void zeeAnaDiff(TH1D* hsee, TCut addCut,TH1D* hseeMc) { TFile *f1=new TFile(fname1.Data()); TTree *zp = (TTree*)f1->Get("tz"); zp->AddFriend("yEvt=yongsunHiEvt" ,fname1.Data()); zp->AddFriend("ySkim=yongsunSkimTree" ,fname1.Data()); zp->AddFriend("yHlt=yongsunHltTree" ,fname1.Data()); zp->AddFriend("tgj", fname1.Data()); TH1D* hmass = new TH1D("hmass",";inv. mass (GeV);event fraction",34,30,200); hmass->Sumw2(); zp->Draw("invm>>hmass",addCut && "isEle1==1 && isEle2==1"); TH1D* htemp = (TH1D*)hsee->Clone("htemp"); htemp->Reset(); zp->Draw("see1>>htemp",addCut && "isEle1==1 && isEle2==1" && "invm>80 && invm<100" ); hsee->Reset(); hsee->Add(htemp); handsomeTH1(hmass,2); scaleInt(hmass); TH1D* htempMC; TFile *f1mc; TTree *zpmc ; f1mc=new TFile(fname1MC.Data()); zpmc = (TTree*)f1mc->Get("tz"); zpmc->AddFriend("yEvt=yongsunHiEvt" ,fname1MC.Data()); zpmc->AddFriend("ySkim=yongsunSkimTree" ,fname1MC.Data()); zpmc->AddFriend("yHlt=yongsunHltTree" ,fname1MC.Data()); zpmc->AddFriend("yPho=yongsunPhotonTree" ,fname1MC.Data()); zpmc->AddFriend("tgj", fname1MC.Data()); hseeMc->Sumw2(); htempMC = (TH1D*)hseeMc->Clone("htempMc"); htempMC->Reset(); TH1D* hmassMC = new TH1D("hmassMC11",";inv. mass (GeV);event fraction",34,30,200); hmassMC->Sumw2(); zpmc->Draw("invm>>hmassMC11",Form("(%s) *yPho.ncoll",addCut.GetTitle())); zpmc->Draw("see1>>htempMc",Form("(%s) *yPho.ncoll", (addCut && "invm>80 && invm<100").GetTitle()) ); hseeMc->Reset(); hseeMc->Add(htempMC); handsomeTH1(hmassMC,1); scaleInt(hmassMC); hmassMC->SetAxisRange(0,0.6,"Y"); hmassMC->DrawCopy(); hmass->DrawCopy("same"); TLegend* leg1 = new TLegend(0.5580645,0.5381356,0.8923387,0.7648305,NULL,"brNDC"); easyLeg(leg1,"Z->ee mass"); leg1->AddEntry(hmass,"DATA","pl"); leg1->AddEntry(hmassMC,"MC","pl"); leg1->Draw(); }
void mc2ibd_NE(TChain *tMC, TFile *fBgnd, TCanvas *cv) { char str[1024]; TLatex *txt = new TLatex(); TH1D *hExp = (TH1D *) fBgnd->Get("hNEA-diff"); if (!hExp) { printf("Histogram hNEA-diff not found in %s\n", fBgnd->GetName()); return; } hExp->SetTitle("Delayed event energy;MeV;Events/200 keV"); hExp->SetLineColor(kBlack); hExp->SetLineWidth(3); gROOT->cd(); TH1D *hMC = new TH1D("hNEMC", "Delayed event energy (MC);MeV;Events/200 keV", 45, 3, 12); hMC->SetLineColor(kBlue); tMC->Project(hMC->GetName(), "NeutronEnergy", cX && cY && cZ && cR && c20 && cGamma && cGammaMax && cPe); hMC->Sumw2(); hMC->Scale(hExp->Integral(15, 45) / hMC->Integral(15,45)); cv->Clear(); hMC->Draw("hist"); hExp->DrawCopy("same"); TLegend *lg = new TLegend(0.65, 0.8, 0.89, 0.89); lg->AddEntry(hExp, "IBD", "LE"); lg->AddEntry(hMC, "MC", "L"); lg->Draw(); }
void mc2ibd_R2(TChain *tMC, TFile *fBgnd, TCanvas *cv) { char str[1024]; TLatex *txt = new TLatex(); TH1D *hExp = (TH1D *) fBgnd->Get("hR2A-diff"); if (!hExp) { printf("Histogram hR2A-diff not found in %s\n", fBgnd->GetName()); return; } hExp->SetTitle("Distance between positron and neutron, 3D case;cm;Events/4cm"); hExp->SetLineColor(kBlack); hExp->SetLineWidth(3); gROOT->cd(); TH1D *hMC = new TH1D("hR2MC", "Distance between positron and neutron, 3D case (MC);cm;Events/4cm", 40, 0, 160); hMC->SetLineColor(kBlue); tMC->Project(hMC->GetName(), "Distance", cX && cY && cZ && cRXY && c20 && cGamma && cGammaMax && cPe && cN); hMC->Sumw2(); hMC->Scale(hExp->Integral() / hMC->Integral()); cv->Clear(); hExp->DrawCopy(); hMC->Draw("hist,same"); TLegend *lg = new TLegend(0.65, 0.8, 0.89, 0.89); lg->AddEntry(hExp, "IBD", "LE"); lg->AddEntry(hMC, "MC", "L"); lg->Draw(); }
void PlotWriteErrors(TFile* input, TFile* output, TString output_folder, TString canvas, TString Hist, TString Opt="") { // Setup the canvas TCanvas *c1= new TCanvas(canvas,canvas,800,700); // Get the histograms from the files TH1D *Data = (TH1D*)input->Get(Hist); //check to make sure there are some events before setting the log scale if(Data->Integral() == 0 ) c1->SetLogy(0); else c1->SetLogy(1); // Fill for histogram Data->SetFillColor(kBlue); Data->GetXaxis()->SetTitleSize(0.06); Data->GetXaxis()->SetTitleOffset(0.75); Data->GetYaxis()->SetTitleSize(0.05); Data->GetYaxis()->SetTitleOffset(1.00); // plot them Data->DrawCopy("hist"); gPad->RedrawAxis(); //write canvas as png c1->Print(TString(output_folder+canvas+".png")); //write canvas to output file output->cd(); c1->Write(); return; }
void DrawHisto(TH1* h_orig, TString name, Option_t *drawopt){ TH1D* h = (TH1D*)h_orig->Clone(name); TString canvname = "canv_"+name; TCanvas *col = new TCanvas(canvname, "", 0, 0, 500, 500); col->SetFillStyle(0); col->SetFrameFillStyle(0); gPad->SetFillStyle(0); gStyle->SetPalette(1); gPad->SetRightMargin(0.15); h->DrawCopy(drawopt); }
void DrawHisto(TH1* h_orig, TString name, Option_t *drawopt, Channel* channel){ TH1D* h = (TH1D*)h_orig->Clone(name); TString canvname = "canv_"+name; TCanvas *col = new TCanvas(canvname, "", 0, 0, 500, 500); col->SetFillStyle(0); col->SetFrameFillStyle(0); gPad->SetFillStyle(0); gStyle->SetPalette(1); gPad->SetRightMargin(0.15); h->DrawCopy(drawopt); // gPad->RedrawAxis(); if(fSaveResults){ col->Write(); } }
TCanvas* pMenu(std::string what) { TCanvas* c = new TCanvas(("cMenu"+what).c_str(),("cMenu"+what).c_str(),1500,400); c->SetBottomMargin(0.6); c->SetLeftMargin(0.04); c->SetRightMargin(0.01); TH1D* h = (TH1D*)gROOT->FindObject(("hMenuAlgos"+what).c_str()); h->SetLineColor(4); h->SetFillColor(4); h->SetFillStyle(3003); h->LabelsOption("v"); h->GetYaxis()->SetLabelOffset(0.005); // h->GetXaxis()->SetRange(550,680); h->DrawCopy(); return c; }
void PlotErrors(TFile* data, TString Hist, TString Opt="") { // Get the histograms from the files TH1D *Data = (TH1D*)data->Get(Hist); //check to make sure there are some events for log scale if(Data->Integral() == 0 ) c1->SetLogy(0); else c1->SetLogy(1); // Fill for histogram Data->SetFillColor(kBlue); // plot them Data->DrawCopy("hist"); gPad->RedrawAxis(); }
void photonEnergyValidate (sampleType collision = kHIMC) { TH1::SetDefaultSumw2(); TFile* f = new TFile("photonEnergyScaleTable_lowPt_v6.root"); TF1* curve[2][4]; // [ conversion 0 or 1 ] [ centrality bin 1,2,3] for ( int icent = 1 ; icent<=3 ; icent++) { curve[0][icent] = (TF1*)f->Get(Form("fit_hscale_r9gt94_%d",icent)); // Not converted curve[1][icent] = (TF1*)f->Get(Form("fit_hscale_r9lt94_%d",icent)); // Converted curve[1][icent]->SetLineStyle(7); } TH1D* htemp = new TH1D("htemp",";p_{T}^{#gamma} (GeV); Residual correction",200,35,200); TCanvas* c1 = new TCanvas("c1","",500,500); handsomeTH1(htemp,0); htemp->SetAxisRange(0.97,1.12,"Y"); htemp->DrawCopy(); for (int icent = 1 ;icent<=3 ; icent++) { curve[0][icent]->Draw("same"); curve[1][icent]->Draw("same"); // onSun(35,1,200,1); } TLegend *l0 = new TLegend(0.4910859,0.5132576,1,0.7102273,NULL,"brNDC"); easyLeg(l0,"r9 > 0.94 : Not Conv"); l0->AddEntry(curve[0][1],"0-10%","l"); l0->AddEntry(curve[0][2],"10-30%","l"); l0->AddEntry(curve[0][3],"30-100%","l"); l0->Draw(); TLegend *l1 = new TLegend(0.4910859,0.7443182,1,0.9318182,NULL,"brNDC"); easyLeg(l1,"r9 < 0.94 : Conv"); l1->AddEntry(curve[1][1],"0-10%","l"); l1->AddEntry(curve[1][2],"10-30%","l"); l1->AddEntry(curve[1][3],"30-100%","l"); l1->Draw(); }
void drawJacob(string fnm="../../output/thinRadiator/o_msc_L001um_03MeV_1e5ev.root"){ TFile *fin=TFile::Open(fnm.c_str(),"READ"); TTree *t=(TTree*)fin->Get("t"); int material, pType, trackID, parentID; double pX, pY, pZ; t->SetBranchAddress("pType", &pType); t->SetBranchAddress("material", &material); t->SetBranchAddress("trackID", &trackID); t->SetBranchAddress("parentID", &parentID); t->SetBranchAddress("postMomX", &pX); t->SetBranchAddress("postMomY", &pY); t->SetBranchAddress("postMomZ", &pZ); int nev = t->GetEntries(); TH1D *scatAng = new TH1D("scatAng","Rate/sin(theta); scattering angle [deg]", 400,0,100); double pi = acos(-1); cout<<"pi "<<pi<<endl; for(int i=0;i<nev;i++){ t->GetEntry(i); if(pType!=11) continue; if(material != 1) continue; if(trackID != 1 || parentID!=0) continue; double r = sqrt( pX*pX + pY*pY + pZ*pZ); if(r==0) continue; double thetaRad = acos(pZ/r); double theta = thetaRad * 180/pi; if(theta<0.01) continue; scatAng->Fill(theta, 1./sin(thetaRad)); } gStyle->SetOptStat("eMRou"); scatAng->DrawCopy(); fin->Close(); }
void draw_graphs(void) { const char title[4][20] = {"Na_mean;um", "Na_sigma;um", "Co_mean;um", "Co_sigma;um"}; const double tgt[4] = {1.787, 0.394, 2.082, 0.473}; const double mc[4][4] = {{2.008, 1.985, 1.974, 1.933}, {0.319, 0.326, 0.330, 0.336}, {2.233, 2.211, 2.185, 2.149}, {0.377, 0.385, 0.394, 0.405}}; const double dl[4] = {0, 50, 100, 200}; const double mm[4][2] = {{1.7, 2.1}, {0.3, 0.4}, {2.0, 2.3}, {0.35, 0.5}}; TGraph *gr; TLine *ln; TH1D *h; TLegend *lg; int i; TCanvas *cv = new TCanvas; cv->Divide(2,2); gr = new TGraph; ln = new TLine; gr->SetMarkerStyle(kFullCircle); gr->SetMarkerSize(1.5); gr->SetMarkerColor(kBlue); ln->SetLineWidth(4); ln->SetLineColor(kRed); lg = new TLegend(0.65, 0.65, 0.95, 0.85); lg->AddEntry(ln, "Exp.", "L"); lg->AddEntry(gr, "MC", "P"); for (i=0; i<4; i++) { cv->cd(i+1); h = new TH1D(title[i], title[i], 100, 0, 200); h->SetMinimum(mm[i][0]); h->SetMaximum(mm[i][1]); h->DrawCopy(); gr->DrawGraph(4, dl, mc[i], "P"); ln->DrawLine(0, tgt[i], 200, tgt[i]); lg->Draw(); delete h; } }
//************************************************************************************************* //Main part of the macro //************************************************************************************************* void AnalyzeYYPhotonEvent(const string InputFilename) { TTree* YYTree = getTreeFromFile(InputFilename.c_str()); assert(YYTree); YYPhotonEvent photon(YYTree); TH1D *plot = new TH1D("hPlot", ";XAxis; Number of Events ", 6, -3,3); for (int n=0;n<YYTree->GetEntries();n++) { photon.GetEntry(n); Double_t weight = photon.photon_branch_weight; //cout << weight << " " << photon.photon_branch_NPhotons << endl; if (photon.photon_branch_NPhotons > 0 ) { plot->Fill(photon.photon_branch_Photon1Eta); } } TCanvas *c = new TCanvas("canvas" , "canvas" , 800, 600); plot->DrawCopy(); }
void chipSummary(const char *dirName, int chipId) { directory = TString(dirName); if (f && f->IsOpen()) f->Close(); if (f1 && f1->IsOpen()) f1->Close(); if (g && g->IsOpen()) g->Close(); gROOT->SetStyle("Plain"); gStyle->SetPalette(1); gStyle->SetOptStat(0); gStyle->SetTitle(0); gStyle->SetStatFont(132); gStyle->SetTextFont(132); gStyle->SetLabelFont(132, "X"); gStyle->SetLabelFont(132, "Y"); gStyle->SetLabelSize(0.08, "X"); gStyle->SetLabelSize(0.08, "Y"); gStyle->SetNdivisions(6, "X"); gStyle->SetNdivisions(8, "Y"); gStyle->SetTitleFont(132); gROOT->ForceStyle(); tl = new TLatex; tl->SetNDC(kTRUE); tl->SetTextSize(0.09); ts = new TLatex; ts->SetNDC(kTRUE); ts->SetTextSize(0.08); line = new TLine; line->SetLineColor(kRed); line->SetLineStyle(kSolid); box = new TBox; box->SetFillColor(kRed); box->SetFillStyle(3002); f = new TFile(Form("%s/%s", dirName, fileName), "READ"); if (strcmp(fileName, adFileName) == 0) f1 = f; else f1 = new TFile(Form("%s/%s", dirName, adFileName), "READ"); if (strcmp(fileName, trimFileName) == 0) g = f; else g = new TFile(Form("%s/%s", dirName, trimFileName), "READ"); sprintf(fname, "%s/../../macros/criteria-full.dat", dirName); if ( !readCriteria(fname) ) { printf("\nchipSummary> ----> COULD NOT READ GRADING CRITERIA !!!"); printf("chipSummary> ----> Aborting execution of chipgSummaryPage.C ... \n\n", fileName, dirName); break; } TH1D *h1; TH2D *h2; c1 = new TCanvas("c1", "", 800, 800); c1->Clear(); c1->Divide(4,4, 0.01, 0.04); // shrinkPad(0.1, 0.1, 0.1, 0.3); FILE *sCurveFile, *phLinearFile, *phTanhFile; TString noslash(dirName); noslash.ReplaceAll("/", " "); noslash.ReplaceAll(".. ", ""); char string[200]; int pixel_alive; int nDeadPixel(0); int nIneffPixel(0); int nMaskDefect(0); int nNoisy1Pixel(0); int nDeadBumps(0); int nDeadTrimbits(0); int nAddressProblems(0); int nNoisy2Pixel(0); int nThrDefect(0); int nGainDefect(0); int nPedDefect(0); int nPar1Defect(0); int nRootFileProblems(0); int nDoubleFunctCounts(0); int nDoublePerfCounts(0); int nDoubleCounts(0); int nDoubleTrims(0); int nDoublePHs(0); int vcal = dac_findParameter(dirName, "Vcal", chipId); // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // Row 1 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // -- Dead pixels c1->cd(1); TH2D *hpm; hpm = (TH2D*)f->Get(Form("PixelMap_C%i", chipId)); if (hpm) { for (int icol = 0; icol < 52; ++icol) { for (int irow = 0; irow < 80; ++irow) { hpm->SetTitle(""); hpm->Draw("colz"); tl->DrawLatex(0.1, 0.92, "Pixel Map"); } } } else { ++nRootFileProblems; } // -- sCurve width and noise level TH1D *hw = new TH1D("hw", "", 100, 0., 600.); TH1D *hd = new TH1D("hd", "", 100, 0., 600.); // Noise in unbonded pixel (not displayed) TH2D *ht = new TH2D("ht", "", 52, 0., 52., 80, 0., 80.); TH1D *htmp; float mN(0.), sN(0.), nN(0.), nN_entries(0.); int over(0), under(0); double htmax(255.), htmin(0.); float thr, sig; int a,b; double minThrDiff(-5.); double maxThrDiff(5.); h2 = (TH2D*)f->Get(Form("vcals_xtalk_C%i", chipId)); sprintf(string, "%s/SCurve_C%i.dat", dirName, chipId); sCurveFile = fopen(string, "r"); if (!sCurveFile) { printf("chipSummary> !!!!!!!!! ----> SCurve: Could not open file %s to read fit results\n", string); } else { for (int i = 0; i < 2; i++) fgets(string, 200, sCurveFile); for (int icol = 0; icol < 52; ++icol) { for (int irow = 0; irow < 80; ++irow) { fscanf(sCurveFile, "%e %e %s %2i %2i", &thr, &sig, string, &a, &b); // printf("chipSummary> sig %e thr %e\n", sig, thr); hw->Fill(sig); thr = thr / 65.; ht->SetBinContent(icol+1, irow+1, thr); if ( h2 ) { if( h2->GetBinContent(icol+1, irow+1) >= minThrDiff) { hd->Fill(sig); } } } } fclose(sCurveFile); c1->cd(2); hw->Draw(); tl->DrawLatex(0.1, 0.92, "S-Curve widths: Noise (e^{-})"); /* c1->cd(15); hd->SetLineColor(kRed); hd->Draw(); tl->DrawLatex(0.1, 0.92, "S-Curve widths of dead bumps"); if ( hd->GetEntries() > 0 ) { ts->DrawLatex(0.55, 0.82, Form("entries: %4.0f", hd->GetEntries())); ts->DrawLatex(0.55, 0.74, Form("#mu:%4.2f", hd->GetMean())); ts->DrawLatex(0.55, 0.66, Form("#sigma: %4.2f", hd->GetRMS())); } */ mN = hw->GetMean(); sN = hw->GetRMS(); nN = hw->Integral(hw->GetXaxis()->GetFirst(), hw->GetXaxis()->GetLast()); nN_entries = hw->GetEntries(); under = hw->GetBinContent(0); over = hw->GetBinContent(hw->GetNbinsX()+1); ts->DrawLatex(0.65, 0.82, Form("N: %4.0f", nN)); ts->DrawLatex(0.65, 0.74, Form("#mu: %4.1f", mN)); ts->DrawLatex(0.65, 0.66, Form("#sigma: %4.1f", sN)); if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under)); if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over )); c1->cd(3); if ( ht->GetMaximum() < htmax ) { htmax = ht->GetMaximum(); } if ( ht->GetMinimum() > htmin ) { htmin = ht->GetMinimum(); } ht->GetZaxis()->SetRangeUser(htmin,htmax); ht->Draw("colz"); tl->DrawLatex(0.1, 0.92, "Vcal Threshold Untrimmed"); } // -- Noise level map c1->cd(4); gPad->SetLogy(1); gStyle->SetOptStat(1); float mV(0.), sV(0.), nV(0.), nV_entries(0.); over = 0.; under = 0.; if (!g->IsZombie()) { h1 = (TH1D*)g->Get(Form("VcalThresholdMap_C%iDistribution;7", chipId)); if (h1) { h1->SetTitle(""); h1->SetAxisRange(0., 100.); h1->Draw(); mV = h1->GetMean(); sV = h1->GetRMS(); nV = h1->Integral(h1->GetXaxis()->GetFirst(), h1->GetXaxis()->GetLast()); nV_entries = h1->GetEntries(); under = h1->GetBinContent(0); over = h1->GetBinContent(h1->GetNbinsX()+1); } else { ++nRootFileProblems; mV = 0.; sV = 0.; } ts->DrawLatex(0.15, 0.82, Form("N: %4.0f", nV)); ts->DrawLatex(0.15, 0.74, Form("#mu: %4.1f", mV)); ts->DrawLatex(0.15, 0.66, Form("#sigma: %4.1f", sV)); if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under)); if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over )); } tl->DrawLatex(0.1, 0.92, "Vcal Threshold Trimmed"); // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // Row 2 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // -- Bump Map TH2D *hbm; c1->cd(5); gStyle->SetOptStat(0); hbm = (TH2D*)f->Get(Form("vcals_xtalk_C%i", chipId)); if (hbm) { h2->SetTitle(""); h2->GetZaxis()->SetRangeUser(minThrDiff, maxThrDiff); h2->Draw("colz"); tl->DrawLatex(0.1, 0.92, "Bump Bonding Problems"); } else { ++nRootFileProblems; } // -- Bump Map c1->cd(6); gPad->SetLogy(1); //gStyle->SetOptStat(1); h1 = (TH1D*)f->Get(Form("vcals_xtalk_C%iDistribution", chipId)); if (h1) { h1->SetTitle(""); h1->GetXaxis()->SetRangeUser(-50., 50.); h1->GetYaxis()->SetRangeUser(0.5, 5.0*h1->GetMaximum()); h1->DrawCopy(); tl->DrawLatex(0.1, 0.92, "Bump Bonding"); } else { ++nRootFileProblems; } // -- Trim bits int trimbitbins(3); c1->cd(7); gPad->SetLogy(1); h1 = (TH1D*)f->Get(Form("TrimBit14_C%i", chipId)); if (h1) { h1->SetTitle(""); h1->SetAxisRange(0., 60.); h1->SetMinimum(0.5); h1->Draw(""); tl->DrawLatex(0.1, 0.92, "Trim Bit Test"); } else { ++nRootFileProblems; } h1 = (TH1D*)f->Get(Form("TrimBit13_C%i", chipId)); if (h1) { h1->SetLineColor(kRed); h1->Draw("same"); } else { ++nRootFileProblems; } h1 = (TH1D*)f->Get(Form("TrimBit11_C%i", chipId)); if (h1) { h1->SetLineColor(kBlue); h1->Draw("same"); } else { ++nRootFileProblems; } h1 = (TH1D*)f->Get(Form("TrimBit7_C%i", chipId)); if (h1) { h1->SetLineColor(kGreen); h1->Draw("same"); } else { ++nRootFileProblems; } // -- For numerics and titels see at end // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // Row 3 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // -- Address decoding // -------------------- TH2D *ham; ham = (TH2D*)f1->Get(Form("AddressDecoding_C%i", chipId)); c1->cd(9); gStyle->SetOptStat(0); if (ham) { ham->SetTitle(""); ham->Draw("colz"); tl->DrawLatex(0.1, 0.92, "Address decoding"); } else { ++nRootFileProblems; } // -- Address levels c1->cd(10); gPad->SetLogy(1); h1 = (TH1D*)f1->Get(Form("AddressLevels_C%i", chipId)); if (h1) { h1->SetTitle(""); h1->SetAxisRange(-1500., 1500.); h1->Draw(); tl->DrawLatex(0.1, 0.92, "Address Levels"); } else { ++nRootFileProblems; } // -- PHCalibration: Linear Fit (Gain & Pedesdtal) // ----------------------------------------------- TH1D *hg = new TH1D("hg", "", 300, -2.0, 5.5); TH2D *hgm = new TH2D("hgm", "", 52, 0., 52., 80, 0., 80.); TH1D *hp = new TH1D("hp", "", 900, -300., 600.); hp->StatOverflows(kTRUE); TH1D *rp = new TH1D("rp", "", 900, -300., 600.); rp->StatOverflows(kFALSE); TH1D *htmp; float par0, par1, par2, par3, par4, par5; // Parameters of Vcal vs. Pulse Height Fit float mG(0.), sG(0.), nG(0.), nG_entries(0.); float mP(0.), sP(0.), nP(0.), nP_entries(0.); over = 0.; under = 0.; float ped, gain; int a,b; int mPbin(0), xlow(-100), xup(255), extra(0); // for restricted RMS float pedMin(0), pedMax(1000); double integral(0.); sprintf(string, "%s/phCalibrationFit_C%i.dat", dirName, chipId); phLinearFile = fopen(string, "r"); if (!phLinearFile) { printf("chipSummary> !!!!!!!!! ----> phCal: Could not open file %s to read fit results\n", string); } else { for (int i = 0; i < 2; i++) fgets(string, 200, phLinearFile); for (int icol = 0; icol < 52; ++icol) { for (int irow = 0; irow < 80; ++irow) { fscanf(phLinearFile, "%e %e %e %e %e %e %s %2i %2i", &par0, &par1, &par2, &par3, &par4, &par5, string, &a, &b); if (par2 != 0.) { // dead pixels have par2 == 0. gain = 1./par2; ped = par3; hp->Fill(ped); hg->Fill(gain); hgm->SetBinContent(icol + 1, irow + 1, gain); } } } fclose(phLinearFile); // -- Gain c1->cd(11); mG = hg->GetMean(); sG = hg->GetRMS(); nG = hg->Integral(hg->GetXaxis()->GetFirst(), hg->GetXaxis()->GetLast()); nG_entries = hg->GetEntries(); under = hg->GetBinContent(0); over = hg->GetBinContent(hp->GetNbinsX()+1); gPad->SetLogy(1); hg->GetYaxis()->SetRangeUser(0.5, 5.0*hg->GetMaximum()); hg->Draw(); tl->DrawLatex(0.1, 0.92, "PH Calibration: Gain (ADC/DAC)"); if ( hg->GetMean() > 1.75 ) { ts->DrawLatex(0.15, 0.80, Form("N: %4.0f", nG)); ts->DrawLatex(0.15, 0.72, Form("#mu: %4.2f", mG)); ts->DrawLatex(0.15, 0.64, Form("#sigma: %4.2f", sG)); } else { ts->DrawLatex(0.65, 0.80, Form("N: %4.0f", nG)); ts->DrawLatex(0.65, 0.72, Form("#mu: %4.2f", mG)); ts->DrawLatex(0.65, 0.64, Form("#sigma: %4.2f", sG)); } if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under)); if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over )); c1->cd(15); hgm->Draw("colz"); tl->DrawLatex(0.1, 0.92, "PH Calibration: Gain (ADC/DAC)"); // -- Pedestal c1->cd(12); mP = hp->GetMean(); sP = hp->GetRMS(); nP = hp->Integral(hp->GetXaxis()->GetFirst(), hp->GetXaxis()->GetLast()); nP_entries = hp->GetEntries(); if ( nP > 0 ) { // -- restricted RMS integral = 0.; mPbin = -1000; xlow = -1000; xup = 1000; over = 0.; under = 0.; mPbin = hp->GetXaxis()->FindBin(mP); for (int i = 0; integral < pedDistr; i++) { xlow = mPbin-i; xup = mPbin+i; integral = hp->Integral(xlow, xup)/nP; } extra = xup - xlow; } else { xlow = -300; xup = 600; extra = 0; over = 0.; under = 0.; } under = hp->Integral(0, xlow - extra); over = hp->Integral(xup + 1.5*extra, hp->GetNbinsX()); hp->GetXaxis()->SetRange(xlow - extra, xup + 1.5*extra); nP = hp->Integral(hp->GetXaxis()->GetFirst(), hp->GetXaxis()->GetLast()); pedMin = hp->GetBinCenter(xlow-extra); pedMax = hp->GetBinCenter(xup+1.5*extra); cout<< " ========> Ped min " << pedMin << " Ped max " << pedMax << ", over: " << over << " under: " << under << endl; hp->DrawCopy(); rp->Add(hp); rp->GetXaxis()->SetRange(xlow, xup); mP = rp->GetMean(); sP = rp->GetRMS(); // box->DrawBox( rp->GetBinCenter(xlow), 0, rp->GetBinCenter(xup), 1.05*rp->GetMaximum()); rp->SetFillColor(kRed); rp->SetFillStyle(3002); rp->Draw("same"); line->DrawLine(rp->GetBinCenter(xlow), 0, rp->GetBinCenter(xlow), 0.6*rp->GetMaximum()); line->DrawLine(rp->GetBinCenter(xup), 0, rp->GetBinCenter(xup), 0.6*rp->GetMaximum()); tl->DrawLatex(0.1, 0.92, "PH Calibration: Pedestal (DAC)"); if ( hp->GetMean() < 126. ) { ts->DrawLatex(0.65, 0.82, Form("N: %4.0f", nP)); ts->SetTextColor(kRed); ts->DrawLatex(0.65, 0.74, Form("#mu: %4.1f", mP)); ts->DrawLatex(0.65, 0.66, Form("#sigma: %4.1f", sP)); } else { ts->DrawLatex(0.16, 0.82, Form("N: %4.0f", nP)); ts->SetTextColor(kRed); ts->DrawLatex(0.16, 0.74, Form("#mu: %4.1f", mP)); ts->DrawLatex(0.16, 0.66, Form("#sigma: %4.1f", sP)); } if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under)); if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over )); ts->SetTextColor(kBlack); } // -- PHCalibration: Tanh Fit (Parameter1) // ---------------------------------------- c1->cd(11); over = 0.; under = 0.; float nPar1(0.), nPar1_entries(0.), mPar1(0.), sPar1(0.); TH1D *hPar1 = new TH1D("par1", "", 350, -1., 6.); sprintf(string, "%s/phCalibrationFitTan_C%i.dat", dirName, chipId); phTanhFile = fopen(string, "r"); if (!phTanhFile) { printf("chipSummary> !!!!!!!!! ----> phCal: Could not open file %s to read fit results\n", string); } else { for (int i = 0; i < 2; i++) fgets(string, 200, phTanhFile); for (int icol = 0; icol < 52; ++icol) { for (int irow = 0; irow < 80; ++irow) { fscanf(phTanhFile, "%e %e %e %e %s %2i %2i", &par0, &par1, &par2, &par3, string, &a, &b); hPar1->Fill(par1); } } fclose(phTanhFile); // -- Parameter 1 hPar1->SetLineColor(kBlue); hPar1->Draw("same"); mPar1 = hPar1->GetMean(); sPar1 = hPar1->GetRMS(); nPar1 = hPar1->Integral(hPar1->GetXaxis()->GetFirst(), hPar1->GetXaxis()->GetLast()); nPar1_entries = hPar1->GetEntries(); under = hPar1->GetBinContent(0); over = hPar1->GetBinContent(hPar1->GetNbinsX()+1); ts->SetTextColor(kBlue); if ( hg->GetMean() > 1.75 ) { ts->DrawLatex(0.15, 0.40, "Par1:"); ts->DrawLatex(0.15, 0.30, Form("N: %4.0f", nPar1)); ts->DrawLatex(0.15, 0.22, Form("#mu: %4.2f", mPar1)); ts->DrawLatex(0.15, 0.14, Form("#sigma: %4.2f", sPar1)); } else { ts->DrawLatex(0.65, 0.40, "Par1:"); ts->DrawLatex(0.65, 0.30, Form("N: %4.0f", nPar1)); ts->DrawLatex(0.65, 0.22, Form("#mu: %4.2f", mPar1)); ts->DrawLatex(0.65, 0.14, Form("#sigma: %4.2f", sPar1)); } if ( under ) ts->DrawLatex(0.15, 0.48, Form("<= %i", under)); if ( over ) ts->DrawLatex(0.75, 0.48, Form("%i =>", over )); ts->SetTextColor(kBlack); } // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // Row 4 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // Trim Bits // ---------- TH2D *htm = new TH2D("htm", "", 80, 0., 80., 52, 0., 52.); c1->cd(13); gStyle->SetOptStat(0); h2 = (TH2D*)f->Get(Form("TrimMap_C%i;8", chipId)); if (h2) { for (int icol = 0; icol < 52; ++icol) { for (int irow = 0; irow < 80; ++irow) { htm->SetBinContent(irow+1, icol+1, h2->GetBinContent(icol+1, irow+1)); } } h2->SetTitle(""); h2->GetZaxis()->SetRangeUser(0., 16.); h2->Draw("colz"); } else { ++nRootFileProblems; } tl->DrawLatex(0.1, 0.92, "Trim Bits"); FILE *tCalFile; sprintf(string, "%s/../T-calibration/TemperatureCalibration_C%i.dat", dirName, chipId); tCalFile = fopen(string, "r"); char tCalDir[200]; sprintf(tCalDir, "%s/../T-calibration", dirName); if ( tCalFile ) { analyse(tCalDir, chipId); } else { c1->cd(14); TGraph *graph = (TGraph*)f->Get(Form("TempCalibration_C%i", chipId)); if ( graph ) { graph->Draw("A*"); } else { ++nRootFileProblems; } tl->DrawLatex(0.1, 0.92, "Temperature calibration"); } // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // -- Count defects and double counting // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% float fl0, fl1, fl2, fl3, fl4, fl5, tmp; int i1, i2; char hname[200]; // TH2D *get = 0, *hget = 0, *htb0 = 0, *htb1 = 0, *htb2 = 0, *htb3 = 0, *htb4 = 0; // for (int i = 1; i < 6; ++i) { // get = (TH2D*)f->Get(Form("CalThresholdMap_C%i;%i", chipId, i)); // if (get) { // hget = (TH2D*)get->Clone(); // hget->SetName(Form("TB0C%i", i)); // if (i == 1) htb0 = hget; // if (i == 2) htb1 = hget; // if (i == 3) htb2 = hget; // if (i == 4) htb3 = hget; // if (i == 5) htb4 = hget; // } // } TH2D *htb[5]; for (int i = 0; i < 5; ++i) { htb[i] = (TH2D*)f->Get(Form("CalThresholdMap_C%i;%i", chipId, i+1)); htb[i]->SetName(Form("tbC%i%i", chipId, i+1)); } TH2D *htthr = 0; htthr = (TH2D*)f->Get(Form("VcalThresholdMap_C%d;8", chipId)); sprintf(string, "%s/SCurve_C%i.dat", dirName, chipId); sCurveFile = fopen(string, "r"); sprintf(string, "%s/phCalibrationFit_C%i.dat", dirName, chipId); phLinearFile = fopen(string, "r"); sprintf(string, "%s/phCalibrationFitTan_C%i.dat", dirName, chipId); phTanhFile = fopen(string, "r"); if (sCurveFile) for (int i = 0; i < 2; i++) fgets(string, 200, sCurveFile); if (phLinearFile) for (int i = 0; i < 2; i++) fgets(string, 200, phLinearFile); if (phTanhFile) for (int i = 0; i < 2; i++) fgets(string, 200, phTanhFile); int px_counted = 0; int px_funct_counted = 0; int px_perf_counted = 0; int trim_counted = 0; int ph_counted = 0; float tb_diff = 0; float tb, tb0; for (int icol = 0; icol < 52; ++icol) { for (int irow = 0; irow < 80; ++irow) { pixel_alive = 1; px_funct_counted = 0; px_perf_counted = 0; px_counted = 0; trim_counted = 0; ph_counted = 0; // -- Pixel alive if (hpm && hpm->GetBinContent(icol+1, irow+1) == 0) { pixel_alive = 0; ++nDeadPixel; cout << Form("chipSummary> dead pixel %3d %3d: %7.5f", icol, irow, hpm->GetBinContent(icol+1, irow+1)) << endl; } if (hpm && hpm->GetBinContent(icol+1,irow+1) > 10) { ++nNoisy1Pixel; px_counted = 1; px_funct_counted = 1;} if (hpm && hpm->GetBinContent(icol+1, irow+1) < 0) { ++nMaskDefect; px_counted = 1; px_funct_counted = 1;} if (hpm && (hpm->GetBinContent(icol+1, irow+1) < 10) && (hpm->GetBinContent(icol+1, irow+1) > 0) ) { ++nIneffPixel; px_counted = 1; px_funct_counted = 1;} // -- Bump bonding if ( pixel_alive && hbm ) { if ( hbm->GetBinContent(icol+1, irow+1) >= minThrDiff ) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_funct_counted ) nDoubleFunctCounts++; px_funct_counted = 1; ++nDeadBumps; cout << Form("chipSummary> bump defect %3d %3d: %7.5f", icol, irow, hbm->GetBinContent(icol+1, irow+1)) << endl; } } // -- Trim bits 1 - 4 if ( pixel_alive && htb[0] ) { tb0 = htb[0]->GetBinContent(icol+1, irow+1); for ( int i = 1; i <= 4; i++ ) { if ( htb[i] ) { tb = htb[i]->GetBinContent(icol+1, irow+1); tb_diff = TMath::Abs(tb-tb0); if (tb_diff <= 2) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_funct_counted ) nDoubleFunctCounts++; px_funct_counted = 1; if ( trim_counted ) nDoubleTrims++; trim_counted = 1; ++nDeadTrimbits; cout << Form("chipSummary> trim bit defect %3d %3d: %4.2f", icol, irow, tb_diff) << endl; } } } } // -- Address decoding if (pixel_alive && ham) { if( ham->GetBinContent(icol+1, irow+1) < 1 ) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_funct_counted ) nDoubleFunctCounts++; px_funct_counted = 1; ++nAddressProblems; cout << Form("chipSummary> address problem %3d %3d: %7.5f", icol, irow, ham->GetBinContent(icol+1, irow+1)) << endl; } } // -- Threshold if (pixel_alive && htthr) { if ( TMath::Abs(htthr->GetBinContent(icol+1, irow+1) - vcalTrim) > tthrTol ) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_perf_counted ) nDoublePerfCounts++; px_perf_counted = 1; ++nThrDefect; cout << Form("chipSummary> threshold problem %3d %3d: %7.5f", icol, irow, htthr->GetBinContent(icol+1, irow+1)) << endl; } } // -- Noise fscanf(sCurveFile, "%e %e %s %2i %2i", &fl1, &fl2, string, &i1, &i2); if (pixel_alive) { if ( (fl2 < noiseMin) || (fl2 > noiseMax) ) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_perf_counted ) nDoublePerfCounts++; px_perf_counted = 1; ++nNoisy2Pixel; cout << Form("chipSummary> noise defect %3d %3d: %7.5f (%2i %2i)", icol, irow, fl2, i1, i2) << endl; } } // -- Gain & Pedestal fscanf(phLinearFile, "%e %e %e %e %e %e %s %2i %2i", &fl0, &fl1, &fl2, &fl3, &fl4, &fl5, string, &i1, &i2); if (pixel_alive) { if (fl2 != 0) gain = 1./fl2; ped = fl3; if ( (gain < gainMin) || (gain > gainMax) ) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_perf_counted ) nDoublePerfCounts++; px_perf_counted = 1; if ( ph_counted ) nDoublePHs++; ph_counted = 1; ++nGainDefect; cout << Form("chipSummary> gain defect %3d %3d: %7.5f (%2i %2i)", icol, irow, gain, i1, i2) << endl; } if ( (ped < pedMin) || (ped > pedMax) ) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_perf_counted ) nDoublePerfCounts++; px_perf_counted = 1; if ( ph_counted ) nDoublePHs++; ph_counted = 1; ++nPedDefect; cout << Form("chipSummary> pedestal defect %3d %3d: %7.5f (%2i %2i)", icol, irow, ped, i1, i2) << endl; } } // -- Par1 fscanf(phTanhFile, "%e %e %e %e %s %2i %2i", &fl0, &fl1, &fl2, &fl3, string, &i1, &i2); if (pixel_alive && phTanhFile) { if ( (fl1 < par1Min) || (fl1 > par1Max) ) { if ( px_counted ) nDoubleCounts++; px_counted = 1; if ( px_perf_counted ) nDoublePerfCounts++; px_perf_counted = 1; if ( ph_counted ) nDoublePHs++; ph_counted = 1; ++nPar1Defect; cout << Form("chipSummary> par1 defect %3d %3d: %7.5f (%2i %2i)", icol, irow, par1, i1, i2) << endl; } } } } fclose(sCurveFile); fclose(phLinearFile); fclose(phTanhFile); // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // Numerics and Titles // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // -- Compute the final verdict on this chip //?? FIXME (below is pure randomness) float finalVerdict(0); if (nDeadTrimbits > 0) finalVerdict += 1; if (nDeadPixel > 0) finalVerdict += 10; if (nNoisy1Pixel > 0) finalVerdict += 10; if (nAddressProblems > 0) finalVerdict += 10; if (nDeadBumps > 0) finalVerdict += 100; if (nNoisy2Pixel > 0) finalVerdict += 1000; if (nThrDefect > 0) finalVerdict += 10000; if (nGainDefect > 0) finalVerdict += 100000; if (nPedDefect > 0) finalVerdict += 100000; if (nPar1Defect > 0) finalVerdict += 100000; // -- Defects c1->cd(8); tl->SetTextSize(0.10); tl->SetTextFont(22); double y = 0.98; y -= 0.11; tl->DrawLatex(0.1, y, "Summary"); // tl->DrawLatex(0.6, y, Form("%06d", finalVerdict)); tl->SetTextFont(132); tl->SetTextSize(0.09); y -= 0.11; tl->DrawLatex(0.1, y, Form("Dead Pixels: ")); tl->DrawLatex(0.7, y, Form("%4d", nDeadPixel)); // y -= 0.10; // tl->DrawLatex(0.1, y, Form("Noisy Pixels 1: ")); // tl->DrawLatex(0.7, y, Form("%4d", nNoisy1Pixel)); y -= 0.10; tl->DrawLatex(0.1, y, "Mask defects: "); tl->DrawLatex(0.7, y, Form("%4d", nMaskDefect)); y -= 0.10; tl->DrawLatex(0.1, y, "Dead Bumps: "); tl->DrawLatex(0.7, y, Form("%4d", nDeadBumps)); y -= 0.10; tl->DrawLatex(0.1, y, "Dead Trimbits: "); tl->DrawLatex(0.7, y, Form("%4d", nDeadTrimbits)); y -= 0.10; tl->DrawLatex(0.1, y, "Address Probl: "); tl->DrawLatex(0.7, y, Form("%4d", nAddressProblems)); y -= 0.10; tl->DrawLatex(0.1, y, Form("Noisy Pixels 2: ")); tl->DrawLatex(0.7, y, Form("%4d", nNoisy2Pixel)); y -= 0.10; tl->DrawLatex(0.1, y, Form("Trim Probl.: ")); tl->DrawLatex(0.7, y, Form("%4d", nThrDefect)); y -= 0.10; tl->DrawLatex(0.1, y, Form("PH defects: ")); tl->DrawLatex(0.5, y, Form("%4d/", nGainDefect)); tl->SetTextColor(kRed); tl->DrawLatex(0.6, y, Form("%4d/",nPedDefect)); tl->SetTextColor(kBlack); tl->SetTextColor(kBlue); tl->DrawLatex(0.7, y, Form("%4d",nPar1Defect)); tl->SetTextColor(kBlack); // y -= 0.10; // tl->DrawLatex(0.1, y, Form("Par1 defect: ")); // tl->DrawLatex(0.7, y, Form("%4d", nPar1Defect)); // -- Operation Parameters c1->cd(16); y = 0.92; tl->SetTextSize(0.10); tl->SetTextFont(22); y -= 0.11; tl->DrawLatex(0.1, y, Form("Op. Parameters")); tl->SetTextFont(132); tl->SetTextSize(0.09); y -= 0.11; int vana(-1.); vana = dac_findParameter(dirName, "Vana", chipId); tl->DrawLatex(0.1, y, "VANA: "); if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3i DAC", vana)); else tl->DrawLatex(0.7, y, "N/A"); y -= 0.10; int caldel(-1.); caldel = dac_findParameter(dirName, "CalDel", chipId); tl->DrawLatex(0.1, y, "CALDEL: "); if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", caldel)); else tl->DrawLatex(0.7, y, "N/A"); y -= 0.10; int vthrcomp(-1.); vthrcomp = dac_findParameter(dirName, "VthrComp", chipId); tl->DrawLatex(0.1, y, "VTHR: "); if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", vthrcomp)); else tl->DrawLatex(0.7, y, "N/A"); y -= 0.10; int vtrim(-1.); vtrim = dac_findParameter(dirName, "Vtrim", chipId); tl->DrawLatex(0.1, y, "VTRIM: "); if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", vtrim)); else tl->DrawLatex(0.7, y, "N/A"); y -= 0.10; int ibias(-1.); ibias = dac_findParameter(dirName, "Ibias_DAC", chipId); tl->DrawLatex(0.1, y, "IBIAS_DAC: "); if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", ibias)); else tl->DrawLatex(0.7, y, "N/A"); y -= 0.10; int voffset(-1.); voffset = dac_findParameter(dirName, "VoffsetOp", chipId); tl->DrawLatex(0.1, y, "VOFFSETOP: "); if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", voffset)); else tl->DrawLatex(0.7, y, "N/A"); // -- Page title c1->cd(0); tl->SetTextSize(0.04); tl->SetTextFont(22); tl->DrawLatex(0.02, 0.97, Form("%s (C%i)", noslash.Data(), chipId)); TDatime date; tl->SetTextSize(0.02); tl->DrawLatex(0.75, 0.97, Form("%s", date.AsString())); c1->SaveAs(Form("%s/chipSummary_C%i.ps", dirName, chipId)); c1->SaveAs(Form("%s/C%i.png", dirName, chipId)); // -- Dump into logfile ofstream OUT(Form("%s/summary_C%i.txt", dirName, chipId)); OUT << "nDeadPixel: " << nDeadPixel << endl; OUT << "nNoisy1Pixel: " << nNoisy1Pixel << endl; OUT << "nDeadTrimbits: " << nDeadTrimbits << endl; OUT << "nDeadBumps: " << nDeadBumps << endl; OUT << "nMaskDefect: " << nMaskDefect << endl; OUT << "nAddressProblems: " << nAddressProblems << endl; OUT << "nNoisy2Pixel: " << nNoisy2Pixel << endl; OUT << "nTThrDefect: " << nThrDefect << endl; OUT << "nGainDefect: " << nGainDefect << endl; OUT << "nPedDefect: " << nPedDefect << endl; OUT << "nParDefect: " << nPar1Defect << endl; OUT << "nDoubleCounts: " << nDoubleCounts << endl; OUT << "nDoubleFunctCounts: " << nDoubleFunctCounts << endl; OUT << "nDoublePerfCounts: " << nDoublePerfCounts << endl; OUT << "nDoubleTrims: " << nDoubleTrims << endl; OUT << "nDoublePHs: " << nDoublePHs << endl; OUT << "nRootFileProblems: " << nRootFileProblems << endl; OUT << "SCurve " << nN_entries << " " << mN << " " << sN << endl; OUT << "Threshold " << nV_entries << " " << mV << " " << sV << endl; OUT << "Gain " << nG_entries << " " << mG << " " << sG << endl; OUT << "Pedestal " << nP_entries << " " << mP << " " << sP << endl; OUT << "Parameter1 " << nPar1_entries << " " << mPar1 << " " << sPar1 << endl; OUT.close(); }
void scan2() { /* TFile f1("hist.root"); TFile f2("SysTot.root"); TH1D *datahist = (TH1D*)f1.Get("datahist"); TH1D *fithist = (TH1D*)f1.Get("fithist"); TH1D *totlow = (TH1D*)f2.Get("totlow"); TH1D *tothigh = (TH1D*)f2.Get("tothigh"); */ TF1 *fun1 = new TF1("fun",fun,0,1000,3); TFile f("Output.root"); TH1F *datahist = dynamic_cast<TH1F*> (f.Get("InvMass")); TH1F *fithist = dynamic_cast<TH1F*> (f.Get("hist_err")); TH1F *tothigh = dynamic_cast<TH1F*> (f.Get("SystPlus")); TH1F *totlow = dynamic_cast<TH1F*> (f.Get("SystMinus")); new TCanvas(); datahist->DrawCopy(); fithist->DrawCopy("same"); gPad->SetEditable(0); /* if (datahist->IsZombie()) { std::cout << "Err! datahist not found " << std::endl; return; } if (fithist->IsZombie()) { std::cout << "Err! err_hist not found " << std::endl; return; } if (tothigh->IsZombie()) { std::cout << "Err! syst_plus hist not found " << std::endl; return; } if (totlow->IsZombie()) { std::cout << "Err! syst_minus hist not found " << std::endl; return; } */ TH1D *p = new TH1D("p","Probability",100,150,900); for (int i = 1; i<=fithist->GetNbinsX(); i++) { double mass = fithist->GetBinCenter(i); if (mass>440 && mass<450) { double sigma = sqrt(2.0)*sqrt(pow(0.135*sqrt(mass/2.0),2)+ pow(0.02*(mass/2.0),2)); cout<< " ===================== mass +/- sigma = " << mass<<"+/-"<<sigma<<endl; int bin1 = fithist->FindBin(mass-sigma/2); int bin2 = fithist->FindBin(mass+sigma/2); cout<<mass<<" "<<bin1<<" "<<bin2<<endl; double data = 0; double bg = 0; double err = 0; for (int j = bin1; j<=bin2; j++) { data+=datahist->GetBinContent(j); bg+=fithist->GetBinContent(j); double err1 = -totlow->GetBinContent(j); double err2 = tothigh->GetBinContent(j); err+=TMath::Max(err1,err2)*bg; //why multiply by bg??? } cout << "Total Data/Bg+/-err in mass window[" << mass << "] = "<< data <<"/ "<< bg << "+/-" << err <<endl; double prob = 0; fun1->SetParameter(0,bg); fun1->SetParameter(1,err); for (int j = int(data+0.001); j<100; j++) { fun1->SetParameter(2,j); //fun1->Print(); //cout << "Evaluating Intrgral for j = " << j << " from x0= " << TMath::Max(0.0,bg-10*err) << " to x1 = " << bg+10*err << endl; double val = fun1->Integral(TMath::Max(0.0,bg-10*err),bg+10*err); //double val = fun1->Integral(TMath::Max(0.0,bg-2*err),bg+2*err); /*for (int z=TMath::Max(0.0,bg-2*err); z < bg+2*err; ++z) { if (c<4) { std::cout << "func at [" << z << "]=" << fun1->Eval(z) << std::endl; } } */ prob += val; } cout<< "Prob for mass[" << mass<<"]="<< prob <<endl; p->SetBinContent(p->FindBin(mass),prob); } } /* delete gRandom; gRandom = (TRandom*) new TRandom3; gRandom->SetSeed(3); TH1D *minp = new TH1D("minp","Minimum Probability of Each PseudoExpt",100,0,0.2); //int nexp = 50000; int nexp = 10; TH1D *htemp = (TH1D*)datahist->Clone("htemp"); for (int iexp = 0; iexp<nexp; iexp++){ //if (iexp%10==0) cout<<iexp<<endl; //generate pseudo-experiments htemp->Reset(); for (int i = 1; i<=htemp->GetNbinsX(); i++){ double mass = htemp->GetBinCenter(i); if (mass>150&&mass<650){ double bg = fithist->GetBinContent(i); double err1 = -totlow->GetBinContent(i); double err2 = tothigh->GetBinContent(i); double err = TMath::Max(err1,err2)*bg; double mean = gRandom->Gaus(bg,err); if (mean<0) mean = 0; htemp->SetBinContent(i,gRandom->Poisson(mean)); } } double minprob = 2.; for (int i = 1; i<=fithist->GetNbinsX(); i++){ double mass = fithist->GetBinCenter(i); if (mass>150&&mass<650){ double sigma = sqrt(2.0)*sqrt(pow(0.135*sqrt(mass/2.0),2)+ pow(0.02*(mass/2.0),2)); //cout<<mass<<" "<<sigma<<endl; int bin1 = fithist->FindBin(mass-sigma/2); int bin2 = fithist->FindBin(mass+sigma/2); //cout<<mass<<" "<<bin1<<" "<<bin2<<endl; double data = 0; double bg = 0; double err = 0; for (int j = bin1; j<=bin2; j++){ data+=htemp->GetBinContent(j); bg+=fithist->GetBinContent(j); double err1 = -totlow->GetBinContent(j); double err2 = tothigh->GetBinContent(j); err+=TMath::Max(err1,err2)*bg; } //cout<<mass<<" "<<data<<" "<<bg<<" "<<err<<endl; double prob = 0; fun1->SetParameter(0,bg); fun1->SetParameter(1,err); for (int j = int(data+0.001); j<100; j++){ fun1->SetParameter(2,j); prob += fun1->Integral(TMath::Max(0.0,bg-10*err),bg+10*err); } if (prob<minprob) minprob=prob; } } minp->Fill(minprob); } */ TCanvas *c1 = new TCanvas("c1","c1"); TH2D *fr = new TH2D("fr","",100,150,900,100,1e-5,2); fr->SetStats(0); fr->SetXTitle("M(#gamma,lead jet)(GeV)"); fr->SetYTitle("Prob of fluctuation #geq N_{obs}"); fr->GetXaxis()->CenterTitle(); fr->GetYaxis()->CenterTitle(); fr->DrawCopy(); p->SetLineWidth(2); p->DrawCopy("same"); double minp=0; double mgg=0; double minc = 10; for (int i = 1; i<=p->GetNbinsX(); i++) { double bin = p->GetBinCenter(i); double binc = p->GetBinContent(i); if (binc<minc) { minp = binc; mgg = bin; minc = binc; } } cout<<mgg<<" "<<minp<<endl; gPad->SetLogy(); double p1s = 0.00458319; double m1s = 0.0435982; double s3s = 0.000100319; TLine *l1 = new TLine(150,p1s,900,p1s); TLine *l2 = new TLine(150,m1s,900,m1s); TLine *l3 = new TLine(150,s3s,900,s3s); l1->SetLineColor(4); l2->SetLineColor(4); l3->SetLineColor(2); l1->SetLineWidth(2); l2->SetLineWidth(2); l3->SetLineWidth(2); l1->Draw(); l2->Draw(); l3->Draw(); TLatex *t1 = new TLatex(250,m1s/4,"Expected Range for Min. Obs. Prob."); t1->SetTextColor(4); t1->SetTextSize(0.05); t1->Draw(); TLatex *t2 = new TLatex(350,s3s*1.5,"3 #sigma evidence level"); t2->SetTextColor(2); t2->SetTextSize(0.05); t2->Draw(); TLatex *t3 = new TLatex(0.3,0.93,"CDF Run II Preliminary, 2.0 fb^{-1}"); t3->SetNDC(true); t3->SetTextSize(0.06); t3->Draw(); // // TCanvas *c2 = new TCanvas("c2","c2"); // minp->DrawCopy(); //cout<<minp->GetMean()<<endl; }
void get_nn_ptpt_FROM_FB_TREE() // TString inputFileName = "MergedOutput.root") { // TFile *myFile = new TFile( "/Users/macbook/alice/aliceAnalysis/results/task_2016_02_09_PbPb_Data_AOD_3etaWins_phi1_pt02_20_FB_TREE_blocks123/block1/AnalysisResults.139465.root" ); TFile *myFile = new TFile( "/Users/macbook/alice/aliceAnalysis/results/task_2016_02_21_PbPb_Data_AOD_3etaWins_phi1_pt02_20_FB_TREE_TEST_NEW_DATA_5_02TeV_tryAOD2/MergedOutput.root" ); if (!myFile) { cout << "No input file!" << endl; return; } myFile->ls(); TList *listKeys = myFile->GetListOfKeys(); cout << "going into list: " << listKeys->At(1)->GetName() << endl; //return; myFile->cd( listKeys->At(1)->GetName() ); TList *listKeys2 = gDirectory->GetListOfKeys(); TList *myTask = (TList*) gDirectory->Get( listKeys2->At(0)->GetName() ); TTree *t1 = (TTree*) myTask->FindObject( "treeFB" ); // cout << t1->GetEntries() << endl; //t1->Print(); //return; // TFile *f = new TFile( "file_event_tree_merged_impPar_2files.root" ); // TTree *t1 = (TTree*) f->Get( "t1" ); // TFile *f = new TFile( "output_1_list.grid.root" ); // TList *list = (TList*) f->Get( "coutput_V0_mult_0.000000_100000.000000" ); // TTree *t1 = (TTree*) list->FindObject( "t1" ); //other vars: // const int nVars = 3; // TString strVarName[] = { // "centr_V0M" , // "centr_CL1" , // "centr_ZEMvsZDC" , // }; // Float_t varBranch[nVars]; // for(Int_t var = 0; var < nVars; var++) // t1->SetBranchAddress(strVarName[var],&varBranch[var]); Float_t brV0M; // t1->SetBranchAddress( "centr_V0M", &brV0M ); t1->SetBranchAddress( "centrV0M_NEW_MULT_SEL", &brV0M ); Float_t brZEMvsZDC; t1->SetBranchAddress( "centr_ZEMvsZDC", &brZEMvsZDC ); // const int nCW = 1; //nCentrWidths // const double cWidths[nCW] = { 10 }; //width of the centrality bins // const double cStep[nCW] = { 5 }; //centrality bins step // const int nCentrBins[nCW] = { 17 }; //n centrality bins // const int nCW = 2; //nCentrWidths // const double cWidths[nCW] = { 10, 5.001 }; //width of the centrality bins // const double cStep[nCW] = { 5, 2.5 }; //centrality bins step // const int nCentrBins[nCW] = { 17, 35 }; //n centrality bins const int nCW = 2; //nCentrWidths const double cWidths[nCW] = { 10, 5 }; //width of the centrality bins const double cStep[nCW] = { 10, 5 }; //centrality bins step const int nCentrBins[nCW] = { 9, 18 }; //n centrality bins // const int nCW = 5; //nCentrWidths // const double cWidths[nCW] = { 10, 5, 2.5, 1.0, 0.5 }; //width of the centrality bins // const double cStep[nCW] = { 5, 2.5, 2.5, 1.0, 1.0 }; //centrality bins step // const int nCentrBins[nCW] = { 17, 35, 36, 90, 90 }; //n centrality bins const int nEtaWins = 3; const int nPhiWins = 1; const int maxNCentrBins = 100; //TMath::MaxElement(nCW, &nCentrBins); WinPair wins[nCW][maxNCentrBins][nEtaWins][nPhiWins]; CentralityOccupancy cOccupancy[nCW][maxNCentrBins]; for ( int cW = 0; cW < nCW; cW++ ) for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ ) { float cBinMin = cStep[cW] * cBin; float cBinMax = cWidths[cW] + cStep[cW] * cBin; cOccupancy[cW][cBin].cBinMin = cBinMin; cOccupancy[cW][cBin].cBinMax = cBinMax; for ( int etaW = 0; etaW < nEtaWins; etaW++ ) for ( int phiW = 0; phiW < nPhiWins; phiW++ ) wins[cW][cBin][etaW][phiW].init(cBinMin, cBinMax, etaW, phiW); } BranchFB br[nEtaWins][nPhiWins]; for ( int etaW = 0; etaW < nEtaWins; etaW++ ) for ( int phiW = 0; phiW < nPhiWins; phiW++ ) { int ptW = 0; TString brNamePostfix = Form("eta_%d_phi%d_pt_%d" , etaW, phiW, ptW ); t1->SetBranchAddress( Form("nF_%s", brNamePostfix.Data() ), &br[etaW][phiW].nF ); t1->SetBranchAddress( Form("nB_%s", brNamePostfix.Data() ), &br[etaW][phiW].nB ); t1->SetBranchAddress( Form("PtF_%s", brNamePostfix.Data() ), &br[etaW][phiW].PtF ); t1->SetBranchAddress( Form("PtB_%s", brNamePostfix.Data() ), &br[etaW][phiW].PtB ); } TH1D *hist1D_QA_percentilesEstimator = new TH1D( "hist1D_QA_percentilesEstimator", "hist1D_QA_percentilesEstimator;percentile;entries", 3001, -0.5, 300.5); TH1D *hist1D_QA_multALL = new TH1D( "hist1D_QA_multALL", "hist1D_QA_multALL;mult;entries", 3001, -0.5, 3000.5); // ##### prepare for tree loop int nEvents = t1->GetEntries(); cout <<"nEvents = " << nEvents << endl; // float **BS_Nf = new float*[nPhiWins]; // float **BS_Nb = new float*[nPhiWins]; // for ( int w = 0; w < nPhiWins; w++ ) // { // BS_Nf[w] = new float[nEvents]; // BS_Nb[w] = new float[nEvents]; // } // ##### main loop over events int flag_V0M_ZDC = 0;//1; int nAccepted = 0; for (Long64_t i=0; i < nEvents; i++) { if ( i % 100000 == 0 ) cout << "getting " << (int)i << endl; // cout <<"getting " << (int)i << "\r"; cout.flush(); t1->GetEntry( i ); // t1->GetEntry( TMath::Nint( gRandom->Uniform(-0.5,nEvents-0.5) ) ); float cEstimator = -1; if ( flag_V0M_ZDC==0 ) { if ( brV0M > 90 ) //V0M cut continue; cEstimator = brV0M; } else { if ( brZEMvsZDC > 50 ) //ZDCvsZEM cut continue; cEstimator = brZEMvsZDC; } hist1D_QA_percentilesEstimator->Fill(cEstimator); //calc mult in whole TPC using wins: int multTPC = 0; for ( int phiW = 0; phiW < nPhiWins; phiW++ ) multTPC += (br[0][phiW].nF + br[2][phiW].nF) + (br[0][phiW].nB + br[2][phiW].nB); hist1D_QA_multALL->Fill(multTPC); // for ( int w = 0; w < nPhiWins; w++ ) // { // BS_Nf[w][nAccepted] = Nf[w]; // BS_Nb[w][nAccepted] = Nb[w]; // } for ( int cW = 0; cW < nCW; cW++ ) for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ ) { cOccupancy[cW][cBin].fill(brV0M, brZEMvsZDC); for ( int etaW = 0; etaW < nEtaWins; etaW++ ) for ( int phiW = 0; phiW < nPhiWins; phiW++ ) wins[cW][cBin][etaW][phiW].fill( cEstimator, br[etaW][phiW].nF, br[etaW][phiW].nB, br[etaW][phiW].PtF, br[etaW][phiW].PtB ); } nAccepted++; } // end of events cout << "nAccepted = " << nAccepted << endl; cout << "nAccepted/nAll = " << (float)nAccepted/nEvents << endl; // ########## QA PLOTTING: TCanvas *canv_estimatorPercentiles_QA_all = new TCanvas("canv_estimatorPercentiles_QA_all","canv_estimatorPercentiles_QA_all",0,0,700,600 ); hist1D_QA_percentilesEstimator->DrawCopy(); TCanvas *canv_hist1D_QA_multALL = new TCanvas("canv_hist1D_QA_multALL","canv_hist1D_QA_multALL",50,50,700,600 ); hist1D_QA_multALL->DrawCopy(); // MULT BINNING: int nCentrBinsMult = 10; cout << "nCentrBins=" << nCentrBinsMult << endl; double *estBounds = new double[nCentrBinsMult]; // array to contain the quantiles getQuantiles(hist1D_QA_multALL, nCentrBinsMult, estBounds); drawCanvasWithClasses( hist1D_QA_multALL, "byMultTPC", nCentrBinsMult, estBounds ); // ##########MAIN PLOTTING FOR CORRS: TGraphErrors *grNN [nCW][nEtaWins]; TGraphErrors *grPtPt[nCW][nEtaWins]; TGraphErrors *grPtN[nCW][nEtaWins]; TGraphErrors *grFractEstByV0M[nCW]; TGraphErrors *grFractEstByZDC[nCW]; for ( int cW = 0; cW < nCW; cW++ ) { grFractEstByV0M[cW] = new TGraphErrors; grFractEstByZDC[cW] = new TGraphErrors; for ( int etaW = 0; etaW < nEtaWins; etaW++ ) { grNN[cW][etaW] = new TGraphErrors; grPtPt[cW][etaW] = new TGraphErrors; grPtN[cW][etaW] = new TGraphErrors; } } //calc (1) - occupancies in centr bins, (2) - corr coeffs for ( int cW = 0; cW < nCW; cW++ ) for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ ) { if ( cOccupancy[cW][cBin].nEventsV0M > 0 ) { CentralityOccupancy *c = &cOccupancy[cW][cBin]; float centr = c->cBinMin + (c->cBinMax - c->cBinMin)/2; float cRatio = 0; if (c->nEventsV0M>0) cRatio = (float)c->nEventsV0M_and_ZDCZEM / c->nEventsV0M; grFractEstByV0M[cW]->SetPoint(grFractEstByV0M[cW]->GetN(), centr, cRatio); if (c->nEventsZDCZEM>0) cRatio = (float)c->nEventsV0M_and_ZDCZEM / c->nEventsZDCZEM; grFractEstByZDC[cW]->SetPoint(grFractEstByZDC[cW]->GetN(), centr, cRatio); } for ( int etaW = 0; etaW < nEtaWins; etaW++ ) for ( int phiW = 0; phiW < nPhiWins; phiW++ ) { WinPair *w = &wins[cW][cBin][etaW][phiW]; float centr = w->cBinMin + (w->cBinMax - w->cBinMin)/2; w->calcCorrCoeffs(); if(0)cout << "cMin=" << w->cBinMin << ", cMax=" << w->cBinMax << ", etaW=" << etaW << ", NN_bCorr= " << w->NN_bCorr << ", PtPt_bCorr= " << w->PtPt_bCorr << endl; //fill graphs TGraphErrors *gr; //gr NN gr = grNN[cW][etaW]; if ( fabs(w->NN_bCorr) < 10 ) gr->SetPoint(gr->GetN(), centr, w->NN_bCorr); //gr PtPt gr = grPtPt[cW][etaW]; if ( fabs(w->PtPt_bCorr) < 10 ) gr->SetPoint(gr->GetN(), centr, w->PtPt_bCorr); //gr PtN gr = grPtN[cW][etaW]; if ( fabs(w->PtN_bCorr) < 10 ) gr->SetPoint(gr->GetN(), centr, w->PtN_bCorr); } } int colors[] = { kBlack, kBlack, kBlue, kRed, kMagenta }; int markers[] = { 20, 24, 5, 2, 21 }; // NN TCanvas *canv_grNN = new TCanvas("canv_grNN","canv_grNN",20,50,700,600 ); tuneCanvas(canv_grNN); grNN[0][0]->SetTitle( ";centrality percentile;b_{corr}" ); //C_{2} tuneGraphAxisLabels(grNN[0][0]); //centr 10 drawGraph(grNN[0][0], 20, kBlack, "AP"); // drawGraph(grNN[0][1], 21, kBlack, "P"); // drawGraph(grNN[0][2], 22, kBlack, "P"); for ( int cW = 1; cW < nCW; cW++ ) drawGraph(grNN[cW][0], markers[cW], colors[cW], "P"); grNN[0][0]->SetMinimum( 0 ); TLegend *leg = new TLegend(0.65,0.65,0.999,0.95); leg->SetFillColor(kWhite); leg->SetFillStyle(0); leg->SetBorderSize(0); for ( int cW = 0; cW < nCW; cW++ ) leg->AddEntry(grNN[cW][0], Form("class width %.1f", cWidths[cW]), "p"); leg->Draw(); TLatex *tex = new TLatex(0.7,0.4, "#eta_{gap}=0.8, #delta#eta=0.4"); drawTex(tex, 0.045); tex = new TLatex(0.4,0.89, "NN"); drawTex(tex, 0.045); TString strPostfix; if (flag_V0M_ZDC==0) strPostfix = Form("V0M.eps"); else strPostfix = Form("ZDCZEM.eps"); canv_grNN->SaveAs( Form("NN_%s", strPostfix.Data() ) ); // PtPt TCanvas *canv_grPtPt = new TCanvas("canv_grPtPt","canv_grPtPt",250,50,700,600 ); tuneCanvas(canv_grPtPt); grPtPt[0][0]->SetTitle( ";centrality percentile;b_{corr}" ); //C_{2} tuneGraphAxisLabels(grPtPt[0][0]); //centr 10 drawGraph(grPtPt[0][0], 20, kBlack, "AP"); // drawGraph(grPtPt[0][1], 21, kBlack, "P"); // drawGraph(grPtPt[0][2], 22, kBlack, "P"); for ( int cW = 1; cW < nCW; cW++ ) drawGraph(grPtPt[cW][0], markers[cW], colors[cW], "P"); grPtPt[0][0]->SetMinimum( 0 ); leg = new TLegend(0.65,0.65,0.999,0.95); leg->SetFillColor(kWhite); leg->SetFillStyle(0); leg->SetBorderSize(0); for ( int cW = 0; cW < nCW; cW++ ) leg->AddEntry(grPtPt[cW][0], Form("class width %.1f", cWidths[cW]), "p"); leg->Draw(); tex = new TLatex(0.7,0.4, "#eta_{gap}=0.8, #delta#eta=0.4"); drawTex(tex, 0.045); tex = new TLatex(0.4,0.89, "PtPt"); drawTex(tex, 0.045); canv_grNN->SaveAs( Form("PtPt_%s", strPostfix.Data() ) ); // PtN TCanvas *canv_grPtN = new TCanvas("canv_grPtN","canv_grPtN",450,50,700,600 ); tuneCanvas(canv_grPtN); grPtN[0][0]->SetTitle( ";centrality percentile;b_{corr}" ); //C_{2} tuneGraphAxisLabels(grPtN[0][0]); //centr 10 drawGraph(grPtN[0][0], 20, kBlack, "AP"); // drawGraph(grPtN[0][1], 21, kBlack, "P"); // drawGraph(grPtN[0][2], 22, kBlack, "P"); for ( int cW = 1; cW < nCW; cW++ ) drawGraph(grPtN[cW][0], markers[cW], colors[cW], "P"); grPtN[0][0]->SetMinimum( 0 ); leg = new TLegend(0.65,0.65,0.999,0.95); leg->SetFillColor(kWhite); leg->SetFillStyle(0); leg->SetBorderSize(0); for ( int cW = 0; cW < nCW; cW++ ) leg->AddEntry(grPtN[cW][0], Form("class width %.1f", cWidths[cW]), "p"); leg->Draw(); tex = new TLatex(0.7,0.4, "#eta_{gap}=0.8, #delta#eta=0.4"); drawTex(tex, 0.045); tex = new TLatex(0.4,0.89, "PtN"); drawTex(tex, 0.045); canv_grNN->SaveAs( Form("PtN_%s", strPostfix.Data() ) ); TCanvas *canv_grPtN_2D = new TCanvas("canv_grPtN_2D","canv_grPtN_2D",450,50,700,600 ); tuneCanvas(canv_grPtN_2D); // wins[0][0][0][0].hist2D_PtN->DrawCopy(); wins[0][0][0][0].hist2D_PtN->ProfileX()->DrawCopy(); // CENTR ESTIMATOR EVENT RATIO: TCanvas *canv_grCentrRatio = new TCanvas("canv_grCentrRatio","canv_grCentrRatio",450,250,700,600 ); tuneCanvas(canv_grCentrRatio); grFractEstByV0M[0]->SetTitle(";centrality percentile;ratio"); tuneGraphAxisLabels(grFractEstByV0M[0]); //centr 10 drawGraph(grFractEstByV0M[0], 20, kBlack, "AP"); // drawGraph(grFractEstByZDC[0], 20, kBlack, "L"); for ( int cW = 1; cW < nCW; cW++ ) drawGraph(grFractEstByV0M[cW], markers[cW], colors[cW], "P"); leg = new TLegend(0.65,0.65,0.999,0.95,"ratio #frac{V0M-and-ZEMZDC}{V0M}"); leg->SetFillColor(kWhite); leg->SetFillStyle(0); leg->SetBorderSize(0); for ( int cW = 0; cW < nCW; cW++ ) leg->AddEntry(grFractEstByV0M[cW], Form("class width %.1f", cWidths[cW]), "p"); leg->Draw(); // leg->SetHeader("ratio #frac{V0M-and-ZEMZDC}/{V0M}"); canv_grCentrRatio->SaveAs("ratio_V0M-and-ZEMZDC_by_V0M.eps"); // CENTR ESTIMATOR PERCENTILES QA: TCanvas *canv_estimatorPercentiles_QA = new TCanvas("canv_estimatorPercentiles_QA","canv_estimatorPercentiles_QA",50,350,700,600 ); for ( int cBin = 0; cBin < nCentrBins[0]; cBin++ ) { TH1D *h = wins[0][cBin][0][0].hist1D_EstimatorEntries; h->SetLineColor(kOrange-9+cBin); if ( cBin == 0 ) h->DrawCopy(); else h->DrawCopy("same"); } // MULT F IN CENTR CLASSES QA: TCanvas *canv_mult_F_in_centr_QA = new TCanvas("canv_mult_F_in_centr_QA","canv_mult_F_in_centr_QA",50,400,700,600 ); gPad->SetLogy(); for ( int cBin = 0; cBin < nCentrBins[0]; cBin++ ) { TH1D *h = wins[0][cBin][0][0].hist1D_multDistrF; h->SetLineColor(kOrange-9+cBin); if ( cBin == 0 ) { h->SetLineColor(kRed); h->GetYaxis()->SetRangeUser(1,100000); } if ( cBin == 0 ) h->DrawCopy(); else h->DrawCopy("same"); } // Check entries in centrality bins: for ( int cW = 0; cW < nCW; cW++ ) { cout << " ###### cW = " << cW << endl; for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ ) { TH1D *h = wins[cW][cBin][0][0].hist1D_multDistrF; cout << "cBin = " << h->GetEntries() << endl; // h->SetLineColor(kOrange-9+cBin); // if ( cBin == 0 ) // h->DrawCopy(); // else // h->DrawCopy("same"); } } return; }
void TestEnergy() { TFile *file = TFile::Open("PPCollisionUps1sMilNoTune.root"); TFile *file2 = TFile::Open("PPCollisionMilNoTune.root"); TNtuple* PPTupleUps = (TNtuple*)file->Get("PPTuple"); TNtuple* PPTupleND = (TNtuple*)file2->Get("PPTuple"); TH1D* NCharUps = new TH1D("NCharUps", "Sum of Energy at mid rapdity", 30000, 0, 300); PPTupleUps->Draw("(ETmid-mu1pT-mu2pT)>>NCharUps", "NChar>2 && abs(deta1) < 1.93 && abs(deta2) < 1.93 && mu1pT > 4 && mu2pT > 4"); // NCharUps->Scale(3.35e-6); double sum, percent = 0, centAr[21]; int c, centa[21], i; sum = 0; centAr[0] = 180; centAr[20] = 0; c = 1; //Find Activity Ranges double min = 0, average[20], bins; i = 0; //Activity Range Calculations for Track Count TH1D* Tracks = new TH1D("Tracks", "Number of Tracks", 10000, 0, 300); PPTupleND->Draw("ETmid>>Tracks", "NChar > 0"); double MinBiasEvents; MinBiasEvents = Tracks->GetEntries(); NCharUps->Draw(); Tracks->Draw(); Tracks->Scale(1./Tracks->GetEntries()); int TrackCent[21]; percent = .02; TrackCent[0] = 300; TrackCent[20] = 0; c = 1; double Ranges[12]; int counter = 1; Ranges[0] = 0; //Loop To Get Activity Range Values for (i=0; percent <= .02; percent += .02) { sum = 0; cout << c << " "; for(i=0; sum < percent && i != 10000; i++) { sum += Tracks->GetBinContent(10000-i); } cout << 100*percent - 2 << "-" << 100*percent << "%" << " " << MinBiasEvents*sum << " " << i << " " << Tracks->GetBinCenter(10000-i) << "\n"; // Use to check Activity Range Values Ranges[counter] = sum; counter++; TrackCent[c] = Tracks->GetBinCenter(10000-i); c++;} percent = .08; for (i=0; percent <= .08; percent += .02) { sum = 0; cout << c << " "; for(i=0; sum < percent || percent == 1; i++) { sum += Tracks->GetBinContent(10000-i); } cout << 100*percent - 2 << "-" << 100*percent << "%" << " " << MinBiasEvents*sum << " " << i << " " << Tracks->GetBinCenter(10000-i) << "\n"; // Use to check Activity Range Values Ranges[counter] = sum; counter++; TrackCent[c] = Tracks->GetBinCenter(10000-i); c++;} percent = .20; for (i=0; percent <= .20; percent += .04) { sum = 0; cout << c << " "; for(i=0; sum < percent || percent == 1; i++) { sum += Tracks->GetBinContent(10000-i); } cout << 100*percent - 4 << "-" << 100*percent << "%" << " " << MinBiasEvents*sum << " " << i << " " << Tracks->GetBinCenter(10000-i) << "\n"; // Use to check Activity Range Values Ranges[counter] = sum; counter++; TrackCent[c] = Tracks->GetBinCenter(10000-i); c++;} percent = .30; // for (i=0; percent <= .30; percent += .05) { // sum = 0; // cout << c << "\n"; // for(i=0; sum < percent || percent == 1; i++) { // sum += Tracks->GetBinContent(10000-i); } // cout << 100*percent - 5 << "-" << 100*percent << "%" << " " << sum << " " << i << " " << Tracks->GetBinCenter(10000-i) << "\n"; // Use to check Activity Range Values // TrackCent[c] = Tracks->GetBinCenter(10000-i) + .5; // c++; } // percent = .40; for (i=0; percent <= 1; percent += .10) { sum = 0; cout << c << " "; for(i=0; sum <= percent && i != 10000; i++) { sum += Tracks->GetBinContent(10000-i); } cout << 100*percent - 10 << "-" << 100*percent << "%" << " " << MinBiasEvents*sum << " " << i << " " << Tracks->GetBinCenter(10000-i) << "\n"; // Use to check Activity Range Values Ranges[counter] = sum; counter++; TrackCent[c] = Tracks->GetBinCenter(10000-i); c++; } cout << "\n" << "Activity Range Values from Array" << "\n"; for(c = 0; c < 11; c++) { cout << c << ") " << TrackCent[c] << "\n"; } min = 0; double TrackAverage[20]; cout << "\n" << NCharUps->GetBinCenter(30000) << "\n"; i = 0; double TotalUps = 0; //cout << "\n" << "Activity Bin Averages" << "\n"; //Loop To Get Average In Each Activity Region for(c = 0; NCharUps->GetBinCenter(30000-i) > TrackCent[c+1] && NCharUps->GetBinCenter(30000-i) <= TrackCent[c]; c++) { sum = 0; bins = 0; for(i = min; (NCharUps->GetBinCenter(30000-i) > TrackCent[c+1] && NCharUps->GetBinCenter(30000-i) <= TrackCent[c]) && i != 30000; i++) { sum += NCharUps->GetBinContent(30000-i)*(NCharUps->GetBinCenter(30000-i)); bins += NCharUps->GetBinContent(30000-i); } TrackAverage[c] = sum/bins; TotalUps += bins; cout << "Point " << c << ": " << bins << " +- " << sqrt(bins) << " Upsilons" << "\n"; min = i; } cout << NCharUps->GetBinCenter(100) << "\n"; // cout << 10*c << "-" << 10*(c+1) << "%" << " " << TrackAverage[c] << "\n"; } cout << "Total number of Upsilons: " << TotalUps << "\n"; cout << "\n" << "Corrected X/Y Track values" << "\n"; double TrackYpoints[20]; for(i = 0; i < 12; i++) { cout << (Ranges[i+1] - Ranges[i])*MinBiasEvents << "\n"; } //Take Average Values and Divide by ND Average to Get X points // for(c = 0; c < 4; c++) { // TrackAverage[c] = TrackAverage[c]/Tracks->GetMean(); // TrackYpoints[c] = (50./NCharUps->Integral(0,25000))*NCharUps->Integral(TrackCent[c+1], TrackCent[c]-1 ); // cout << "(" <<TrackAverage[c] << "," << TrackYpoints[c] << ")" << "\n"; } //for(c = 4; c < 7; c++) { // TrackAverage[c] = TrackAverage[c]/Tracks->GetMean(); // TrackYpoints[c] = (25./NCharUps->Integral(0,25000))*NCharUps->Integral(TrackCent[c+1], TrackCent[c]-1 ); // cout << "(" <<TrackAverage[c] << "," << TrackYpoints[c] << ")" << "\n"; } // for(c = 7; c < 10; c++) { // TrackAverage[c] = TrackAverage[c]/Tracks->GetMean(); // TrackYpoints[c] = (20./NCharUps->Integral(0,25000))*NCharUps->Integral(TrackCent[c+1], TrackCent[c]-1 ); // cout << "(" <<TrackAverage[c] << "," << TrackYpoints[c] << ")" << "\n"; } TrackAverage[0] = TrackAverage[0]/Tracks->GetMean(); TrackYpoints[0] = (50./NCharUps->Integral(0,30000))*NCharUps->Integral(100*TrackCent[1], 100*(TrackCent[0]-1) ); cout << "(" <<TrackAverage[0] << "," << TrackYpoints[0] << ")" << "\n"; TrackAverage[1] = TrackAverage[1]/Tracks->GetMean(); TrackYpoints[1] = (16.67/NCharUps->Integral(0,30000))*NCharUps->Integral(100*TrackCent[2], 100*TrackCent[1]-100 ); cout << "(" <<TrackAverage[1] << "," << TrackYpoints[1] << ")" << "\n"; TrackAverage[2] = TrackAverage[2]/Tracks->GetMean(); TrackYpoints[2] = (8.33/NCharUps->Integral(0,30000))*NCharUps->Integral(100*TrackCent[3], 100*TrackCent[2]-100 ); cout << "(" <<TrackAverage[2] << "," << TrackYpoints[2] << ")" << "\n"; for(c = 3; c < 14; c++) { TrackAverage[c] = TrackAverage[c]/Tracks->GetMean(); TrackYpoints[c] = (10./NCharUps->Integral(0,30000))*NCharUps->Integral(100*TrackCent[c+1], 100*TrackCent[c]-100 ); cout << "(" <<TrackAverage[c] << "," << TrackYpoints[c] << ")" << "\n"; } TF1* line = new TF1("line", "x", 0, 4.5); TF1* line2 = new TF1("line2", "1.8*x", 0, 4.5); line2->SetLineColor(kWhite); sum = 0; double scaledSumE = 0, scaleSumT = 0; scaleSumT = NCharUps->Integral(0,30000); TCanvas* can2 = new TCanvas("can2", "Centrality"); can2->cd(); line->SetLineColor(1); line2->GetYaxis()->SetTitle("#varUpsilon(1S)/<#varUpsilon(1S)>"); line2->GetXaxis()->SetTitle("#Sigma E_{T}^{|#eta| < 2.4}/<#Sigma E_{E}^{|#eta| < 2.4}>"); line2->SetTitle("#varUpsilon(1S) Cross Section vs Track Multiplicity"); line2->Draw(); line->SetLineStyle(3); line->Draw("same"); for(c = 0; c < 18; c++) { cout << TrackCent[c] << " Bin Average: " << 10.32*TrackAverage[c] << "\n";} double Test, Testaverage, Testsum, Testbin, count = 0, TestY = 0; Test = NCharUps->Integral(38,100); for(i = 38; i < 100; i++) { Testsum += NCharUps->GetBinContent(i)*NCharUps->GetBinCenter(i); Testbin += NCharUps->GetBinContent(i); } Testaverage = Testsum/Testbin; TestY = (10./NCharUps->Integral(0,30000))*NCharUps->Integral(38, 100); cout << "\n" << "\n" << TestY << "\n" << "\n"; TH1D* modelT = new TH1D("modelT", "Pythia model", 5000, 0, 5); //Fill Histogram with points from Model for(i = 0; i < 20; i++) { //Track Values modelT->SetBinContent(1000*TrackAverage[i], TrackYpoints[i]); modelT->SetBinError(1000*TrackAverage[i], .01); } modelT->SetMarkerStyle(20); modelT->SetMarkerColor(kBlue); modelT->SetLineColor(kBlue); modelT->Draw("sameE"); //Histogram for STAR Data Points TH1D* data = new TH1D("data", "CMS Data", 4000, 0, 4); data->SetMarkerStyle(20); data->SetMarkerColor(kRed); data->SetLineColor(kRed); data->SetBinContent(3262, 6.67); data->SetBinError(3262, .26); data->SetBinContent(2010, 3.12); data->SetBinError(2010, .15); data->SetBinContent(1240, 1.4); data->SetBinError(1240, .06); data->SetBinContent(630, .240); data->SetBinError(630, .01); data->Draw("sameE"); TLegend* leg = new TLegend(.1,.74,.30,.9); leg->SetHeader("For |#eta| < 2.4"); leg->AddEntry(modelT->DrawCopy("same"), "Pythia 8 Model", "l"); leg->AddEntry(data->DrawCopy("same"), "CMS data", "l"); leg->Draw("same"); return; }
void MidRapAnalysis() { //Set up Canvas Area TCanvas* can2 = new TCanvas("can2", "Centrality"); double xAverage[] = {3.42, 2.62, 1.96, 1.45, 1.12, .87, .67, .49, .39, .28, .23}; double yAverage[] = {5.22, 3.33, 2.21, 1.40, 1.06, .72, .49, .22, .16, .06, .03}; double yError[] = {.36, .25, .12, .06, .01, .12, .04, .03, .01, .01, 0}; double xError[] = {0,0,0,0,0,0,0,0,0,0}; TGraphErrors* Emodel = new TGraphErrors(10, xAverage, yAverage, xError, yError); Emodel->SetFillStyle(3001); Emodel->SetFillColor(kBlue); double xAverageE[] = {4.19, 2.92, 2.03, 1.40, 1.04, .77, .57, .42, .32, .24}; double yAverageE[] = {5.39, 3.36, 2.14, 1.33, .90, .56, .37, .16, .14, .01}; double yErrorE[] = {.31, .24, .08, .07, .01, .01, .02, .06, .07, .01}; double xErrorE[] = {0,0,0,0,0,0,0,0,0,0}; TGraphErrors* EmodelE = new TGraphErrors(10, xAverageE, yAverageE, xErrorE, yErrorE); EmodelE->SetFillStyle(3001); EmodelE->SetFillColor(kGreen); can2->cd(); TH1F* frame = can2->DrawFrame(0, 0, 3.5, 7.2); TF1* line = new TF1("line", "x", 0, 4.3); TF1* line2 = new TF1("line2", "1.6*x", 0, 4.3); line2->SetLineColor(kWhite); line->SetLineColor(1); line2->GetYaxis()->SetTitle("#varUpsilon(1S)/<#varUpsilon(1S)>"); // line2->GetXaxis()->SetTitle("N_{Ch}^{|#eta|<2.4}/<N_{Ch}^{|#eta|<2.4}>"); line2->SetTitle("#varUpsilon(1S) Cross Section vs Event Activity"); line2->Draw(); Emodel->Draw("P3"); EmodelE->Draw("3"); //line2->Draw("same"); line->SetLineStyle(3); line->SetLineColor(kBlack); line->Draw("same"); TH1D* mod = new TH1D("mod", "Pythia Model", 400, 0, 4); mod->SetLineColor(kBlue); TH1D* modEnergy = new TH1D("modEnergy", "Pythia Energy Model", 400, 0, 4); modEnergy->SetLineColor(kGreen); TH1D* data = new TH1D("data", "CMS Data", 4000, 0, 4); data->SetMarkerStyle(20); data->SetMarkerColor(kRed); //Manually Entering CMS Data Points with Error data->SetBinContent(3262, 6.67); data->SetBinError(3262, .26); data->SetBinContent(2010, 3.12); data->SetBinError(2010, .15); data->SetBinContent(1240, 1.4); data->SetBinError(1240, .06); data->SetBinContent(630, .240); data->SetBinError(630, .01); //data->SetMarkerColor(kBlue); data->SetMarkerSize(1); data->SetLineColor(kRed); data->Draw("sameE"); TLegend* leg = new TLegend(.1,.7,.38,.9); leg->SetHeader("For |#eta| < 2.4"); leg->AddEntry(modEnergy->DrawCopy("same"), "Pythia 8 - #Sigma E_{T}/<#Sigma E_{T}>", "l"); leg->AddEntry(mod->DrawCopy("same"), "Pythia 8 - N_{Ch}/<N_{Ch}>", "l"); leg->AddEntry(data->DrawCopy("sameE"), "CMS data - N_{Ch}/<N_{Ch}>", "l"); leg->Draw("same"); mod->SetLineColor(kBlack); mod->Draw("same"); return; }
AntiparticleParticleRatio(Int_t part, Int_t cent, Bool_t cutSpectra = kTRUE) { gStyle->SetOptStat(0); gStyle->SetOptFit(); TFile *itssafile = TFile::Open(itssafilename); // TFile *itstpcfile = TFile::Open(itstpcfilename); TFile *tpctoffile = TFile::Open(tpctoffilename); TFile *toffile = TFile::Open(toffilename); // TFile *hydrofile = TFile::Open(hydrofilename); TCanvas *cCanvas = new TCanvas("cCanvas"); if (cent == -1) cCanvas->Divide(5, 2); TCanvas *cCanvasCombined = new TCanvas("cCanvasCombined"); if (cent == -1) cCanvasCombined->Divide(5, 2); TCanvas *cCanvasRatio = new TCanvas("cCanvasRatio"); if (cent == -1) cCanvasRatio->Divide(5, 2); TCanvas *cCanvasRatioFit = new TCanvas("cCanvasRatioFit"); if (cent == -1) cCanvasRatioFit->Divide(5, 2); TH1D *hITSsa[2], *hITSTPC[2], *hTPCTOF[2], *hTOF[2]; TGraphErrors *gCombined[2][10]; TProfile *pCombined[2][10]; TH1D *hCombined[2][10]; TH1D *hRatio_ITSsa[10]; TH1D *hRatio_ITSTPC[10]; TH1D *hRatio_TPCTOF[10]; TH1D *hRatio_TOF[10]; TH1D *hRatio_COMB[10]; for (Int_t icent = 0; icent < 10; icent++) { if (cent != -1 && icent != cent) continue; for (Int_t icharge = 0; icharge < 2; icharge++) { gCombined[icharge][icent] = new TGraphErrors(); pCombined[icharge][icent] = new TProfile(Form("pCombined_charge%d_cent%d", icharge, icent), "", NptBins, ptBin); hCombined[icharge][icent] = new TH1D(Form("hCombined_charge%d_cent%d", icharge, icent), "", NptBins, ptBin); TObjArray spectraArray; hITSsa[icharge] = GetITSsaSpectrum(itssafile, part, icharge, icent, cutSpectra); hITSTPC[icharge] = NULL;//GetITSTPCSpectrum(itstpcfile, part, icharge, icent, cutSpectra); hTPCTOF[icharge] = GetTPCTOFSpectrum(tpctoffile, part, icharge, icent, cutSpectra); hTOF[icharge] = GetTOFSpectrum(toffile, part, icharge, icent, cutSpectra); // hHydro = GetHydroSpectrum(hydrofile, part, charge, icent); Double_t minimum = 0.; Double_t maximum = 0.; if (hITSsa[icharge]) { // AddPointsToGraph(hITSsa[icharge], gCombined[icharge][icent]); // AddPointsToProfile(hITSsa[icharge], pCombined[icharge][icent]); spectraArray.Add(hITSsa[icharge]); // hITSsa[icharge]->DrawCopy("same"); // if (hITSsa[icharge]->GetMaximum() > maximum) maximum = hITSsa[icharge]->GetMaximum(); // if (hITSsa[icharge]->GetMinimum() < minimum) minimum = hITSsa[icharge]->GetMinimum(); } if (hITSTPC[icharge]) { // AddPointsToGraph(hITSTPC[icharge], gCombined[icharge][icent]); // AddPointsToProfile(hITSTPC[icharge], pCombined[icharge][icent]); spectraArray.Add(hITSTPC[icharge]); // hITSTPC[icharge]->DrawCopy("same"); // if (hITSTPC[icharge]->GetMaximum() > maximum) maximum = hITSTPC[icharge]->GetMaximum(); // if (hITSTPC[icharge]->GetMinimum() < minimum) minimum = hITSTPC[icharge]->GetMinimum(); } if (hTPCTOF[icharge]) { // AddPointsToGraph(hTPCTOF[icharge], gCombined[icharge][icent]); // AddPointsToProfile(hTPCTOF[icharge], pCombined[icharge][icent]); spectraArray.Add(hTPCTOF[icharge]); // hTPCTOF[icharge]->DrawCopy("same"); // if (hTPCTOF[icharge]->GetMaximum() > maximum) maximum = hTPCTOF[icharge]->GetMaximum(); // if (hTPCTOF[icharge]->GetMinimum() < minimum) minimum = hTPCTOF[icharge]->GetMinimum(); } if (hTOF[icharge]) { // AddPointsToGraph(hTOF[icharge], gCombined[icharge][icent]); // AddPointsToProfile(hTOF[icharge], pCombined[icharge][icent]); spectraArray.Add(hTOF[icharge]); // hTOF[icharge]->DrawCopy("same"); // if (hTOF[icharge]->GetMaximum() > maximum) maximum = hTOF[icharge]->GetMaximum(); // if (hTOF[icharge]->GetMinimum() < minimum) minimum = hTOF[icharge]->GetMinimum(); } CombineSpectra(hCombined[icharge][icent], &spectraArray); } /* antiparticle/particle ratios */ Char_t title[1024]; sprintf(title, "%s/%s (%s);p_{T} (GeV/c);%s/%s;", partChargeName[part][1], partChargeName[part][0], centName[icent], partChargeName[part][1], partChargeName[part][0]); TH1D *hArea = new TH1D(Form("hArea_%d", icent), title, 100, ptMin[part], ptMax[part]); hArea->SetMaximum(1.2); hArea->SetMinimum(0.8); if (cent == -1) cCanvas->cd(icent + 1); else cCanvas->cd(); hArea->DrawCopy(); if (hITSsa[0] && hITSsa[1]) { hRatio_ITSsa[icent] = new TH1D(*hITSsa[1]); hRatio_ITSsa[icent]->Divide(hITSsa[0]); hRatio_ITSsa[icent]->DrawCopy("same"); } if (hTPCTOF[0] && hTPCTOF[1]) { hRatio_TPCTOF[icent] = new TH1D(*hTPCTOF[1]); hRatio_TPCTOF[icent]->Divide(hTPCTOF[0]); hRatio_TPCTOF[icent]->DrawCopy("same"); } if (hTOF[0] && hTOF[1]) { hRatio_TOF[icent] = new TH1D(*hTOF[1]); hRatio_TOF[icent]->Divide(hTOF[0]); hRatio_TOF[icent]->DrawCopy("same"); } // TLegend *legend = cCanvas->BuildLegend(); // legend->SetFillStyle(0); // legend->SetFillColor(0); // legend->DeleteEntry(); if (cent == -1) cCanvasCombined->cd(icent + 1); else cCanvasCombined->cd(); if (hCombined[0][icent] && hCombined[1][icent]) { hRatio_COMB[icent] = new TH1D(*hCombined[1][icent]); hRatio_COMB[icent]->Divide(hCombined[0][icent]); hRatio_COMB[icent]->SetMarkerStyle(20); hRatio_COMB[icent]->SetMarkerColor(2); hRatio_COMB[icent]->Fit("pol0", ""); hRatio_COMB[icent]->SetMinimum(0.5); hRatio_COMB[icent]->SetMaximum(1.5); hRatio_COMB[icent]->SetTitle(title); // hRatio_COMB[icent]->Draw("PHIST"); // pol0->SetRange(0., 5.); // pol0->DrawCopy("same"); // hArea->DrawCopy(); // hRatio_COMB[icent]->Draw("same"); } } }
void drawIaa( bool saveFigures=true) { const int nPtBin = 4; int ptBin[nPtBin+1] = {40, 50,60,80,9999}; double ptBinPaDraw[nPtBin+1] = { 40.5 ,49.5, 58.5, 76.5, 123. } ; // double AvePtBin[nPtBin+1] = { 45, 54.1479, 67.4204, 99.6956, 9999}; const int nCentBinHI = 2; const int centBinHI[nCentBinHI +1] = {-1, 10030, 13099}; TH1D* hJetPt[7][10][6]; // [Collision][centrality][pt] TH1D* hIaa[10][6]; // [centrality][pt] for (int icent=1 ; icent<= 10 ; icent++) { for (int ipt=1 ; ipt<=nPtBin ; ipt++) { hIaa[icent][ipt] = NULL; for (int icoll=0 ; icoll<6 ; icoll++) { hJetPt[icoll][icent][ipt] = NULL; } } } TFile* histFile[7][6]; // [Collision][pt] for (int ipt=1 ; ipt<=nPtBin ; ipt++) { for (int icoll=0 ; icoll<6 ; icoll++) { TString sampleName = getSampleName( icoll ) ; char* fname = Form("ffFiles/jetEnergyResL2L3_smeared/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131018.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/centralValue/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/centralOct16th/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131016.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/jetEnergyResCorrectedOct16th/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131016.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/jetEnergyScaledMinus2percentOct17/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131017.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/ak5Cone/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131017.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); //char* fname = Form("ffFiles/jetEnergyResCorrected/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); //char* fname = Form("ffFiles/jetEnergyScaledPlus2percent/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/jetEnergyScaledMinus2percent/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/noElectronRejection/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); //char* fname = Form("ffFiles/leadingJetAnalysis/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/jetEnergySmearedBy10percent/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); // char* fname = Form("ffFiles/photonEnergyScaled/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr30_20131011_photonEnergyScaledBy-0.015.root",sampleName.Data(), (int)ptBin[ipt-1], 9999); histFile[icoll][ipt] = new TFile(fname) ; cout << " Reading file : " << fname << endl; if ( histFile[icoll][ipt]->IsZombie() == false ) { cout << " Success." << endl; if ( (icoll == kPPDATA) || (icoll == kPPMC) ) { // PP int icent = 7 ; hJetPt[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPtForIaa_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("jetPt_icent%d_final", icent) << endl; // hJetPt[icoll][7][ipt]->Rebin(10); // hJetPt[icoll][7][ipt]->Scale(1./10); } if ( ( icoll == kHIDATA) || (icoll == kHIMC) ) { // PbPb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { hJetPt[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPtForIaa_icent%d_final", centBinHI[icent] ) ); cout << " Getting histogram : " << Form("jetPt_icent%d_final", centBinHI[icent] ) << endl; // hJetPt[icoll][icent][ipt]->Rebin(10); //hJetPt[icoll][icent][ipt]->Scale(1/10.); } } } else cout << " no such file " << endl; } } // Calculation of IAA for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { for (int ipt=1 ; ipt<=nPtBin ; ipt++) { hIaa[icent][ipt] = (TH1D*)hJetPt[kHIDATA][icent][ipt]->Clone(Form("iaa_%s",hJetPt[kHIDATA][icent][ipt]->GetName())); hIaa[icent][ipt]->Divide(hJetPt[kPPDATA][7][ipt]); } } TH1D* hTempPt = new TH1D("hTemp",";p_{T}^{#gamma} (GeV);",200,10,300); TCanvas* c2 = new TCanvas("c2","",1000,450); makeMultiPanelCanvas(c2,nPtBin,2,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c2->cd(ipt); // draw pp hTempPt->SetXTitle("p_{T}^{Jet} (GeV)"); hTempPt->SetYTitle("#frac{dN}{dp_{T}} #frac{1}{N^{#gamma}}"); hTempPt->SetAxisRange(30,200,"X"); // hTempPt->SetAxisRange(0,0.025,"Y"); hTempPt->SetAxisRange(0.00007,0.11,"Y"); handsomeTH1(hTempPt,0); hTempPt->DrawCopy(); gPad->SetLogy(); handsomeTH1(hJetPt[kPPDATA][7][ipt], 1); hJetPt[kPPDATA][7][ipt]->SetMarkerStyle(24); hJetPt[kPPDATA][7][ipt]->Draw("same"); // draw pbpb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(hJetPt[kHIDATA][icent][ipt],kRed); if ( icent == 2 ) hJetPt[kHIDATA][icent][ipt]->SetMarkerStyle(24); hJetPt[kHIDATA][icent][ipt]->Draw("same"); } double dx1=0.15; drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15); /* if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15); else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15); */ onSun(30,0,200,0); c2->cd(ipt + nPtBin); hTempPt->SetAxisRange(0,2.5,"Y"); hTempPt->SetYTitle("Ratio of Yield PbPb/pp"); handsomeTH1(hTempPt,0); hTempPt->DrawCopy(); for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(hIaa[icent][ipt],kRed); if ( icent == 2 ) hIaa[icent][ipt]->SetMarkerStyle(24); // if ( icent == 1 ) hIaa[icent][ipt]->Draw("same"); jumSun(30,1,200,1); } } c2->cd(1); TLegend *l2 = new TLegend(0.5933981,0.3877892,0.9981436,0.7857262,NULL,"brNDC"); easyLeg(l2,"2.76TeV"); l2->AddEntry(hJetPt[kPPDATA][7][1],"pp", "p"); l2->AddEntry(hJetPt[kHIDATA][2][1],"PbPb 30-100%", "p"); l2->AddEntry(hJetPt[kHIDATA][1][1],"PbPb 0-30%", "p"); l2->Draw(); if (saveFigures) c2->SaveAs("figures/pT_dependence_IAA_figure1.pdf"); if (saveFigures) c2->SaveAs("figures/pT_dependence_IAA_figure1.gif"); TFile * fResults = new TFile("resultHistograms.root","update"); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { hJetPt[kPPDATA][7][ipt]->SetName(Form("dNdJetPt_forIaa_pp_ptBin%dAndHigher",ipt)); hJetPt[kPPDATA][7][ipt]->Write(); for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { hJetPt[kHIDATA][icent][ipt]->SetName(Form("dNdJetPt_forIaa_pbpb_centralityBin%d_ptBin%dAndHigher",icent,ipt)); hJetPt[kHIDATA][icent][ipt]->Write(); hIaa[icent][ipt]->SetName(Form("Ryaa_centralityBin%d_ptBin%dAndHigher",icent,ipt)); hIaa[icent][ipt]->Write(); } } fResults->Close(); }
void drawPtDependencePPSmeared(int centBin = 10030, TString dirName="nominal", int prodDate=20131021, int jetPtCut=30) { TH1::SetDefaultSumw2(); const int nPtBin = 4; double ptBin[nPtBin+1] = {40, 50,60,80,9999}; double ptBinPaDraw[nPtBin+1] = { 40.5 ,49.5, 58.5, 76.5, 123. } ; // double AvePtBin[nPtBin+1] = { 45, 54.1479, 67.4204, 99.6956, 9999}; const int nCentBinHI = 2; const int centBinHI[nCentBinHI +1] = {-1, 10030, 13099}; TH1D* hxjg[7][10][6]; // [Collision][centrality][pt] TH1D* hJetPt[7][10][6]; // [Collision][centrality][pt] TH1D* hJetPtIaaBin[7][10][6]; // [Collision][centrality][pt] TH1D* hDphi[7][10][6]; // [Collision][centrality][pt] TH1D* hEta[7][10][6]; // [Collision][centrality][pt] TH1D* meanXjg[7][10]; // [Collision][centrality] TH1D* meanJetPt[7][10]; // [Collisi on][centrality] TH1D* rjg[7][10]; // [Collision][centrality] for (int icoll=0 ; icoll<6 ; icoll++) { for (int icent=1 ; icent<= 10 ; icent++) { meanXjg[icoll][icent] = new TH1D( Form("meanXjg_icoll%d_icent%d",icoll,icent), ";p_{T}^{#gamma} (GeV); <X_{J#gamma}>",nPtBin,ptBinPaDraw); meanJetPt[icoll][icent] = new TH1D( Form("meanJetPt_icoll%d_icent%d",icoll,icent), ";p_{T}^{#gamma} (GeV); <p_{T}^{Jet}>",nPtBin,ptBinPaDraw); rjg[icoll][icent] = new TH1D( Form("rjg_icoll%d_icent%d",icoll,icent), ";p_{T}^{#gamma} (GeV); R_{J#gamma}",nPtBin,ptBinPaDraw); for (int ipt=1 ; ipt<=nPtBin ; ipt++) { hxjg[icoll][icent][ipt] = NULL; hJetPt[icoll][icent][ipt] = NULL; hJetPtIaaBin[icoll][icent][ipt] = NULL; hDphi[icoll][icent][ipt] = NULL; hEta[icoll][icent][ipt] = NULL; } } } TFile* histFile[7][6]; // [Collision][pt] for (int ipt=1 ; ipt<=nPtBin ; ipt++) { for (int icoll=0 ; icoll<6 ; icoll++) { TString sampleName = getSampleName( icoll ) ; char* fname = Form("ffFiles/%s/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr%d_%d.root",dirName.Data(), sampleName.Data(), (int)ptBin[ipt-1], (int)ptBin[ipt], (int)jetPtCut, prodDate); histFile[icoll][ipt] = new TFile(fname) ; cout << " Reading file : " << fname << endl; if ( histFile[icoll][ipt]->IsZombie() == false ) { cout << " Success." << endl; if ( (icoll == kPPDATA) || (icoll == kPPMC) ) { // PP int icent = 7 ; hxjg[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("xjg_icent%d_final", centBin)); cout << " Getting histogram : " << Form("xjg_icent%d_final", icent) << endl; hJetPt[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPt_icent%d_final", centBin)); cout << " Getting histogram : " << Form("jetPt_icent%d_final", icent) << endl; hJetPtIaaBin[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPtForIaa_icent%d_final", centBin)); cout << " Getting histogram : " << Form("jetPtForIaa_icent%d_final", icent) << endl; hDphi[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetDphi_icent%d_final", centBin)); cout << " Getting histogram : " << Form("jetDphi_icent%d_final", icent) << endl; hEta[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("etaJg_icent%d_final", centBin)) ; cout << " Getting histogram : " << Form("etaJg_icent%d_final", centBin) << endl; } if ( ( icoll == kHIDATA) || (icoll == kHIMC) ) { // PbPb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { hxjg[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("xjg_icent%d_final", centBinHI[icent] )) ; cout << " Getting histogram : " << Form("xjg_icent%d_final", centBinHI[icent] ) << endl; hJetPt[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPt_icent%d_final", centBinHI[icent] ) ); cout << " Getting histogram : " << Form("jetPt_icent%d_final", centBinHI[icent] ) << endl; hJetPtIaaBin[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPtForIaa_icent%d_final", centBinHI[icent] ) ); cout << " Getting histogram : " << Form("jetPtForIaa_icent%d_final", centBinHI[icent] ) << endl; hDphi[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetDphi_icent%d_final", centBinHI[icent] ) ) ; cout << " Getting histogram : " << Form("jetDphi_icent%d_final", icent)<< endl; hEta[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("etaJg_icent%d_final", centBinHI[icent] ) ) ; cout << " Getting histogram : " << Form("etaJg_icent%d_final", icent)<< endl; } } } else cout << " no such file " << endl; } } for (int ipt=1 ; ipt<=nPtBin ; ipt++) { for (int icoll=0 ; icoll<6 ; icoll++) { for (int icent=1 ; icent<= 10 ; icent++ ) { if ( hxjg[icoll][icent][ipt] == NULL ) continue; // emtpy histogram double rVal, rErr; rVal = hxjg[icoll][icent][ipt]->IntegralAndError(1, hxjg[icoll][icent][ipt]->GetNbinsX(), rErr, "width"); printf("icoll: %d icent: %d ipt: %d rval: %lf\n",icoll, icent, ipt, rVal); rjg[icoll][icent]->SetBinContent( ipt, rVal ); rjg[icoll][icent]->SetBinError ( ipt, rErr ); meanXjg[icoll][icent]->SetBinContent( ipt, hxjg[icoll][icent][ipt]->GetMean() ); meanXjg[icoll][icent]->SetBinError ( ipt, hxjg[icoll][icent][ipt]->GetMeanError() ); meanJetPt[icoll][icent]->SetBinContent( ipt, hJetPt[icoll][icent][ipt]->GetMean() ); meanJetPt[icoll][icent]->SetBinError ( ipt, hJetPt[icoll][icent][ipt]->GetMeanError() ); } } } TCanvas* c1 = new TCanvas("c1","",1200,350); makeMultiPanelCanvas(c1,nPtBin,1,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c1->cd(ipt); // draw pp handsomeTH1(hDphi[kPPDATA][7][ipt], 1); hDphi[kPPDATA][7][ipt]->SetXTitle("#Delta#phi_{J#gamma}"); hDphi[kPPDATA][7][ipt]->SetYTitle("Normalized entries"); hDphi[kPPDATA][7][ipt]->SetMarkerStyle(24); hDphi[kPPDATA][7][ipt]->Scale(1./hDphi[kPPDATA][7][ipt]->Integral("width")); hDphi[kPPDATA][7][ipt]->SetAxisRange(0,3.141592,"X"); hDphi[kPPDATA][7][ipt]->SetAxisRange(0.01,30,"Y"); hDphi[kPPDATA][7][ipt]->Draw(); // draw pbpb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(hDphi[kHIDATA][icent][ipt],kRed); if ( icent == 2 ) hDphi[kHIDATA][icent][ipt]->SetMarkerStyle(24); hDphi[kHIDATA][icent][ipt]->Scale(1./hDphi[kHIDATA][icent][ipt]->Integral("width")); hDphi[kHIDATA][icent][ipt]->Draw("same"); } gPad->SetLogy(); // onSun(30,0,200,0); } c1->cd(1); TLegend *ly = new TLegend(0.4913112,0.6561548,0.9997611,0.9431145,NULL,"brNDC"); easyLeg(ly,"2.76TeV"); ly->AddEntry(hDphi[kPPDATA][7][1],"pp ","p"); ly->AddEntry(hDphi[kHIDATA][2][1],"PbPb 0-30%","p"); TLegend *l1 = new TLegend(0.1995968,0.7097458,0.7076613,0.9237288,NULL,"brNDC"); easyLeg(l1,"2.76TeV"); l1->AddEntry(hDphi[kPPDATA][7][1],"pp ","p"); l1->AddEntry(hDphi[kHIDATA][2][1],"PbPb 30-100%","p"); l1->AddEntry(hDphi[kHIDATA][1][1],"PbPb 0-30%","p"); l1->Draw(); // c1->SaveAs("figures/pT_dependence_dphi_pp_pbpb_figure1.pdf"); // c1->SaveAs("figures/pT_dependence_dphi_pp_pbpb_figure1.gif"); TH1D* hTempPt = new TH1D("hTemp",";p_{T}^{#gamma} (GeV);",200,10,300); TCanvas* c2 = new TCanvas("c2","",1200,350); makeMultiPanelCanvas(c2,nPtBin,1,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c2->cd(ipt); // draw pp hTempPt->SetXTitle("p_{T}^{Jet} (GeV)"); hTempPt->SetYTitle("#frac{dN}{dp_{T}} #frac{1}{N}"); hTempPt->SetAxisRange(10,150,"X"); // hTempPt->SetAxisRange(0,0.025,"Y"); hTempPt->SetAxisRange(0,0.08,"Y"); handsomeTH1(hTempPt,0); hTempPt->DrawCopy(); // hJetPt[kPPDATA][7][ipt]->Scale(1./rjg[kPPDATA][7]->GetBinContent(ipt)); // rjg normalization handsomeTH1(hJetPt[kPPDATA][7][ipt], 1); hJetPt[kPPDATA][7][ipt]->SetMarkerStyle(24); hJetPt[kPPDATA][7][ipt]->Draw("same"); // draw pbpb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(hJetPt[kHIDATA][icent][ipt],kRed); // hJetPt[kHIDATA][icent][ipt]->Scale(1./rjg[kHIDATA][icent]->GetBinContent(ipt)); // rjg normalization // hJetPt[kHIDATA][icent][ipt]->Rebin(10); // hJetPt[kHIDATA][icent][ipt]->Scale(1/10.); if ( icent == 2 ) hJetPt[kHIDATA][icent][ipt]->SetMarkerStyle(24); if ( icent == 2 ) hJetPt[kHIDATA][icent][ipt]->Draw("same"); if ( icent == 1 ) hJetPt[kHIDATA][icent][ipt]->Draw("same"); } double dx1=0.15; if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15);//yeonju 130823 onSun(30,0,200,0); } c2->cd(1); l1->Draw(); c2->SaveAs("figures/pT_dependence_jetPt_pp_pbpb_figure1.pdf"); c2->SaveAs("figures/pT_dependence_jetPt_pp_pbpb_figure1.gif"); TLegend *l2 = new TLegend(0.2116935,0.7012712,0.6149194,0.904661,NULL,"brNDC"); easyLeg(l2,"2.76TeV"); l2->AddEntry(hDphi[kPPDATA][7][1],"pp ","p"); l2->AddEntry(hDphi[kHIDATA][1][1],"PbPb 30-100%","p"); l2->AddEntry(hDphi[kHIDATA][2][1],"PbPb 0-30%","p"); TCanvas* c21 = new TCanvas("c21","",500,500); handsomeTH1(meanJetPt[kPPDATA][7], 1); meanJetPt[kPPDATA][7]->SetYTitle("<p_{T}^{Jet}> (>30GeV)"); meanJetPt[kPPDATA][7]->SetMarkerStyle(24); // meanJetPt[kPPDATA][7]->SetAxisRange(-2,2,"X"); meanJetPt[kPPDATA][7]->SetAxisRange(40,90,"Y"); meanJetPt[kPPDATA][7]->Draw(); for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(meanJetPt[kHIDATA][icent],kRed); if ( icent == 2 ) meanJetPt[kHIDATA][icent]->SetMarkerStyle(24); //if ( icent == 2 ) meanJetPt[kHIDATA][icent]->Draw("same"); meanJetPt[kHIDATA][icent]->Draw("same"); } l1 ->Draw(); c21->SaveAs("figures/pT_dependence_jetPt_pp_pbpb_figure2.pdf"); c21->SaveAs("figures/pT_dependence_jetPt_pp_pbpb_figure2.gif"); TCanvas* c3 = new TCanvas("c3","",1200,350); makeMultiPanelCanvas(c3,nPtBin,1,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c3->cd(ipt); // draw pp handsomeTH1(hxjg[kPPDATA][7][ipt], 1); hxjg[kPPDATA][7][ipt]->SetXTitle("x_{J#gamma}"); hxjg[kPPDATA][7][ipt]->SetYTitle("#frac{dN}{dp_{T}} #frac{1}{N}"); hxjg[kPPDATA][7][ipt]->SetMarkerStyle(24); // hxjg[kPPDATA][7][ipt]->Scale(1./rjg[kPPDATA][7]->GetBinContent(ipt)); // rjg normalization // hxjg[kPPDATA][7][ipt]->Rebin(10); // hxjg[kPPDATA][7][ipt]->Scale(1./10); hxjg[kPPDATA][7][ipt]->SetAxisRange(0,2.5,"X"); hxjg[kPPDATA][7][ipt]->SetAxisRange(0,3,"Y"); hxjg[kPPDATA][7][ipt]->Draw(); // draw pbpb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(hxjg[kHIDATA][icent][ipt],kRed); // hxjg[kHIDATA][icent][ipt]->Scale(1./rjg[kHIDATA][icent]->GetBinContent(ipt)); // rjg normalization // hxjg[kHIDATA][icent][ipt]->Rebin(10); // hxjg[kHIDATA][icent][ipt]->Scale(1./10); if ( icent == 2 ) hxjg[kHIDATA][icent][ipt]->SetMarkerStyle(24); if ( icent == 2 ) hxjg[kHIDATA][icent][ipt]->Draw("same"); if ( icent == 1 ) hxjg[kHIDATA][icent][ipt]->Draw("same"); } double dx1=0.15; if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15);//yeonju 130823 onSun(30,0,200,0); } c3->cd(1); l1->Draw(); c3->SaveAs("figures/pT_dependence_xjg_pp_pbpb_figure1.pdf"); c3->SaveAs("figures/pT_dependence_xjg_pp_pbpb_figure1.gif"); TCanvas* c31 = new TCanvas("c31","",500,500); handsomeTH1(meanXjg[kPPDATA][7], 1); meanXjg[kPPDATA][7]->SetYTitle("<x_{J#gamma}> (>30GeV)"); meanXjg[kPPDATA][7]->SetMarkerStyle(24); // meanXjg[kPPDATA][7]->SetAxisRange(-2,2,"X"); meanXjg[kPPDATA][7]->SetAxisRange(0.6,1.2,"Y"); meanXjg[kPPDATA][7]->Draw(); for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(meanXjg[kHIDATA][icent],kRed); if ( icent == 2 ) meanXjg[kHIDATA][icent]->SetMarkerStyle(24); //if ( icent != 2 ) meanXjg[kHIDATA][icent]->Draw("same"); meanXjg[kHIDATA][icent]->Draw("same"); } l1->Draw(); c31->SaveAs("figures/pT_dependence_xjg_pp_pbpb_figure1.pdf"); c31->SaveAs("figures/pT_dependence_xjg_pp_pbpb_figure1.gif"); TCanvas* c_rjg = new TCanvas("c_rjg","",500,500); handsomeTH1(rjg[kPPDATA][7], 1); rjg[kPPDATA][7]->SetYTitle("r_{J#gamma}"); rjg[kPPDATA][7]->SetMarkerStyle(24); // rjg[kPPDATA][7]->SetAxisRange(-2,2,"X"); rjg[kPPDATA][7]->SetAxisRange(0.0,1.1,"Y"); rjg[kPPDATA][7]->Draw(); for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { handsomeTH1(rjg[kHIDATA][icent],kRed); if ( icent == 2 ) rjg[kHIDATA][icent]->SetMarkerStyle(24); // if ( icent != 2 ) rjg[kHIDATA][icent]->Draw("same"); rjg[kHIDATA][icent]->Draw("same"); } l1->Draw(); c_rjg->SaveAs("figures/pT_dependence_rjg_pp_pbpb_figure1.pdf"); c_rjg->SaveAs("figures/pT_dependence_rjg_pp_pbpb_figure1.gif"); // Save the final root histogram files TFile * fResults = new TFile(Form("resultHistograms_ppSmeared%d.root",centBin),"update"); // pp meanJetPt[kPPDATA][7]->SetName(Form("meanJetPt_pp")); meanJetPt[kPPDATA][7]->Write(); meanXjg[kPPDATA][7]->SetName(Form("meanXjg_pp")); meanXjg[kPPDATA][7]->Write(); rjg[kPPDATA][7]->SetName(Form("meanRjg_pp")); rjg[kPPDATA][7]->Write(); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { hJetPt[kPPDATA][7][ipt]->SetName(Form("dNdJetPt_pp_ptBin%d",ipt)); hJetPt[kPPDATA][7][ipt]->Write(); hJetPtIaaBin[kPPDATA][7][ipt]->SetName(Form("dNdJetPt_IaaBin_pp_ptBin%d",ipt)); hJetPtIaaBin[kPPDATA][7][ipt]->Write(); hxjg[kPPDATA][7][ipt]->SetName(Form("dNdXjg_pp_ptBin%d",ipt)); hxjg[kPPDATA][7][ipt]->Write(); hDphi[kPPDATA][7][ipt]->SetName(Form("dNdphi_pp_ptBin%d",ipt)); hDphi[kPPDATA][7][ipt]->Write(); } // PbPb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { hJetPt[kHIDATA][icent][ipt]->SetName(Form("dNdJetPt_pbpb_centralityBin%d_ptBin%d",icent,ipt)); hJetPt[kHIDATA][icent][ipt]->Write(); hJetPtIaaBin[kHIDATA][icent][ipt]->SetName(Form("dNdJetPt_IaaBin_pbpb_centralityBin%d_ptBin%d",icent,ipt)); hJetPtIaaBin[kHIDATA][icent][ipt]->Write(); hxjg[kHIDATA][icent][ipt]->SetName(Form("dNdXjg_pbpb_centralityBin%d_ptBin%d",icent,ipt)); hxjg[kHIDATA][icent][ipt]->Write(); hDphi[kHIDATA][icent][ipt]->SetName(Form("dNdphi_pbpb_centralityBin%d_ptBin%d",icent,ipt)); hDphi[kHIDATA][icent][ipt]->Write(); } meanJetPt[kHIDATA][icent]->SetName(Form("meanJetPt_pbpb_centralityBin%d",icent)); meanJetPt[kHIDATA][icent]->Write(); meanXjg[kHIDATA][icent]->SetName(Form("meanXjg_pbpb_centralityBin%d",icent)); meanXjg[kHIDATA][icent]->Write(); rjg[kHIDATA][icent]->SetName(Form("meanRjg_pbpb_centralityBin%d",icent)); rjg[kHIDATA][icent]->Write(); } fResults->Close(); }
void DrawEff_DS(){ gStyle->SetOptStat(kFALSE); gStyle->SetErrorX(0); //bool isweight=kFALSE; bool isweight=kTRUE; bool isHF=kTRUE; //bool isHF=kFALSE; if(isweight) TString dir="weight"; else TString dir="noweight"; const int Nhist=4; const int NGen=1; const int Ncent=6; //const double HFbin[]={0,0.1,0.2,0.4,0.6,0.8,1,2,4,6,9,12,15,20,30,50,75,100}; const double xerr[Ncent]={0,0,0,0,0,0}; /* const double HFbin_cent[Nhist][Ncent+1]={ {0,2.92,10.1,19.3,23.7,30.2,100}, {0,1.03,5.00,11.6,15.0,20.3,100}, {0,2.7,12.6,28.6,36.9,49.6,100}}; */ const double HFbin_cent[Nhist][Ncent+1]={ {0,2.725,10.065,19.565,23.975,30.455,100}, {0,0.975,5.005,11.775,15.285,20.725,100}, {0,2.515,12.465,28.855,37.235,50.085,100}}; const double cent[Ncent]={95,75,45,25,15,5}; const int nHFbin=sizeof(HFbin)/sizeof(double)-1; //double color[NGen][Nhist]={{2,1,4},{2,1,4}}; //double Style[NGen][Nhist]={{20,24,28},{20,24,28}}; double color[NGen][Nhist]={{2,1,4}}; double Style[NGen][Nhist]={{20,24,28}}; //TString Gen[NGen]={"Hijing","Epos"}; TString Gen[NGen]={"Hijing"}; TString histoname[Nhist]={"HFEnergy4","HFEnergyPlus4","HFEnergyPlus","Ntrk"}; TString etarange[Nhist]={" HF E_{T} |#eta|>4"," HF E_{T} #eta>4"," HF E_{T} #eta>0",""}; TString filename[NGen]; TFile* f[NGen]; TH1F* h_or[NGen][Nhist]; TH1F* reh_or[NGen][Nhist]; TH1F* h_tr[NGen][Nhist]; TH1F* reh_tr[NGen][Nhist]; TH1F* h_ds[NGen][Nhist]; TH1F* reh_ds[NGen][Nhist]; TH1F* h_eff[NGen][Nhist]; TH1F* reh_eff[NGen][Nhist]; TLatex* T1[Nhist]; TLatex* T2; TLatex* T3[NGen]; TF1 *fitEff[NGen][Nhist]; //TGraphAsymmErrors *gEff[NGen][Nhist]; TGraph *gEff[NGen][Nhist]; c1 = new TCanvas("c1"," ",800,500); c2 = new TCanvas("c2"," ",800,700); makeMultiPanelCanvas(c1,NGen,1,0.03,0.03,0.14,0.14,0.03); makeMultiPanelCanvas(c2,1,1,0.03,0.03,0.03,0.03,0.03); //for |eta|>4 HFEnergy: /* for(int k=0;k<NGen;k++) for(int j=0;j<Nhist;j++) fitEff[k][j]= new TF1(Form("fitEff_%s%s",Gen[k].Data(),histoname[j]),"[0]-[1]*exp([2]*x)-[3]*exp(-[4]*x)",0,300); fitEff[0][0]->SetParameters(0.999876,0.44648,-1.78911,0.242036,0.549932); fitEff[0][1]->SetParameters(1.,0.367894,-3.36629,0.104605,0.690272); fitEff[0][2]->SetParameters(0.99981,0.697501,-2.59569,0.15323,0.411757); fitEff[1][0]->SetParameters(0.999918,0.691843,-0.785042,0.0352768,0.449521); fitEff[1][1]->SetParameters(0.999929,0.284,-2.25636,0.264114,0.951221); fitEff[1][2]->SetParameters(0.999887,0.5,-2.39395,0.373215,0.550851); */ for(int k=0;k<NGen;k++){ T3[k]=new TLatex(0.45,0.93,Gen[k]); T3[k]->SetNDC(); T3[k]->SetTextAlign(12); T3[k]->SetTextSize(0.05); T3[k]->SetTextColor(1); T3[k]->SetTextFont(42); } for(int j=0;j<Nhist;j++){ T1[j]=new TLatex(0.4,0.85,etarange[j]); T1[j]->SetNDC(); T1[j]->SetTextAlign(12); T1[j]->SetTextSize(0.05); T1[j]->SetTextColor(1); T1[j]->SetTextFont(42); } T2=new TLatex(0.2,0.25,"Double Side"); T2->SetNDC(); T2->SetTextAlign(12); T2->SetTextSize(0.06); T2->SetTextColor(1); T2->SetTextFont(42); j=3; for(int k=0;k<NGen;k++){ //for(int j=0;j<Nhist;j++){ filename[k]=Form("output/%s/pPbHist_%s_DS",dir.Data(),Gen[k].Data()); f[k]=TFile::Open(Form("%s.root",filename[k].Data())); h_or[k][j]=(TH1F*)f[k]->Get(Form("h%s",histoname[j].Data())); h_tr[k][j]=(TH1F*)f[k]->Get(Form("h%s_tr",histoname[j].Data())); h_ds[k][j]=(TH1F*)f[k]->Get(Form("h%s_DS",histoname[j].Data())); h_eff[k][j]=(TH1F*)f[k]->Get(Form("hEff_%s",histoname[j].Data())); fixedFontHist(h_or[k][j],1.8,2); fixedFontHist(h_tr[k][j],1.8,2); fixedFontHist(h_ds[k][j],1.8,2); //reh_or[k][j]=(TH1F*)h_or[k][j]->Clone(Form("re%s%s",Gen[k].Data(),histoname[j].Data())); //reh_tr[k][j]=(TH1F*)h_tr[k][j]->Clone(Form("re%s%s_tr",Gen[k].Data(),histoname[j].Data())); //reh_ds[k][j]=(TH1F*)h_ds[k][j]->Clone(Form("re%s%s_ds",Gen[k].Data(),histoname[j].Data())); //reh_or[k][j]=(TH1F*)h_or[k][j]->Rebin(Ncent,Form("re%s%s",Gen[k].Data(),histoname[j].Data()),HFbin_cent[j]); //reh_tr[k][j]=(TH1F*)h_tr[k][j]->Rebin(Ncent,Form("re%s%s_tr",Gen[k].Data(),histoname[j].Data()),HFbin_cent[j]); //reh_ds[k][j]=(TH1F*)h_ds[k][j]->Rebin(Ncent,Form("re%s%s_ds",Gen[k].Data(),histoname[j].Data()),HFbin_cent[j]); reh_or[k][j]=(TH1F*)h_or[k][j]->Rebin(nHFbin,Form("re%s%s",Gen[k].Data(),histoname[j].Data()),HFbin); reh_tr[k][j]=(TH1F*)h_tr[k][j]->Rebin(nHFbin,Form("re%s%s_tr",Gen[k].Data(),histoname[j].Data()),HFbin); reh_ds[k][j]=(TH1F*)h_ds[k][j]->Rebin(nHFbin,Form("re%s%s_ds",Gen[k].Data(),histoname[j].Data()),HFbin); //normalizeByBinWidth(reh_or[k][j]); //normalizeByBinWidth(reh_tr[k][j]); //normalizeByBinWidth(reh_ds[k][j]); //gEff[k][j]=new TGraphAsymmErrors(); gEff[k][j]=new TGraph(h_eff[k][j]); gEff[k][j]->SetPoint(0,0,1); gEff[k][j]->SetName(Form("gEff_%s%s",Gen[k].Data(),histoname[j].Data())); //gEff[k][j]->BayesDivide(reh_tr[k][j],reh_ds[k][j]); gEff[k][j]->SetMarkerColor(color[k][j]); gEff[k][j]->SetLineColor(color[k][j]); gEff[k][j]->SetMarkerStyle(Style[k][j]); gEff[k][j]->SetMarkerSize(1.2); gEff[k][j]->GetXaxis()->SetLimits(0.01,99.9); gEff[k][j]->SetTitle(""); //} } TH1D * hFrame = new TH1D("","",100,0,100.); if(!isHF){ hFrame->GetXaxis()->SetLabelOffset(999); hFrame->GetXaxis()->SetTickLength(0);} hFrame->GetYaxis()->SetTitle("Event Selection Efficiency"); hFrame->SetMaximum(1.09); hFrame->SetMinimum(0); if(isHF) hFrame->GetXaxis()->SetTitle("HF E_{T} (GeV/c)"); if(j==3) hFrame->GetXaxis()->SetTitle("track Mult"); hFrame->GetYaxis()->SetTitleSize(0.05); fixedFontHist(hFrame); hFrame->GetYaxis()->SetTitleOffset(1.5); for(k=0;k<NGen;k++){ if(isHF) c1->cd(k+1)->SetLogx(); else c1->cd(k+1); TLegend *leg=new TLegend(0.60,0.2,0.75,0.4); if(k!=0){ hFrame->GetYaxis()->SetTitle(""); hFrame->GetYaxis()->SetLabelSize(0); } hFrame->DrawCopy(); //for(j=0;j<Nhist;j++){ if(isHF) gEff[k][j]->Draw("Psame"); else{ ReverseXAxis(gEff[k][j],0.05); ReverseXGraph(gEff[k][j]); } //fitEff[k][j]->SetLineStyle(color[k][j]); //fitEff[k][j]->SetLineColor(color[k][j]); //fitEff[k][j]->Draw("same"); leg->AddEntry(gEff[k][j],etarange[j],"lp"); //} leg->SetTextSize(0.05); leg->SetBorderSize(0); leg->SetFillColor(0); TLine *l=new TLine(0,1,100,1); l->SetLineStyle(2); l->Draw("same"); leg->Draw("same"); T3[k]->Draw("same"); } if(isHF) c1->Print(Form("pic/OwnBinning/pPbHist_%s_DS_HF.png",dir.Data())); else c1->Print(Form("pic/OwnBinning/pPbHist_%s_DS_cent.png",dir.Data())); //------------------------------------------------------------------------------------------ if(isHF) //c2->cd()->SetLogx(); //else c2->cd(); TLegend *leg=new TLegend(0.7,0.2,0.85,0.4); hFrame->GetYaxis()->SetTitle("Event Selection Efficiency"); hFrame->GetYaxis()->SetLabelSize(18); hFrame->GetYaxis()->SetTitleOffset(1); hFrame->DrawCopy(); for(k=0;k<NGen;k++){ if(k==0){ gEff[k][j]->SetMarkerColor(1); gEff[k][j]->SetLineColor(1); gEff[k][j]->SetMarkerStyle(20); gEff[k][j]->SetMarkerSize(1.6); } else{ gEff[k][j]->SetMarkerColor(2); gEff[k][j]->SetLineColor(2); gEff[k][j]->SetMarkerStyle(24); gEff[k][j]->SetMarkerSize(1.6); } if(isHF) gEff[k][j]->Draw("Psame"); else{ ReverseXAxis(gEff[k][j],0.05); ReverseXGraph(gEff[k][j]); } leg->SetTextSize(0.05); leg->SetBorderSize(0); leg->SetFillColor(0); leg->AddEntry(gEff[k][j],Gen[k],"p"); TLine *l=new TLine(0,1,100,1); l->SetLineStyle(2); } T1[j]->Draw("same"); leg->Draw("same"); l->Draw("same"); if(isHF) c2->Print(Form("pic/OwnBinning/pPbHist_%s_DS_%s_HF.png",dir.Data(),histoname[j].Data())); else c2->Print(Form("pic/OwnBinning/pPbHist_%s_DS_%s_cent.png",dir.Data(),histoname[j].Data())); }
void photonTemplateProducer(int cutOpt=3, int ppHI = kHI, int isoChoice = kSumIso, int isoCut = -100, bool onlygjEvents=false, float specialSbCut=10, float mcSigShift=0, float sbBkgShift=0) { CutAndBinCollection cab; cab.setCuts(cutOpt); int nPtBin = cab.getNPtBin(); vector<double> ptBinVector = cab.getPtBin(); double ptBin[100]; for ( int i = 0 ; i<=nPtBin ;i++) { ptBin[i] = ptBinVector[i]; } int nCentBin = cab.getNCentBin(); vector<double> centBinVector = cab.getCentBin(); double centBin[100]; for ( int i = 0 ; i<=nCentBin ;i++) { centBin[i] = centBinVector[i]; } TString pphiLabel = ""; if ( ppHI == kPP) pphiLabel = "pp"; TCanvas* c1[5]; TH1D* hData[5][5]; TH1D* hSig[5][5]; TH1D* hBkg[5][5]; // TH1D* hDatapp[5]; // TH1D* hSigpp[5]; // TH1D* hBkgpp[5]; TH1D* hBkgMCsr[5][5]; TH1D* hBkgMCsb[5][5]; TH1D* rawSpectra[5]; TH1D* finSpectra[5]; TH2D* hPurity2D = new TH2D("hPurity2D",";pT(GeV);Centrality bin",nPtBin,ptBin,nCentBin,centBin); int nCent(-1); if ( ppHI == kHI ) nCent = nCentBin; if ( ppHI == kPP ) nCent = 1; for ( int icent = 1 ; icent<=nCent ; icent++) { rawSpectra[icent] = new TH1D(Form("rawSpec_icent%d_%s",icent,getIsoLabel(isoChoice).Data()),"",nPtBin,ptBin); } for (int ipt = 1; ipt <= nPtBin ; ipt++) { c1[ipt] = new TCanvas(Form("c1_ipt%d",ipt),"",700,700); if ( ppHI == kHI ) makeMultiPanelCanvas(c1[ipt],nCent/2,2,0.0,0.0,0.2,0.15,0.02); TCut ptCut = Form("corrPt>%.2f && corrPt<%.2f",(float)ptBin[ipt-1],(float)ptBin[ipt]); for ( int icent = 1 ; icent<=nCent ; icent++) { int lowCent = centBinVector[icent-1]; int highCent = centBinVector[icent]-1; hData[icent][ipt] = new TH1D(Form("hData_cent%d_pt%d",icent,ipt),";shower shape (#sigma_{#eta#eta});Entries per photon candidate;",25,0,0.025); hSig[icent][ipt] = (TH1D*)hData[icent][ipt]->Clone(Form("hSig_cent%d_pt%d",icent,ipt)); hBkg[icent][ipt] = (TH1D*)hData[icent][ipt]->Clone(Form("hBkg_cent%d_pt%d",icent,ipt)); hBkgMCsr[icent][ipt] = (TH1D*)hData[icent][ipt]->Clone(Form("hBkgMCsr_cent%d_pt%d",icent,ipt)); hBkgMCsb[icent][ipt] =(TH1D*)hData[icent][ipt]->Clone(Form("hBkgMCsb_cent%d_pt%d",icent,ipt)); TString fNamedata = fNameHIdata; if ( ppHI == kPP ) fNamedata = fNamePPdata; getTemplate(ppHI, hSig[icent][ipt],"meaningless",isoChoice,isoCut, kSig,lowCent,highCent,ptCut,onlygjEvents,specialSbCut,mcSigShift); getTemplate(ppHI, hData[icent][ipt],fNamedata ,isoChoice,isoCut, kData,lowCent,highCent,ptCut,onlygjEvents,specialSbCut); if ( ppHI == kHI) { getTemplate(ppHI, hBkg[icent][ipt], fNamedata ,isoChoice,isoCut, kSBB,lowCent,highCent,ptCut,onlygjEvents,specialSbCut,sbBkgShift); } if ( ppHI == kPP) getTemplate(ppHI, hBkg[icent][ipt], fNamedata ,isoChoice,isoCut, kSBBpp,lowCent,highCent,ptCut,onlygjEvents,specialSbCut); } for ( int icent = 1 ; icent<=nCent ; icent++) { int lowerCent = centBinVector[icent-1]; int upperCent =centBinVector[icent]-1; c1[ipt]->cd(nCent - icent+1); fitResult fitr = doFit ( hSig[icent][ipt], hBkg[icent][ipt], hData[icent][ipt], 0.005,0.025); if ( icent== nCent) drawPatch(0,0,0.05,0.14,0,1001, "ndc"); cout << " shift = " << mcSigShift << endl; cout << " purity = " << fitr.purity010 << endl; if ( ptBin[ipt]> 200) drawText(Form(" E_{T}^{#gamma} > %d GeV", (int)ptBin[ipt-1]),0.5680963,0.529118); else drawText(Form("%d - %d GeV", (int)ptBin[ipt-1], (int)ptBin[ipt]),0.5680963,0.529118); if ( ppHI == kHI) { drawText(Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),0.5680963,0.4369118); } else if ( ppHI == kPP) { drawText("7TeV pp",0.5680963,0.4369118); } if ( (icent == nCent) || (icent == 2)) drawText(Form("Purity(#sigma_{#eta#eta} < 0.01) : %.0f%%", (float)fitr.purity010*100),0.5680963,0.3569118,1,15); else drawText(Form("Purity(#sigma_{#eta#eta} < 0.01) : %.0f%%", (float)fitr.purity010*100),0.4980963,0.3569118,1,15); drawText(Form("#pm %.0f%% (stat)", float( 100. * fitr.purity010 * (float)fitr.nSigErr / (float)fitr.nSig ) ),0.6680963,0.2869118,1,15); hPurity2D->SetBinContent(ipt,icent,fitr.purity010); hPurity2D->SetBinError (ipt,icent,fitr.purity010* fitr.nSigErr/fitr.nSig); rawSpectra[icent]->SetBinContent( ipt, fitr.nSig); rawSpectra[icent]->SetBinError( ipt,fitr.nSigErr); TString aa = ""; if (isoChoice == kSumIso) aa = "Sum Iso Method"; if (isoChoice == k3dIso) aa = "3d Cut Method"; if (isoChoice == kFisher) aa = "Fisher Method"; if ( (ppHI == kHI) && ( icent==nCent -1) ) drawText(aa.Data(),0.1980963,0.8569118,1,20); else if ( ppHI == kPP) drawText(aa.Data(),0.1980963,0.8569118,1,20); if ( icent<= 2) drawPatch(0,0,0.05,0.14,0,1001, ndcOpt); // drawPatch(0.9,0.05,1.01,0.14,0,1001,ndcOpt); if ( (ppHI == kPP) && ( mcSigShift != 0 )) drawText(Form("Signal template shifted by %f",mcSigShift),0.1980963,0.7569118,1,15); if ( (ppHI == kHI) && ( mcSigShift != 0 ) && (icent==3)) drawText(Form("Signal template shifted by %f",mcSigShift),0.1980963,0.7569118,1,15); } TString ppLabel =""; if ( ppHI == kPP) ppLabel = "_pp"; TString shiftLabel=""; if ( mcSigShift != 0 ) shiftLabel = Form("_%fSigShifted",(float)mcSigShift); c1[ipt]->SaveAs(Form("fittingPurity%s_%s_pt%d%s.pdf",ppLabel.Data(), getIsoLabel(isoChoice).Data(),ipt,shiftLabel.Data())); } // efficiency plots TCanvas* c2 = new TCanvas("c2","",700,700); //100 + nCent_std*300,400); if ( ppHI == kHI) makeMultiPanelCanvas(c2,nCent/2,2,0.0,0.0,0.2,0.15,0.02); TH1D* heff[7][5]; TH1D* heffGj[5]; TH1D* heffDphi[5]; TH1D* effSingleBin = new TH1D("effSingleBin","",1,60,100000); TGraphAsymmErrors* geff[7][5]; TGraphAsymmErrors* gSingleBin = new TGraphAsymmErrors(); TGraphAsymmErrors* geffGj[5]; TGraphAsymmErrors* geffDphi[5]; for (int icent = 1; icent <=nCent; icent++) { for ( int iid=1 ; iid<=5; iid++) { heff[icent][iid] = new TH1D(Form("heff_icent%d_id%d",icent,iid),";photon E_{T} (GeV);Efficiency",nPtBin, ptBin); if ( isoChoice == kSumIso2) heff[icent][iid]->SetName(Form("heff_icent%d_id%d_isoCut%d",icent,iid,(int)isoCut)); if ( isoChoice == kSumIso3) heff[icent][iid]->SetName(Form("heff_icent%d_id%d_sbIsoCut%d",icent,iid,(int)specialSbCut)); geff[icent][iid] = new TGraphAsymmErrors(); geff[icent][iid]->SetName(Form("geff_%s",heff[icent][iid]->GetName())); } heffGj[icent] = new TH1D(Form("heff_icent%d_Gj", icent),";x_J#gamma;Efficiency",10,0,2); heffDphi[icent] = new TH1D(Form("heff_icent%d_Dphi",icent),";#Delta#phi of pair;Efficiency",9,0.3141592,3.141592); geffGj[icent] = new TGraphAsymmErrors(); geffDphi[icent] = new TGraphAsymmErrors(); } TCut srIsoCut = getIsoCut(isoChoice,isoCut); int nId=4; for (int icent = 1; icent <=nCent ; icent++) { int lowCent = centBinVector[icent-1]; int highCent = centBinVector[icent]-1; TCut centCut = Form("yEvt.hiBin >= %d && yEvt.hiBin<= %d",lowCent,highCent); if ( ppHI == kPP ) centCut = ""; getEff("genMatchedPt",heff[icent][1],geff[icent][1],centCut, "swissCrx<0.90 && seedTime<4"); getEff("genMatchedPt",heff[icent][2],geff[icent][2],centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1"); getEff("genMatchedPt",heff[icent][3],geff[icent][3],centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1" && srIsoCut); getEff("genMatchedPt",heff[icent][4],geff[icent][4],centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1 && sigmaIetaIeta<0.010"&& srIsoCut); effSingleBin->Reset(); getEff("genMatchedPt",effSingleBin, gSingleBin, centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1" && srIsoCut); cout << " here Gj" << endl; getEff("yJet.jtpt/photonEt",heffGj[icent],geffGj[icent], centCut && " genIso<5 && abs(genMomId)<=22 && photonEt>60 && abs(yJet.jteta)<2 && yJet.jtpt>30 && acos(cos(photonPhi-yJet.jtphi))>2.749", "hovere<0.1 && sigmaIetaIeta<0.010 && (cc4+cr4+ct4PtCut20)/0.9<1",true); getEff("acos(cos(photonPhi-yJet.jtphi))",heffDphi[icent],geffDphi[icent],centCut && " genIso<5 && abs(genMomId)<=22 && photonEt>60 && abs(yJet.jteta)<2 && yJet.jtpt>30", "hovere<0.1 && sigmaIetaIeta<0.010 && (cc4+cr4+ct4PtCut20)/0.9<1",true); } for (int icent = 1; icent <=nCent; icent++) { for ( int iid=1 ; iid<=nId ; iid++) { handsomeTH1(heff[icent][iid],ycolor[iid]); handsomeTGraph(geff[icent][iid],ycolor[iid]); } } TH1D* htmp = (TH1D*)heff[1][1]->Clone("htmp"); htmp->Reset(); htmp->SetAxisRange(0,1.3,"Y"); htmp->SetYTitle("Efficiency"); handsomeTH1(htmp); for (int icent = 1; icent <=nCent; icent++) { int lowerCent = centBinVector[icent-1]; int upperCent = centBinVector[icent]-1; if ( ppHI == kHI) c2->cd(nCent - icent + 1); htmp->DrawCopy(); for ( int iid=1 ; iid<=nId ; iid++) { heff[icent][iid]->Draw("p same"); geff[icent][iid]->Draw("p"); } if ( ( icent == nCent ) || ( ppHI == kPP) ) { TLegend* leg1 = new TLegend(0.25,0.20,0.95,0.55,NULL,"brNDC"); easyLeg(leg1,"Photon ID efficiency"); leg1->AddEntry(heff[icent][1],"spike rejection","lp"); leg1->AddEntry(heff[icent][2],"+ H/E < 0.1","lp"); if (isoChoice == kSumIso) leg1->AddEntry(heff[icent][3],"+ SumIso cut","lp"); if (isoChoice == kFisher) leg1->AddEntry(heff[icent][3],"+ Fisher cut","lp"); leg1->AddEntry(heff[icent][4],"+ #sigma_{#eta#eta} <0.010","lp"); leg1->Draw(); } drawText(Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),0.5680963,0.8369118); if ( icent<=2) drawPatch(0,0,0.05,0.14,0,1001,ndcOpt); // drawPatch(0.9,0.05,1.01,0.14,0,1001,ndcOpt); } c2->SaveAs(Form("photonID_efficiency_%s.pdf",getIsoLabel(isoChoice).Data())); TCanvas* c2b = new TCanvas("c2b","",1000,500); //100 + nCent_std*300,400); c2b->Divide(2,1); c2b->cd(1); TH1D* htmpG = (TH1D*)heffGj[1]->Clone("htmpG"); htmpG->Reset(); htmpG->SetAxisRange(0,1.3,"Y"); htmpG->SetYTitle("Efficiency"); handsomeTH1(htmpG); TLegend* legCent = new TLegend(0.4657258,0.2245763,1,0.4512712,NULL,"brNDC"); easyLeg(legCent,"Centrality"); if (isoChoice == kSumIso) easyLeg(legCent,"SumIso Method"); if (isoChoice == kFisher) easyLeg(legCent,"Fisher Method"); cout<< " heffGj "<< endl << endl<< endl; for (int icent = 1; icent <=nCent; icent++) { handsomeTH1(heffGj[icent],ycolor[icent]); heffGj[icent]->Fit("pol1"); heffGj[icent]->GetFunction("pol1")->SetLineColor(ycolor[icent]); heffGj[icent]->GetFunction("pol1")->SetLineStyle(7); } htmpG->DrawCopy(); for (int icent = 1; icent <=nCent; icent++) { heffGj[icent]->Draw("same"); int lowerCent = centBinVector[icent-1]; int upperCent = centBinVector[icent]-1; legCent->AddEntry(heffGj[icent],Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),"pl"); } legCent->Draw(); c2b->cd(2); TH1D* htmpDp = new TH1D("htmpDp",";#Delta#phi of pair;Efficiency",10,0,3.14); htmpDp->Reset(); htmpDp->SetAxisRange(0,1.3,"Y"); htmpDp->SetYTitle("Efficiency"); handsomeTH1(htmpDp); cout << " heffDphi " << endl << endl << endl ; for (int icent = 1; icent <=nCent; icent++) { handsomeTH1(heffDphi[icent],ycolor[icent]); heffDphi[icent]->Fit("pol1"); heffDphi[icent]->GetFunction("pol1")->SetLineColor(ycolor[icent]); heffDphi[icent]->GetFunction("pol1")->SetLineStyle(7); } htmpDp->DrawCopy(); for (int icent = 1; icent <=nCent; icent++) { heffDphi[icent]->Draw("same"); } legCent->Draw(); c2b->SaveAs(Form("photonID_efficiency_%s_2.pdf",getIsoLabel(isoChoice).Data())); TCanvas* c3 = new TCanvas("cPurity","",500,500); TH1D* hPurity[10]; for (int icent = 1; icent <=nCent; icent++) { hPurity[icent] = (TH1D*)hPurity2D->ProjectionX(Form("purity1D_icent%d",icent),icent,icent); hPurity[icent]->Fit("pol1"); hPurity[icent]->GetFunction("pol1")->SetLineColor(ycolor[icent]); hPurity[icent]->GetFunction("pol1")->SetLineStyle(7); } TH1D* tempPurity = (TH1D*)hPurity[1]->Clone("purityTemp"); tempPurity->Reset(); handsomeTH1(tempPurity,1); tempPurity->SetXTitle("pT (Gev)"); tempPurity->SetYTitle("Purity"); tempPurity->SetAxisRange(0.45,1.2,"Y"); tempPurity->Draw(); for (int icent = 1; icent <=nCent; icent++) { handsomeTH1(hPurity[icent],ycolor[icent]); hPurity[icent]->Draw("same"); } TLegend* legPurity = new TLegend(0.4657258,0.2245763,1,0.4512712,NULL,"brNDC"); easyLeg(legPurity,"Purity"); if (isoChoice == kSumIso) easyLeg(legPurity,"SumIso Method"); if (isoChoice == kFisher) easyLeg(legPurity,"Fisher Method"); for (int icent = 1; icent <=nCent; icent++){ int lowerCent = centBinVector[icent-1]; int upperCent = centBinVector[icent]-1; legPurity->AddEntry(hPurity[icent],Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),"pl"); } legPurity->Draw(); if ( !onlygjEvents) drawText("inclusive photon",0.25,0.2); c3->SaveAs(Form("purity_%s.pdf",getIsoLabel(isoChoice).Data())); TCanvas* c4 = new TCanvas("efficiencyCorrection","",1000,500); c4->Divide(2,1); c4->cd(1); for (int icent = 1; icent <=nCent; icent++) { TH1ScaleByWidth(rawSpectra[icent]); // divide by width finSpectra[icent] = (TH1D*)rawSpectra[icent]->Clone(Form("finSpec_icent%d_%s",icent,getIsoLabel(isoChoice).Data())); if ( isoChoice == kSumIso2) finSpectra[icent]->SetName(Form("finSpec_icent%d_%s_isoCut%d",icent,getIsoLabel(isoChoice).Data(),(int)isoCut)); if ( isoChoice == kSumIso3) finSpectra[icent]->SetName(Form("finSpec_icent%d_%s_sbisoCut%d",icent,getIsoLabel(isoChoice).Data(),(int)specialSbCut)); finSpectra[icent]->Divide(heff[icent][3]); handsomeTH1(finSpectra[icent],ycolor[icent]); } // TAA and centrality // TFile outf = TFile(cab.getPurityFileName(),"recreate"); hPurity2D->Write(); for ( int icent=1 ; icent<=nCent ; icent++) { heff[icent][3]->Write(); heff[icent][4]->Write(); finSpectra[icent]->Write(); hPurity[icent]->Write(); for (int ipt = 1; ipt <= nPtBin ; ipt++) { hData[icent][ipt]->Write(); } // hBkgMCRatioFit[icent][1]->Write(); } outf.Close(); }
void drawPtDependencePA(TString dirName, int prodDate, int jetPtCut, TString fNameSuffix, TString outNameSuffix){ bool saveFigures=true; const int nPtBin = 4; double ptBin[nPtBin+1] = {40, 50,60,80,9999}; double ptBinPaDraw[nPtBin+1] = { 40.5 ,49.5, 58.5, 76.5, 123. } ; // double AvePtBin[nPtBin+1] = { 45, 54.1479, 67.4204, 99.6956, 9999}; const int nCentBinHI = 2; const int centBinHI[nCentBinHI +1] = {-1, 10030, 13099}; TH1D* hxjg[7][10][6]; // [Collision][centrality][pt] TH1D* hJetPt[7][10][6]; // [Collision][centrality][pt] TH1D* hJetPtIaaBin[7][10][6]; // [Collision][centrality][pt] TH1D* hDphi[7][10][6]; // [Collision][centrality][pt] TH1D* meanXjg[7][10]; // [Collision][centrality] TH1D* meanJetPt[7][10]; // [Collisi on][centrality] TH1D* rjg[7][5]; // [Collision][centrality] for (int icoll=0 ; icoll<6 ; icoll++) { for (int icent=1 ; icent<= 10 ; icent++) { meanXjg[icoll][icent] = new TH1D( Form("meanXjg_icoll%d_icent%d",icoll,icent), ";p_{T}^{#gamma} (GeV); <X_{J#gamma}>",nPtBin,ptBinPaDraw); meanJetPt[icoll][icent] = new TH1D( Form("meanJetPt_icoll%d_icent%d",icoll,icent), ";p_{T}^{#gamma} (GeV); <p_{T}^{Jet}>",nPtBin,ptBinPaDraw); rjg[icoll][icent] = new TH1D( Form("rjg_icoll%d_icent%d",icoll,icent), ";p_{T}^{#gamma} (GeV); R_{J#gamma}",nPtBin,ptBinPaDraw); for (int ipt=1 ; ipt<=nPtBin ; ipt++) { hxjg[icoll][icent][ipt] = NULL; hJetPt[icoll][icent][ipt] = NULL; hJetPtIaaBin[icoll][icent][ipt] = NULL; hDphi[icoll][icent][ipt] = NULL; } } } TFile* histFile[7][6]; // [Collision][pt] for (int ipt=1 ; ipt<=nPtBin ; ipt++) { for (int icoll=0 ; icoll<6 ; icoll++) { TString sampleName = getSampleName( icoll ) ; char* fname; if (fNameSuffix.EqualTo("")) { // if no explicit suffix for the input file name is specified fname = Form("ffFiles/%s/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr%d_%d.root",dirName.Data(), sampleName.Data(), (int)ptBin[ipt-1], (int)ptBin[ipt], (int)jetPtCut, prodDate); } else { fname = Form("ffFiles/%s/photonTrackCorr_%s_output_photonPtThr%d_to_%d_jetPtThr%d_%d_%s.root",dirName.Data(), sampleName.Data(), (int)ptBin[ipt-1], (int)ptBin[ipt], (int)jetPtCut, prodDate, fNameSuffix.Data()); } histFile[icoll][ipt] = new TFile(fname) ; cout << " Reading file : " << fname << endl; if ( histFile[icoll][ipt]->IsZombie() == false ) { cout << " Success." << endl; if ( (icoll == kPPDATA) || (icoll == kPPMC) ) { // PP int icent = 7 ; hxjg[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("xjg_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("xjg_icent%d_final", icent) << endl; hJetPt[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPt_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("jetPt_icent%d_final", icent) << endl; hJetPtIaaBin[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPtForIaa_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("jetPtForIaa_icent%d_final", icent) << endl; hDphi[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetDphi_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("jetDphi_icent%d_final", icent) << endl; //hEta[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("etaJg_icent%d_final", icent)) ; //cout << " Getting histogram : " << Form("etaJg_icent%d_final", icent) << endl; } if ( (icoll == kPADATA) || (icoll == kPAMC) ) { // PA int icent = 1 ; hxjg[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("xjg_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("xjg_icent%d_final", icent) << endl; hJetPt[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPt_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("jetPt_icent%d_final", icent) << endl; hJetPtIaaBin[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPtForIaa_icent%d_final", icent ) ) ; cout << " Getting histogram : " << Form("jetPtForIaa_icent%d_final", icent ) << endl; hDphi[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetDphi_icent%d_final", icent)) ; cout << " Getting histogram : " << Form("jetDphi_icent%d_final", icent) << endl; //hEta[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("etaJg_icent%d_final", icent)) ; //cout << " Getting histogram : " << Form("etaJg_icent%d_final", icent) << endl; } if ( ( icoll == kHIDATA) || (icoll == kHIMC) ) { // PbPb for ( int icent = 1; icent <= nCentBinHI ; icent++ ) { hxjg[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("xjg_icent%d_final", centBinHI[icent] )) ; cout << " Getting histogram : " << Form("xjg_icent%d_final", centBinHI[icent] ) << endl; hJetPt[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPt_icent%d_final", centBinHI[icent] ) ); cout << " Getting histogram : " << Form("jetPt_icent%d_final", centBinHI[icent] ) << endl; hJetPtIaaBin[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetPtForIaa_icent%d_final", centBinHI[icent] ) ); cout << " Getting histogram : " << Form("jetPtForIaa_icent%d_final", centBinHI[icent] ) << endl; hDphi[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("jetDphi_icent%d_final", centBinHI[icent] ) ) ; cout << " Getting histogram : " << Form("jetDphi_icent%d_final", centBinHI[icent])<< endl; //hEta[icoll][icent][ipt] = (TH1D*)histFile[icoll][ipt]->Get(Form("etaJg_icent%d_final", centBinHI[icent] ) ) ; //cout << " Getting histogram : " << Form("etaJg_icent%d_final", centBinHI[icent])<< endl; } } } else cout << " no such file " << endl; } } for (int ipt=1 ; ipt<=nPtBin ; ipt++) { for (int icoll=0 ; icoll<6 ; icoll++) { for (int icent=1 ; icent<= 10 ; icent++ ) { if ( hxjg[icoll][icent][ipt] == NULL ) continue; // emtpy histogram double rVal, rErr; rVal = hxjg[icoll][icent][ipt]->IntegralAndError(1, hxjg[icoll][icent][ipt]->GetNbinsX(), rErr, "width"); rjg[icoll][icent]->SetBinContent( ipt, rVal ); rjg[icoll][icent]->SetBinError ( ipt, rErr ); meanXjg[icoll][icent]->SetBinContent( ipt, hxjg[icoll][icent][ipt]->GetMean() ); meanXjg[icoll][icent]->SetBinError ( ipt, hxjg[icoll][icent][ipt]->GetMeanError() ); meanJetPt[icoll][icent]->SetBinContent( ipt, hJetPt[icoll][icent][ipt]->GetMean() ); meanJetPt[icoll][icent]->SetBinError ( ipt, hJetPt[icoll][icent][ipt]->GetMeanError() ); } } } TCanvas* c1 = new TCanvas("c1","",1200,350); makeMultiPanelCanvas(c1,nPtBin,1,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c1->cd(ipt); handsomeTH1(hDphi[kPAMC][1][ipt], 1); hDphi[kPAMC][1][ipt]->SetXTitle("#Delta#phi_{J#gamma}"); hDphi[kPAMC][1][ipt]->SetYTitle("Normalized entries"); hDphi[kPAMC][1][ipt]->SetMarkerStyle(24); hDphi[kPAMC][1][ipt]->Scale(1./hDphi[kPAMC][1][ipt]->Integral("width")); hDphi[kPAMC][1][ipt]->SetAxisRange(0,3.141592,"X"); hDphi[kPAMC][1][ipt]->SetAxisRange(0.01,30,"Y"); hDphi[kPAMC][1][ipt]->Draw(); handsomeTH1(hDphi[kPADATA][1][ipt], kRed); hDphi[kPADATA][1][ipt]->Scale(1./hDphi[kPADATA][1][ipt]->Integral("width")); hDphi[kPADATA][1][ipt]->Draw("same"); gPad->SetLogy(); double dx1=0.15; if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15);//yeonju 130823 } c1->cd(1); TLegend *l1 = new TLegend(0.2199474,0.5971384,0.7283974,0.8119819,NULL,"brNDC"); easyLeg(l1,"5.02TeV"); l1->AddEntry(hDphi[kPAMC][1][1],"pA pythia+HIJING ","p"); l1->AddEntry(hDphi[kPADATA][1][1],"pA Data","p"); l1->Draw(); if (saveFigures) { if(outNameSuffix.EqualTo("")){ c1->SaveAs("figures/pT_dependence_dphi_pA_figure1.pdf"); c1->SaveAs("figures/pT_dependence_dphi_pA_figure1.gif"); } else { c1->SaveAs(Form("figures/pT_dependence_dphi_pA_figure1_%s.pdf", outNameSuffix.Data())); c1->SaveAs(Form("figures/pT_dependence_dphi_pA_figure1_%s.gif", outNameSuffix.Data())); } } TH1D* hTempPt = new TH1D("hTemp",";p_{T}^{#gamma} (GeV);",200,10,300); TCanvas* c2 = new TCanvas("c2","",1200,350); makeMultiPanelCanvas(c2,nPtBin,1,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c2->cd(ipt); hTempPt->SetXTitle("p_{T}^{Jet} (GeV)"); hTempPt->SetYTitle("#frac{dN}{dp_{T}} #frac{1}{N}"); hTempPt->SetAxisRange(10,150,"X"); // hTempPt->SetAxisRange(0,0.025,"Y"); hTempPt->SetAxisRange(0,0.08,"Y"); handsomeTH1(hTempPt,0); hTempPt->DrawCopy(); // hJetPt[kPAMC][1][ipt]->Scale(1./rjg[kPAMC][1]->GetBinContent(ipt)); // rjg normalization handsomeTH1(hJetPt[kPAMC][1][ipt], 1); hJetPt[kPAMC][1][ipt]->SetMarkerStyle(24); hJetPt[kPAMC][1][ipt]->Draw("same"); handsomeTH1(hJetPt[kPADATA][1][ipt],kRed); // hJetPt[kPADATA][1][ipt]->Scale(1./rjg[kPADATA][1]->GetBinContent(ipt)); hJetPt[kPADATA][1][ipt]->Draw("same"); double dx1=0.15; if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15);//yeonju 130823 onSun(30,0,200,0); } c2->cd(1); l1->Draw(); if (saveFigures) { if(outNameSuffix.EqualTo("")){ c2->SaveAs("figures/pT_dependence_jetPt_pA_figure1.pdf"); c2->SaveAs("figures/pT_dependence_jetPt_pA_figure1.gif"); } else { c2->SaveAs(Form("figures/pT_dependence_jetPt_pA_figure1_%s.pdf", outNameSuffix.Data())); c2->SaveAs(Form("figures/pT_dependence_jetPt_pA_figure1_%s.gif", outNameSuffix.Data())); } } TLegend *l2 = new TLegend(0.2116935,0.7012712,0.6149194,0.904661,NULL,"brNDC"); easyLeg(l2,"5.02TeV"); l2->AddEntry(hDphi[kPAMC][1][1],"pPb pythia+HIJING","p"); l2->AddEntry(hDphi[kPADATA][1][1],"pPb Data","p"); TCanvas* c21 = new TCanvas("c21","",500,500); handsomeTH1(meanJetPt[kPAMC][1], 1); meanJetPt[kPAMC][1]->SetYTitle("<p_{T}^{Jet}> (>30GeV)"); meanJetPt[kPAMC][1]->SetMarkerStyle(24); // meanJetPt[kPAMC][1]->SetAxisRange(-2,2,"X"); meanJetPt[kPAMC][1]->SetAxisRange(40,115,"Y"); meanJetPt[kPAMC][1]->Draw(); handsomeTH1(meanJetPt[kPADATA][1],kRed); meanJetPt[kPADATA][1]->Draw("same"); l1 ->Draw(); if (saveFigures) { if(outNameSuffix.EqualTo("")){ c21->SaveAs("figures/pT_dependence_jetPt_pA_figure2.pdf"); c21->SaveAs("figures/pT_dependence_jetPt_pA_figure2.gif"); } else { c21->SaveAs(Form("figures/pT_dependence_jetPt_pA_figure2_%s.pdf", outNameSuffix.Data())); c21->SaveAs(Form("figures/pT_dependence_jetPt_pA_figure2_%s.gif", outNameSuffix.Data())); } } TCanvas* c3 = new TCanvas("c3","",1200,350); makeMultiPanelCanvas(c3,nPtBin,1,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c3->cd(ipt); handsomeTH1(hxjg[kPAMC][1][ipt], 1); hxjg[kPAMC][1][ipt]->SetXTitle("x_{J#gamma}"); hxjg[kPAMC][1][ipt]->SetYTitle("#frac{dN}{dp_{T}} #frac{1}{N}"); hxjg[kPAMC][1][ipt]->SetMarkerStyle(24); // hxjg[kPAMC][1][ipt]->Scale(1./rjg[kPAMC][1]->GetBinContent(ipt)); // rjg normalization hxjg[kPAMC][1][ipt]->SetAxisRange(0,2,"X"); hxjg[kPAMC][1][ipt]->Draw(); handsomeTH1(hxjg[kPADATA][1][ipt],kRed); // hxjg[kPADATA][1][ipt]->Scale(1./rjg[kPADATA][1]->GetBinContent(ipt)); // rjg normalization hxjg[kPADATA][1][ipt]->Draw("same"); double dx1=0.15; if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15);//yeonju 130823 onSun(30,0,200,0); } c3->cd(1); l1->Draw(); if (saveFigures) { if(outNameSuffix.EqualTo("")){ c3->SaveAs("figures/pT_dependence_xjg_pA_figure1.pdf"); c3->SaveAs("figures/pT_dependence_xjg_pA_figure1.gif"); } else { c3->SaveAs(Form("figures/pT_dependence_xjg_pA_figure1_%s.pdf", outNameSuffix.Data())); c3->SaveAs(Form("figures/pT_dependence_xjg_pA_figure1_%s.gif", outNameSuffix.Data())); } } TCanvas* c31 = new TCanvas("c31","",500,500); handsomeTH1(meanXjg[kPAMC][1], 1); meanXjg[kPAMC][1]->SetYTitle("<x_{J#gamma}> (>30GeV)"); meanXjg[kPAMC][1]->SetMarkerStyle(24); // meanXjg[kPAMC][1]->SetAxisRange(-2,2,"X"); meanXjg[kPAMC][1]->SetAxisRange(0.6,1.2,"Y"); meanXjg[kPAMC][1]->Draw(); handsomeTH1(meanXjg[kPADATA][1],kRed); meanXjg[kPADATA][1]->Draw("same"); l1->Draw(); if (saveFigures) { if(outNameSuffix.EqualTo("")){ c31->SaveAs("figures/pT_dependence_xjg_pA_figure2.pdf"); c31->SaveAs("figures/pT_dependence_xjg_pA_figure2.gif"); } else { c31->SaveAs(Form("figures/pT_dependence_xjg_pA_figure2_%s.pdf", outNameSuffix.Data())); c31->SaveAs(Form("figures/pT_dependence_xjg_pA_figure2_%s.gif", outNameSuffix.Data())); } } TCanvas* c_rjg = new TCanvas("c_rjg","",500,500); handsomeTH1(rjg[kPAMC][1], 1); rjg[kPAMC][1]->SetYTitle("R_{J#gamma}"); rjg[kPAMC][1]->SetMarkerStyle(24); // rjg[kPAMC][1]->SetAxisRange(-2,2,"X"); rjg[kPAMC][1]->SetAxisRange(0.0,1.1,"Y"); rjg[kPAMC][1]->Draw(); handsomeTH1(rjg[kPADATA][1],kRed); rjg[kPADATA][1]->Draw("same"); l1->Draw(); if (saveFigures) { if(outNameSuffix.EqualTo("")){ c_rjg->SaveAs("figures/pT_dependence_rjg_pA_figure1.pdf"); c_rjg->SaveAs("figures/pT_dependence_rjg_pA_figure1.gif"); } else { c_rjg->SaveAs(Form("figures/pT_dependence_rjg_pA_figure1_%s.pdf", outNameSuffix.Data())); c_rjg->SaveAs(Form("figures/pT_dependence_rjg_pA_figure1_%s.gif", outNameSuffix.Data())); } } // Save the final root histogram files TFile* fResults; if(outNameSuffix.EqualTo("")){ fResults = new TFile("resultHistograms.root", "update"); } else { fResults = new TFile(Form("resultHistograms_%s.root", outNameSuffix.Data()), "update"); } // TFile * fResults = new TFile("resultHistograms_ppb_photonEnergy_ScaledBy0.015.root","update"); meanJetPt[kPADATA][1]->SetName(Form("meanJetPt_ppb")); meanJetPt[kPADATA][1]->Write(); meanXjg[kPADATA][1]->SetName(Form("meanXjg_ppb")); meanXjg[kPADATA][1]->Write(); rjg[kPADATA][1]->SetName(Form("meanRjg_ppb")); rjg[kPADATA][1]->Write(); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { hJetPt[kPADATA][1][ipt]->SetName(Form("dNdJetPt_ppb_ptBin%d",ipt)); hJetPt[kPADATA][1][ipt]->Write(); hJetPtIaaBin[kPADATA][1][ipt]->SetName(Form("dNdJetPt_IaaBin_ppb_ptBin%d",ipt)); hJetPtIaaBin[kPADATA][1][ipt]->Write(); hxjg[kPADATA][1][ipt]->SetName(Form("dNdXjg_ppb_ptBin%d",ipt)); hxjg[kPADATA][1][ipt]->Write(); hDphi[kPADATA][1][ipt]->SetName(Form("dNdphi_ppb_ptBin%d",ipt)); hDphi[kPADATA][1][ipt]->Write(); } fResults->Close(); }
void NewCosmicstest(){ //gROOT->Reset(); TStopwatch *clock0 = new TStopwatch(); TFile *fout = new TFile("Cosmictest.root","RECREATE"); bool high = 1; //Float_t z0 = 1400; Float_t z0 = 0; Float_t yTop = 600; Float_t xTop = 300; Float_t zTop = 3650; Float_t xdist = 3000; Float_t zdist = 9000; TH2D *StartXZ = new TH2D("xz","xz;x[cm];z[cm]",30,-(xdist/2),xdist/2,90,z0 - 4500,z0 + 4500); TH1D *StartTheta = new TH1D("#theta","#theta; #theta_Zenith",100,0,2); TH1D *StartPhi = new TH1D("#phi","#phi; #phi",50,0,7); TH1D *StartPHigh = new TH1D("PHigh","P; P[GeV]",100,-1,3); TH1D *StartP = new TH1D("P","P;P[GeV]",100,-1,3); TH1D *StartPLow = new TH1D("PLow","P;P[GeV]",100,-1,3); //TH1D *StartP = new TH1D("P","P;P[GeV]",100,0.1,1000); BinLogX(StartP); BinLogX(StartPHigh); BinLogX(StartPLow); TH2D *StartPTheta = new TH2D("P,Theta","P-Theta;P[GeV];#theta",150,-1,3,50,0,2); BinLogX(StartPTheta); TH2D *MCXZ = new TH2D("MCxz","xz;x[cm];z[cm]",30,-(xdist/2),xdist/2,90,z0 - 4500,z0 + 4500); TH1D *MCTheta = new TH1D("MC#theta","#theta; #theta",100,0,2); TH1D *MCPhi = new TH1D("MC#phi","#phi, #phi",50,0,7); TH1I *MCnTry = new TH1I("nTry","nTry",100,4.6,5); Double_t totalweightsum=0; Double_t px,py,pz,x,y,z,w, weighttest, weight; Int_t nTry,nInside,nEvent,nTest; Co3Rng *fRandomEngine = new Co3Rng(); int EVENTS = 400000; Int_t kmax = 40000; float weight1,weight1Low,weight1High; weight1Low = 123*xdist*zdist/EVENTS/10000; // expected #muons per spill/ #simulated events per spill 174*30*90/500000 cout<<weight1Low<<endl; double I = fRandomEngine->fSpectrumH->Integral(100,1000); weight1High = 2*TMath::Pi()/3*I*xdist*zdist/EVENTS/10000; //weight2 = 900/I; // 1/(mean momentum weight), P_max-P_min/(3*0.3044/2pi) cout<< weight1High<<endl; Float_t weight3 = 4.833931503; // MC average of nTry/nEvents 4.833949997 +- 0.000010494 weight1 = 1; weight = weight1 / weight3; nInside = 0; nEvent = 0; nTest = 0; weighttest = 0; y = 1900; //20m over beam axis w = weight/kmax; clock0->Start(); for(Int_t k = 0;k<kmax;k++){ cout<<k<<endl; nTry =0; for(Int_t i=0;i<EVENTS;i++){ Bool_t hit = 0; do{ // shower characteristics double phi = fRandomEngine->Uniform(0,2*TMath::Pi()); double theta = fRandomEngine->fTheta->GetRandom(); //momentum components px = TMath::Sin(phi)*TMath::Sin(theta); pz = TMath::Cos(phi)*TMath::Sin(theta); py = -TMath::Cos(theta); // start position, area 1120m^2 x = fRandomEngine->Uniform(-xdist/2,xdist/2); z = fRandomEngine->Uniform(z0 - zdist/2, z0 + zdist/2); // claim for flight close to the actual detector if((abs(x-(y+yTop)*px/py) < xTop && abs(z-z0-(y+yTop)*pz/py) < zTop) || (abs(x-(y-yTop)*px/py) < xTop && abs(z-z0-(y-yTop)*pz/py) < zTop)|| abs(y-(x+xTop)*py/px)<yTop && abs(z-z0-(x+xTop)*pz/px)<zTop || abs(y-(x-xTop)*py/px)<yTop && abs(z-z0-(x-xTop)*pz/px)<zTop){ // muon momentum double P; //if (!high) {P = fRandomEngine->NEWstest(theta);} //else {P = fRandomEngine->fSpectrumH->GetRandom();} // high P = fRandomEngine->fSpectrumH->GetRandom(); w = weight1High/weight3/kmax; StartP->Fill(P,w); StartPHigh->Fill(P,w); StartPTheta->Fill(P,theta,w); // low P = fRandomEngine->NEWstest(theta); w = weight1Low/weight3/kmax; StartP->Fill(P,w); StartPLow->Fill(P,w); StartPTheta->Fill(P,theta,w); px = px*P; py = py*P; pz = pz*P; //muon or anti-muon hit = 1; nInside++; // StartP->Fill(P,w); w = weight1Low/weight3/kmax + weight1High/weight3/kmax; StartTheta->Fill(theta,w); // kein Weight! StartPhi->Fill(phi,w); // kein Weight! StartXZ->Fill(x,z,w); // kein Weight! StartPTheta->Fill(P,theta,w); } nTry++; weighttest += w; MCTheta->Fill(theta,w); // kein Weight! MCPhi->Fill(phi,w); MCXZ->Fill(x,z,w); nTest++; }while(!hit); nEvent++; } MCnTry->Fill(1.0*nTry/EVENTS); } clock0->Stop(); delete fRandomEngine; cout<<nEvent<<" events have been generated."<<endl; cout<<"There is a total of "<<nInside<<"/"<<nTest<<" muons that passed close enough to the detector."<<endl; cout<<"Including the given weight this corresponds to "; cout<<kmax*weighttest/xdist/zdist*10000/123.3044<<" spills (1 spill = "<<xdist*zdist*123.3044/10000; cout<<" real cosmic muons = "<<EVENTS<<" simulated events)."<<endl; cout<<weighttest<<endl; clock0->Print(); Double_t meanflux = 0; Int_t binsum = 0; for (Int_t ix = 2; ix<29;ix++){ for (Int_t iz = 2; iz<89;iz++){ binsum++; meanflux += MCXZ->GetBinContent(ix,iz); } } cout<< "meanflux: "<<meanflux/binsum<<" "<< meanflux<<endl<<endl; printf("MCnTry: %.9f +- %.9f",MCnTry->GetMean(),MCnTry->GetMeanError()); cout<<endl<<endl; TCanvas *c1 = new TCanvas("c1","c1",400,400); c1->Divide(1,1); c1->cd(1); MCnTry->DrawCopy(); TCanvas *c4 = new TCanvas("c4","c4",400,400); c4->Divide(1,1); c4->cd(1); StartPTheta->DrawCopy("SURF2"); gPad->SetLogx(); //TCanvas *c2 = new TCanvas("c2","c2",400,400); //c2->Divide(1,1); //c2->cd(1); //gPad->SetLogy(); //wei->DrawCopy(); TCanvas *c3 = new TCanvas("c3","c3",1600,800); c3->Divide(4,2); c3->cd(1); StartXZ->DrawCopy("COLZ"); c3->cd(2); //MCP->SetLineColor(kGreen); // MCP->DrawCopy(); //StartP->DrawCopy(); //TF1 *fs = new TF1("fs",NEWs,1,100,2); //fs->FixParameter(0, 0); //fs->FixParameter(1, 500); //StartP->Add(fs,-1); StartP->DrawCopy(); //StartP->Fit(fs,"I"); // //fs->DrawCopy("SAME"); //gPad->SetLogy(); gPad->SetLogx(); c3->cd(3); MCTheta->SetLineColor(kGreen); MCTheta->DrawCopy(); StartTheta->DrawCopy("SAME"); //TF1 *f1 = new TF1("f1","[0]*cos(x)*cos(x)",1.57,3.14); //StartTheta->Fit(f1,"","",1.57,3.14); gPad->SetLogy(0); gPad->SetLogx(0); c3->cd(4); MCPhi->SetLineColor(kGreen); MCPhi->DrawCopy(); StartPhi->DrawCopy("SAME"); //TF1 *f1 = new TF1("f1","[0]*cos(x)*cos(x)",1.57,3.14); //StartTheta->Fit(f1,"","",1.57,3.14); gPad->SetLogy(0); gPad->SetLogx(0); c3->cd(5); MCXZ->DrawCopy("COLZ"); c3->cd(6); //MCP->Divide(StartP); // MCP->DrawCopy(); gPad->SetLogy(0); gPad->SetLogx(0); c3->cd(7); //MCTheta->Divide(StartTheta); MCTheta->DrawCopy(); gPad->SetLogy(); gPad->SetLogx(0); c3->cd(8); //MCPhi->Divide(StartPhi); MCPhi->DrawCopy(); gPad->SetLogy(0); gPad->SetLogx(0); c3->Update(); c3->SaveAs("Start.png"); StartXZ->Write(); StartTheta->Write(); StartPhi->Write(); StartP->Write(); StartPLow->Write(); StartPHigh->Write(); StartPTheta->Write(); MCXZ->Write(); MCTheta->Write(); MCPhi->Write(); MCnTry->Write(); fout ->Close(); }
void drawResults(bool drawSinglePanels = false) { // const int kPPcentral = 1; // const int kPPperipheral =2 ; // const int kHIcentral = 3; // const int kHIperipheral = 4; // const int kPADATA = 5; // const int kPAMC = 6; //const int nPtBin = 4; // double ptBin[nPtBin+1] = {40, 50,60,80,9999}; TH1D* meanJetPt[8]; // [collision] [Before/After variation] TH1D* meanJetPtSys[8]; // [collision] [Before/After variation] TH1D* meanXjg[8]; // [collision] [Before/After variation] TH1D* meanXjgSys[8]; // [collision] [Before/After variation] TH1D* meanRjg[8]; TH1D* meanRjgSys[8]; TFile * f = new TFile("../resultHistograms/resultHistograms_ppSmeared10030.root"); meanJetPt[1] =(TH1D*)f->Get(Form("meanJetPt_pp")); meanXjg[1] =(TH1D*)f->Get(Form("meanXjg_pp")); meanRjg[1] =(TH1D*)f->Get(Form("meanRjg_pp")); f = new TFile("../resultHistograms/resultHistograms_ppSmeared13099.root"); meanJetPt[2] =(TH1D*)f->Get(Form("meanJetPt_pp")); meanXjg[2] =(TH1D*)f->Get(Form("meanXjg_pp")); meanRjg[2] =(TH1D*)f->Get(Form("meanRjg_pp")); // pbpb f = new TFile("../resultHistograms/resultHistograms_nominal_vtxCentWeighted.root"); meanJetPt[7] =(TH1D*)f->Get(Form("meanJetPt_pp")); meanXjg[7] =(TH1D*)f->Get(Form("meanXjg_pp")); meanRjg[7] =(TH1D*)f->Get(Form("meanRjg_pp")); meanJetPt[3] =(TH1D*)f->Get(Form("meanJetPt_pbpb_centralityBin1")); meanXjg[3] =(TH1D*)f->Get(Form("meanXjg_pbpb_centralityBin1")); meanRjg[3] =(TH1D*)f->Get(Form("meanRjg_pbpb_centralityBin1")); meanJetPt[4] =(TH1D*)f->Get(Form("meanJetPt_pbpb_centralityBin2")); meanXjg[4] =(TH1D*)f->Get(Form("meanXjg_pbpb_centralityBin2")); meanRjg[4] =(TH1D*)f->Get(Form("meanRjg_pbpb_centralityBin2")); // pPb meanJetPt[5] =(TH1D*)f->Get(Form("meanJetPt_ppb")); meanXjg[5] =(TH1D*)f->Get(Form("meanXjg_ppb")); meanRjg[5] =(TH1D*)f->Get(Form("meanRjg_ppb")); f = new TFile("../resultHistograms/resultHistograms_MCrecoIso_vtxCentWeighted.root"); //pythia+hijing meanJetPt[6] =(TH1D*)f->Get(Form("meanJetPt_ppb")); meanXjg[6] =(TH1D*)f->Get(Form("meanXjg_ppb")); meanRjg[6] =(TH1D*)f->Get(Form("meanRjg_ppb")); TFile* fSys = new TFile("../relativeSys/relativeSys_merged.root"); meanJetPtSys[1] =(TH1D*)fSys->Get("meanJetPt_pp_uncertainty_merged"); meanRjgSys[1] =(TH1D*)fSys->Get(Form("meanRjg_pp_uncertainty_merged")); meanXjgSys[1] =(TH1D*)fSys->Get(Form("meanXjg_pp_uncertainty_merged")); meanJetPtSys[2] = (TH1D*)meanJetPtSys[1]->Clone(Form("%s_2",meanJetPtSys[1]->GetName())); meanRjgSys[2] = (TH1D*)meanRjgSys[1]->Clone(Form("%s_2",meanRjgSys[1]->GetName())); meanXjgSys[2] = (TH1D*)meanXjgSys[1]->Clone(Form("%s_2",meanXjgSys[1]->GetName())); meanJetPtSys[3] =(TH1D*)fSys->Get("meanJetPt_pbpb_centralityBin1_uncertainty_merged"); meanXjgSys[3] =(TH1D*)fSys->Get(Form("meanXjg_pbpb_centralityBin1_uncertainty_merged")); meanRjgSys[3] =(TH1D*)fSys->Get(Form("meanRjg_pbpb_centralityBin1_uncertainty_merged")); meanJetPtSys[4] =(TH1D*)fSys->Get("meanJetPt_pbpb_centralityBin2_uncertainty_merged"); meanXjgSys[4] =(TH1D*)fSys->Get(Form("meanXjg_pbpb_centralityBin2_uncertainty_merged")); meanRjgSys[4] =(TH1D*)fSys->Get(Form("meanRjg_pbpb_centralityBin2_uncertainty_merged")); meanJetPtSys[5] =(TH1D*)fSys->Get("meanJetPt_ppb_uncertainty_merged"); meanXjgSys[5] =(TH1D*)fSys->Get(Form("meanXjg_ppb_uncertainty_merged")); meanRjgSys[5] =(TH1D*)fSys->Get(Form("meanRjg_ppb_uncertainty_merged")); // RJG!! TCanvas* c2; //c2->Divide(3,1); if( !drawSinglePanels) { c2 = new TCanvas("c1","",1300,500); makeMultiPanelCanvas(c2,3,1,0.0,0.0, 0.15, 0.15, 0.025); } else { c2 = new TCanvas("c1","",1450,500); c2->Divide(3,1); //makeMultiPanelCanvas(c2,3,1,0.2,0.2, 0.15, 0.15, 0.025); } c2->cd(3); handsomeTH1(meanRjg[1],1,1,21); // drawSys(TH1 *h,TH1 *sys, Int_t theColor= newYellow, Int_t fillStyle = -1, Int_t lineStyle = -1) TH1D* tempR = new TH1D("tempR",";p_{T}^{#gamma} (GeV);R_{J#gamma}",1000,40,130); tempR->Reset(); handsomeTH1(tempR,0); //tempR->SetAxisRange(0,1.2,"Y"); tempR->SetAxisRange(0,1.0,"Y"); tempR->SetAxisRange(40.01,109.99,"X"); tempR->GetYaxis()->SetNdivisions(505); tempR->Draw(); drawSys(meanRjg[1], meanRjgSys[1], kGreen,3001); drawSys(meanRjg[3], meanRjgSys[3]); handsomeTH1(meanRjg[1],1,1,21); meanRjg[1]->DrawCopy("same"); handsomeTH1(meanRjg[3],2,1,20); meanRjg[3]->DrawCopy("same"); meanRjg[1]->SetFillStyle(3001); meanRjg[1]->SetFillColor(kGreen); meanRjg[3]->SetFillColor(90); meanRjg[3]->SetFillStyle(1001); meanRjg[1]->SetLineColor(0); meanRjg[3]->SetLineColor(0); if ( 1==1 ){ TLegend *ly = new TLegend(0.4,0.2,0.75,0.4,NULL,"brNDC"); //easyLeg(ly,"2.76TeV"); easyLeg(ly); ly->AddEntry(meanRjg[3],"PbPb 0-30%","fp"); ly->AddEntry(meanRjg[1],"Smeared pp reference","fp"); ly->Draw(); } if(!drawSinglePanels) drawCMSppPbPbDist(0.04,0.9); else drawCMSppPbPbDist(0.2,0.9); c2->cd(2); tempR->Draw(); drawSys(meanRjg[2], meanRjgSys[2], kGreen,3001); drawSys(meanRjg[4], meanRjgSys[4]); // meanRjg[2]->SetMarkerStyle(25); handsomeTH1(meanRjg[2],1,1,25); meanRjg[2]->DrawCopy("same"); handsomeTH1(meanRjg[4],2,1,24); // meanRjg[4]->SetMarkerStyle(24); meanRjg[4]->DrawCopy("same"); meanRjg[2]->SetFillStyle(3001); meanRjg[2]->SetFillColor(kGreen); meanRjg[4]->SetFillColor(90); meanRjg[4]->SetFillStyle(1001); meanRjg[2]->SetLineColor(0); meanRjg[4]->SetLineColor(0); if ( 1==1 ){ TLegend *ly = new TLegend(0.4,0.2,0.75,0.4,NULL,"brNDC"); easyLeg(ly); ly->AddEntry(meanRjg[4],"PbPb 30-100%","fp"); ly->AddEntry(meanRjg[2],"Smeared pp reference","fp"); ly->Draw(); } if(!drawSinglePanels) drawCMSppPbPbDist(0.04,0.9); else drawCMSppPbPbDist(0.2,0.9); c2->cd(1); tempR->SetAxisRange(40,109.99,"X"); tempR->DrawCopy(); tempR->SetAxisRange(40.01,109.99,"X"); drawSys(meanRjg[5], meanRjgSys[5], newYellow); drawSys(meanRjg[7], meanRjgSys[2], kGreen, 3001); // handsomeTH1(meanRjg[5],9,1,34); handsomeTH1(meanRjg[5],2,1,34); handsomeTH1(meanRjg[6],1,1,25); handsomeTH1(meanRjg[7],1,1); meanRjg[6]->DrawCopy("same"); meanRjg[7]->DrawCopy("same"); meanRjg[5]->DrawCopy("same"); meanRjg[7]->SetFillStyle(3001); meanRjg[7]->SetFillColor(kGreen); meanRjg[5]->SetFillColor(90); meanRjg[5]->SetFillStyle(1001); meanRjg[7]->SetLineColor(0); meanRjg[5]->SetLineColor(0); if ( 1==1 ) { TLegend *ly = new TLegend(0.5,0.2,0.85,0.42,NULL,"brNDC");//0.4,0.2,0.75,0.4 easyLeg(ly); ly->AddEntry(meanRjg[5],"pPb DATA","fp"); ly->AddEntry(meanRjg[7],"pp DATA (2.76 TeV)","fp"); ly->AddEntry(meanRjg[6],"PYTHIA+HIJING","p"); ly->Draw(); } drawCMSpPbDist(0.2,0.9); c2->SaveAs("pT_dependence_rjg_pp_pbpb.pdf"); c2->SaveAs("pT_dependence_rjg_pp_pbpb.gif"); //c2->SaveAs("pT_dependence_rjg_pp_pbpb.png"); // ppPbPb meanJetPt TCanvas* c3 = new TCanvas("c3","",1300,500); if(!drawSinglePanels) makeMultiPanelCanvas(c3,3,1,0.0,0.0, 0.15, 0.15, 0.025); else c3->Divide(3,1); //makeMultiPanelCanvas(c3,3,1,0.2,0.2, 0.15, 0.15, 0.025); c3->cd(1); handsomeTH1(meanRjg[1],1); // drawSys(TH1 *h,TH1 *sys, Int_t theColor= newYellow, Int_t fillStyle = -1, Int_t lineStyle = -1) // tempR->Draw(); TH1D* tempJ = new TH1D("tempJ",";p_{T}^{#gamma}; <p_{T}^{Jet}>",10000,40,130); tempJ->Reset(); handsomeTH1(tempJ,0); tempJ->SetAxisRange(40.01,109.99,"Y"); tempJ->SetAxisRange(40.,109.99,"X"); tempJ->DrawCopy(); tempJ->SetAxisRange(40.01,109.99,"X"); drawSys(meanJetPt[5], meanJetPtSys[5], newYellow); drawSys(meanJetPt[7], meanJetPtSys[1], kGreen,3001); // handsomeTH1(meanJetPt[5],9,1,34); handsomeTH1(meanJetPt[5],2,1,34); handsomeTH1(meanJetPt[6],1,1,25); handsomeTH1(meanJetPt[7],1,1); meanJetPt[6]->DrawCopy("same"); meanJetPt[7]->DrawCopy("same"); meanJetPt[5]->DrawCopy("same"); if ( 1==1 ) { TLegend *ly = new TLegend(0.53,0.18,0.88,0.4,NULL,"brNDC"); easyLeg(ly); ly->AddEntry(meanJetPt[5],"pPb DATA","p"); ly->AddEntry(meanJetPt[7],"pp DATA (2.76 TeV)","p"); ly->AddEntry(meanJetPt[6],"PYTHIA+HIJING","p"); ly->Draw(); } drawCMSpPbDist(0.2,0.9); c3->cd(3); handsomeTH1(meanJetPt[1],1,1,21); // drawSys(TH1 *h,TH1 *sys, Int_t theColor= newYellow, Int_t fillStyle = -1, Int_t lineStyle = -1) tempJ->Draw(); drawSys(meanJetPt[3], meanJetPtSys[3]); drawSys(meanJetPt[1], meanJetPtSys[1], kGreen,3001); handsomeTH1(meanJetPt[3],2 ); meanJetPt[1]->Draw("same"); meanJetPt[3]->Draw("same"); if ( 1==1 ){ TLegend *ly = new TLegend(0.58,0.18,0.93,0.4,NULL,"brNDC"); easyLeg(ly); ly->AddEntry(meanJetPt[3],"PbPb 0-30%","p"); ly->AddEntry(meanJetPt[1],"pp (smeared)","p"); ly->Draw(); } drawCMSppPbPbDist(0.1,0.9); c3->cd(2); tempJ->Draw(); drawSys(meanJetPt[2], meanJetPtSys[2], kGreen,3001); drawSys(meanJetPt[4], meanJetPtSys[4]); // meanJetPt[2]->SetMarkerStyle(25); meanJetPt[2]->Draw("same"); handsomeTH1(meanJetPt[4],2 ); // meanJetPt[4]->SetMarkerStyle(24); meanJetPt[4]->Draw("same"); if ( 1==1 ){ TLegend *ly = new TLegend(0.58,0.18,0.93,0.4,NULL,"brNDC"); easyLeg(ly); ly->AddEntry(meanJetPt[4],"PbPb 30-100%","p"); ly->AddEntry(meanJetPt[2],"pp (smeared)","p"); ly->Draw(); } drawCMSppPbPbDist(0.1,0.9); c3->SaveAs("pT_dependence_jetPt_pp_pbpb.pdf"); c3->SaveAs("pT_dependence_jetPt_pp_pbpb.gif"); //c3->SaveAs("pT_dependence_jetPt_pp_pbpb.png"); // mean xjg TCanvas* c7; if(!drawSinglePanels) { c7 = new TCanvas("c7","",1300,500); makeMultiPanelCanvas(c7,3,1,0.0,0.0, 0.15, 0.15, 0.025); } else { c7 = new TCanvas("c7","",1450,500); c7->Divide(3,1); //makeMultiPanelCanvas(c7,3,1,0.2,0.2, 0.15, 0.15, 0.025); } c7->cd(3); handsomeTH1(meanXjg[1],1,1,24); // drawSys(TH1 *h,TH1 *sys, Int_t theColor= newYellow, Int_t fillStyle = -1, Int_t lineStyle = -1) TH1D* tempX = new TH1D("tempX",";p_{T}^{#gamma} (GeV);<X_{J#gamma}>;",10000,40,130); tempX->Reset(); handsomeTH1(tempX,0); tempX->SetAxisRange(0.6,1.1,"Y"); tempX->SetAxisRange(40.01,109.99,"X"); tempX->GetYaxis()->SetNdivisions(606); tempX->Draw(); drawSys(meanXjg[3], meanXjgSys[3]); drawSys(meanXjg[1], meanXjgSys[1], kGreen,3001); // meanXjg[1]->SetMarkerStyle(21); handsomeTH1(meanXjg[1],1,1,21); meanXjg[1]->DrawCopy("same"); handsomeTH1(meanXjg[3],2,1,20); meanXjg[3]->DrawCopy("same"); meanXjg[1]->SetFillStyle(3001); meanXjg[1]->SetFillColor(kGreen); meanXjg[3]->SetFillColor(90); meanXjg[3]->SetFillStyle(1001); meanXjg[1]->SetLineColor(0); meanXjg[3]->SetLineColor(0); Float_t xpos = 0.022; if(drawSinglePanels) xpos = 0.15; if ( 1==1 ){ TLegend *ly = new TLegend(xpos,0.1861745,0.578901,0.3788434,NULL,"brNDC"); easyLeg(ly); ly->AddEntry(meanXjg[3],"PbPb 0-30%","fp"); ly->AddEntry(meanXjg[1],"Smeared pp reference","fp"); ly->Draw(); } drawCMSppPbPbDist(0.6,0.9); c7->cd(2); tempX->Draw(); drawSys(meanXjg[4], meanXjgSys[4]); drawSys(meanXjg[2], meanXjgSys[2], kGreen,3001); // meanXjg[2]->SetMarkerStyle(25); handsomeTH1(meanXjg[2],1,1,25); meanXjg[2]->DrawCopy("same"); handsomeTH1(meanXjg[4],2,1,24 ); // meanXjg[4]->SetMarkerStyle(24); meanXjg[4]->DrawCopy("same"); meanXjg[2]->SetFillStyle(3001); meanXjg[2]->SetFillColor(kGreen); meanXjg[4]->SetFillColor(90); meanXjg[4]->SetFillStyle(1001); meanXjg[2]->SetLineColor(0); meanXjg[4]->SetLineColor(0); if ( 1==1 ){ TLegend *ly = new TLegend(xpos,0.1861745,0.578901,0.3788434,NULL,"brNDC"); easyLeg(ly); ly->AddEntry(meanXjg[4],"PbPb 30-100%","fp"); ly->AddEntry(meanXjg[2],"Smeared pp reference","fp"); ly->Draw(); } drawCMSppPbPbDist(0.6,0.9); c7->cd(1); tempX->SetAxisRange(40.0,109.99,"X"); tempX->DrawCopy(); tempX->SetAxisRange(40.01,109.99,"X"); drawSys(meanXjg[5], meanXjgSys[5], newYellow); drawSys(meanXjg[7], meanXjgSys[2], kGreen, 3001); // handsomeTH1(meanXjg[5],9,1,34); handsomeTH1(meanXjg[5],2,1,34); handsomeTH1(meanXjg[6],1,1,25); handsomeTH1(meanXjg[7],1,1); meanXjg[6]->DrawCopy("same"); meanXjg[7]->DrawCopy("same"); meanXjg[5]->DrawCopy("same"); meanXjg[7]->SetFillStyle(3001); meanXjg[7]->SetFillColor(kGreen); meanXjg[5]->SetFillColor(90); meanXjg[5]->SetFillStyle(1001); meanXjg[7]->SetLineColor(0); meanXjg[5]->SetLineColor(0); if ( 1==1 ) { TLegend *ly = new TLegend(0.1722123,0.1861,0.4788343,0.3788,NULL,"brNDC"); easyLeg(ly); ly->AddEntry(meanXjg[5],"pPb DATA","fp"); ly->AddEntry(meanXjg[7],"pp DATA (2.76 TeV)","fp"); ly->AddEntry(meanXjg[6],"PYTHIA+HIJING","p"); ly->Draw(); } drawCMSpPbDist(0.65,0.90); c7->SaveAs("pT_dependence_meanXjg_pp_pbpb.pdf"); c7->SaveAs("pT_dependence_meanXjg_pp_pbpb.gif"); //c7->SaveAs("pT_dependence_meanXjg_pp_pbpb.png"); // TCanvas* c10 = new TCanvas("c10","",1200,350); // makeMultiPanelCanvas(c10,nPtBin,1,0.0,0.0,0.2,0.15,0.02); // for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { // c10->cd(ipt); // hTempPt->SetAxisRange(20,200,"X"); // hTempPt->SetAxisRange(0,2.5,"Y"); // hTempPt->SetYTitle("Yield^{JeT} Ratio"); // handsomeTH1(hTempPt,0); // hTempPt->DrawCopy(); // IaaRatio[4][ipt] = (TH1D*)Iaa[4][ipt]->Clone(Form("%s_ratio",Iaa[4][ipt]->GetName()) ); // IaaRatio[4][ipt]->Divide(Iaa[2][ipt]); // IaaRatioSys[4][ipt] = mergeSys( IaaSys[2][ipt], IaaSys[4][ipt]) ; // drawSys(IaaRatio[4][ipt], IaaRatioSys[4][ipt], newYellow); // jumSun(20,1,200,1); // handsomeTH1(IaaRatio[4][ipt],2); // IaaRatio[4][ipt]->SetMarkerStyle(24); // IaaRatio[4][ipt]->Draw("same"); // double dx1=0.15; // drawText(Form("p_{T}^{#gamma} > %dGeV ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 // drawText(Form("(PbPb)/(pp smeared) 30-100%%"), 0.12+dx1+0.05,0.69,1,15);//yeonju 130823 // } // c10->SaveAs("pT_dependence_iAA_ratio2.pdf"); }
void AnalyzeData(char *DataFile = "drs4_peds_5buffers.dat", Int_t nevt, Int_t startEv = 1, char *PedFile, Int_t DrawExtraGraphs = 0) { // Redefine DOMINO Depth in ADC counts const Float_t DominoDepthADC = pow(2, DOMINO_DEPTH); // open file FILE *fdata = OpenDataFile(DataFile); struct channel_struct *p; struct channel_struct *dep; // create histograms // create list of histograms for channels and distribution TList *DistChList = new TList(); TH1F *distch; // histo with distribution of cell-charge, for each channel TList *DistChSubList = new TList(); TH1F *distchsub; // histo with distribution of cell-charge, pedestals subtracted, for each channel TList *DistCh0SubList = new TList(); TH1F *distch0sub; // histo with distribution of cell-charge, pedestals subtracted, // channel 0 subtracted for each channel TList *grPedList = new TList(); TGraphErrors *grPed; // for each channel, pedestal value and RMS for each cell is plotted TList *hCellList = new TList(); TH1F *hCell; // charge distribution for each cell (DOMINO_NCELL x DOMINO_NCH histos) TList *hCellSubList = new TList(); TH1F *hCellSub; // charge distribution for each cell (DOMINO_NCELL x DOMINO_NCH histos), pedestal subtracted TList *hRMSList = new TList(); TH1F *hRMSdist; // histo with RMS distribution (statistical RMS of distribution) TList *hRMSFitList = new TList(); TH1F *hRMSFitdist; // histo with RMS distribution (RMS of Gaussian fit) TList *grDataList = new TList(); TGraphErrors *grData; // charge-cell and RMS for each cell is plotted TList *grDataSubList = new TList(); TGraphErrors *grDataSub; // pedestal subtracted charge-cell and RMS for each cell is plotted for (int h = 0; h < DOMINO_NCH; h++) { // TString title = "Data Dist channel"; title += h; distch = new TH1F(title, title, DominoDepthADC, 0., DominoDepthADC); DistChList->Add(distch); // TString title = "Data Dist Ped Sub channel"; title += h; distchsub = new TH1F(title, title, DominoDepthADC, -DominoDepthADC/2, DominoDepthADC/2); DistChSubList->Add(distchsub); // TString title = "Data Dist Ped Ch0 Sub channel"; title += h; distch0sub = new TH1F(title, title, DominoDepthADC, -DominoDepthADC/2, DominoDepthADC/2); DistCh0SubList->Add(distch0sub); // TString title = "Pedestal ch"; title += h; grPed = new TGraphErrors(DOMINO_NCELL); grPed->SetTitle(title); grPedList->Add(grPed); // TString title = "Data ch"; title += h; grData = new TGraphErrors(DOMINO_NCELL); grData->SetTitle(title); grDataList->Add(grData); // // Mean data and RMS for each channel and cell TString title = "Data PedSubtracted ch"; title += h; grDataSub = new TGraphErrors(DOMINO_NCELL); grDataSub->SetTitle(title); grDataSubList->Add(grDataSub); // for (int ch = 0; ch < DOMINO_NCELL; ch++) { // data distribution histos TString title = "Data ch"; title += h; title += " cell"; title += ch; hCell = new TH1F(title, title, DominoDepthADC, 0., DominoDepthADC); hCellList->Add(hCell); // data (ped subtracted) distribution histos TString title = "Data PedSub ch"; title += h; title += " cell "; title += ch; hCellSub = new TH1F(title, title, 2 * DominoDepthADC, -1 * DominoDepthADC, DominoDepthADC); hCellSubList->Add(hCellSub); } // Data-RMS distribution histos TString title = "RMSDist channel"; title += h; hRMSdist = new TH1F(title, title, 100, 0, 20.); hRMSList->Add(hRMSdist); // Data-RMS (calculated through a fit) distribution histos TString title = "RMSFitDist channel"; title += h; hRMSFitdist = new TH1F(title, title, 100, 0, 20.); hRMSFitList->Add(hRMSFitdist); } //-------------- // // calculate or read pedestals from file grPedList = OpenPedestals(PedFile); // return; // // ====== Read data file and subtract the pedestals // // Count number of events in data file int nevtDataMax = 0; while (!feof(fdata)) { fread((void *) &event_data, 1, sizeof(event_data), fdata); nevtDataMax++; } printf("nevtDataMax: %d\n", nevtDataMax); if (nevt > (nevtDataMax - startEv) || nevt == 0) nevt = nevtDataMax - startEv; cout << endl << "==>> Processing " << nevt << " events from file " << DataFile << endl; rewind(fdata); Int_t ievt = 1; // go to first event (startEv) while (ievt < startEv) { fread((void *) &event_data, 1, sizeof(event_data), fdata); if (feof(fdata)) break; ievt++; } // filling ievt = 1; Int_t flagEnd = 0; Double_t chtmp; Double_t PedVal, itmp, Ch0Val; // loop on events cout << endl << " --- read DATA file:" << fdata << endl; while (ievt <= nevt && !flagEnd) { fread((void *) &event_data, 1, sizeof(event_data), fdata); if (feof(fdata)) flagEnd = 1; if (ievt % (nevt / 10 + 1) == 0) cout << "*" << endl; p = (struct channel_struct *) &event_data.ch[0]; // read bunch of data dep = (struct channel_struct *) &event_data.ch[1]; // read bunch of data TGraphErrors *grCh0 = new TGraphErrors(DOMINO_NCELL); // loop on channels for (int h = 0; h < DOMINO_NCH; h++) { // loop on cells distch = (TH1F *) DistChList->At(h); distchsub = (TH1F *) DistChSubList->At(h); grPed = (TGraphErrors *) grPedList->At(h); distch0sub = (TH1F *) DistCh0SubList->At(h); if(h==0) { for(i = 0; i < DOMINO_NCELL;i++) { grPed->GetPoint(i, itmp, PedVal); chtmp = (Double_t)(p->data[i]); chtmp = chtmp - PedVal; grCh0->SetPoint(i,itmp, chtmp); } } for (int i = 0; i < DOMINO_NCELL; i++) { // Read pedestal value for this cell grPed->GetPoint(i, itmp, PedVal); grCh0->GetPoint(i, itmp, Ch0Val); // cout << itmp << ", " << PedVal << endl; // Read calibration correction for this cell // CalFact = //charge distribution for each cell, pedestal subtracted chtmp = (Double_t)(p->data[i]); // data value // cout << "tcell, tcell, depth: " << chtmp << "," << p->data[i] << "," << deptmp << endl; distch->Fill(chtmp); // Check data value: must be within DOMINO Depth // if(chtmp > DominoDepthADC) // cout << " === WARNING!!! Channel " << h << " Cell " << i << " has value " << chtmp << endl; // cout << "Charge: " << p->data[i] << endl; ((TH1 *) hCellList->At(h * DOMINO_NCELL + i))->Fill(chtmp); // Now the pedestal is subtracted chtmp = chtmp - PedVal; distchsub->Fill(chtmp); ((TH1 *) hCellSubList->At(h * DOMINO_NCELL + i))->Fill(chtmp); chtmp = chtmp - Ch0Val; distch0sub->Fill(chtmp); } p++; // next channel } ievt++; // next event } cout << endl; // now mean and RMS for each cell are computed and save in histos and graphs cout << " --- filling data histos and grphs " << endl; TF1 *fgauss = new TF1("fgauss", Gauss, -10., 10., 3); fgauss->SetParLimits(0, 0.1, 10000.); fgauss->SetParLimits(1, 0., 4096.); fgauss->SetParLimits(2, 0.1, 20.); Float_t mean, rms, meansub, rmssub; for (int h = 0; h < DOMINO_NCH; h++) { // for (int h=5; h<6; h++){ cout << " Channel:" << h << endl; hRMSdist = (TH1F *) hRMSList->At(h); hRMSFitdist = (TH1F *) hRMSFitList->At(h); grData = (TGraphErrors *) grDataList->At(h); grDataSub = (TGraphErrors *) grDataSubList->At(h); for (int ch = 0; ch < DOMINO_NCELL; ch++) { // data distribution histos // cout << "cell:" << ch << " index:" << h*DOMINO_NCELL+ch << " Mean,RMS:"<<hCell->GetMean()<< "," << hCell->GetRMS()<<endl; hCell = (TH1F *) hCellList->At(h * DOMINO_NCELL + ch); mean = hCell->GetMean(); rms = hCell->GetRMS(); hCellSub = (TH1F *) hCellSubList->At(h * DOMINO_NCELL + ch); meansub = hCellSub->GetMean(); rmssub = hCellSub->GetRMS(); fgauss->SetParameter(0, (Double_t) nevt / 4.); fgauss->SetParameter(1, mean); fgauss->SetParameter(2, rms); // hCell->Fit("fgauss","QN0"); grData->SetPoint(ch, ch, mean); grData->SetPointError(ch, 0, rms); grDataSub->SetPoint(ch, ch, meansub); // grDataSub->SetPointError(ch,0.5,rmssub); grDataSub->SetPointError(ch, 0.5, 2.1); hRMSdist->Fill(rms); hRMSFitdist->Fill(fgauss->GetParameter(2)); // cout << "cell:" << ch << " index:" << h*DOMINO_NCELL+ch << " Mean,RMS:"<< mean << "," << rms<<endl; } } Double_t x, y, chtmp, x1, x2, y1, y2; /*TList *grCellCalibList = OpenCalibFile("CalibrationData1000events.root"); TGraphErrors *grCellCalib; TGraphErrors *grDataSubCalib = new TGraphErrors(DOMINO_NCELL); grDataSubCalib->SetTitle("Data after calibration correction"); grDataSub = (TGraphErrors *) grDataSubList->At(anaChannel); for(ch = 0; ch < DOMINO_NCELL; ch++) { grCellCalib = ((TGraphErrors *) grCellCalibList->At(ch)); grCellCalib->Fit("pol3", "Q"); TF1 *pol3fit = ((TF1 *) grCellCalib->GetFunction("pol3")); grDataSub->GetPoint(ch, x, y); chtmp = y - (Double_t)(pol3fit->Eval(y/3.25)); grDataSubCalib->SetPoint(ch, x, chtmp); } TCanvas *cGrTest = new TCanvas("grTest", "test per vedere i dati", 1000,1000); grDataSubCalib->Draw("APEL");*/ TString Title = "Charge Distribution per channel"; gStyle->SetOptFit(111); TCanvas *cdistch = new TCanvas("cdistch", Title, 1000, 1000); cdistch->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { cdistch->cd(i + 1); TH1 *dhist = (TH1 *) DistChList->At(i); dhist->DrawCopy(); dhist->SetLineWidth(1); dhist->Fit("gaus", "Q"); dhist->GetFunction("gaus")->SetLineColor(4); dhist->GetFunction("gaus")->SetLineWidth(2); } TString Title = "Charge Distribution Pedestals Subtracted per channel"; TCanvas *cdistchsub = new TCanvas("cdistchsub", Title, 1000, 1000); cdistchsub->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { cdistchsub->cd(i + 1); TH1 *dsubhist = (TH1 *) DistChSubList->At(i); dsubhist->DrawCopy(); dsubhist->SetLineWidth(1); dsubhist->Fit("gaus", "Q"); dsubhist->GetFunction("gaus")->SetLineColor(4); dsubhist->GetFunction("gaus")->SetLineWidth(2); } TString Title = "Charge Distribution Pedestals and Ch0 Subtracted per channel"; TCanvas *cdistch0sub = new TCanvas("cdistch0sub", Title, 1000, 1000); cdistch0sub->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { cdistch0sub->cd(i + 1); TH1 *dch0subhist = (TH1 *) DistCh0SubList->At(i); dch0subhist->DrawCopy(); dch0subhist->SetLineWidth(1); dch0subhist->Fit("gaus", "Q"); dch0subhist->GetFunction("gaus")->SetLineColor(4); dch0subhist->GetFunction("gaus")->SetLineWidth(2); } TCanvas *cDataSubTest = new TCanvas("cDataSubTest", "Data after pedestal subtraction", 1000, 1000); cDataSubTest->Divide(1,8); for (h = 0; h< DOMINO_NCH; h++) { grDataSub = (TGraphErrors *) grDataSubList->At(h); cDataSubTest->cd(h+1); grDataSub->GetYaxis()->SetLabelSize(0.06); grDataSub->GetXaxis()->SetLabelSize(0.06); grDataSub->Draw("APE"); } TCanvas *cDataSubTestCh5 = new TCanvas("cDataSubTestCh5", "Data after pedestal subtraction Ch5", 1200, 800); grDataSub = (TGraphErrors *) grDataSubList->At(anaChannel); grDataSub->GetYaxis()->SetLabelSize(0.06); grDataSub->GetYaxis()->SetTitle("ADC Counts"); grDataSub->GetXaxis()->SetTitle("Cell"); grDataSub->GetXaxis()->SetLabelSize(0.06); TLine *refval = new TLine(0,350,1024,350); refval->SetLineWidth(3); refval->SetLineStyle(2); refval->SetLineColor(2); TLine *i1 = new TLine(121,-50,121,800); i1->SetLineStyle(2); TLine *i2 = new TLine(291,-50,291,800); i2->SetLineStyle(2); TLine *i3 = new TLine(461,-50,461,800); i3->SetLineStyle(2); TLine *i4 = new TLine(632,-50,632,800); i4->SetLineStyle(2); TLine *i5 = new TLine(803,-50,803,800); i5->SetLineStyle(2); TLine *i6 = new TLine(975,-50,975,800); i6->SetLineStyle(2); TLine *ireal1 = new TLine(121+20,600,121+20,800); ireal1->SetLineWidth(3); ireal1->SetLineColor(4); TLine *ireal2 = new TLine(291-20,600,291-20,800); ireal2->SetLineWidth(3); ireal2->SetLineColor(4); TLine *ireal3 = new TLine(461+20,600,461+20,800); ireal3->SetLineWidth(3); ireal3->SetLineColor(4); TLine *ireal4 = new TLine(632-20,600,632-20,800); ireal4->SetLineWidth(3); ireal4->SetLineColor(4); TLine *ireal5 = new TLine(803+20,600,803+20,800); ireal5->SetLineWidth(3); ireal5->SetLineColor(4); TLine *ireal6 = new TLine(975-20,600,975-20,800); ireal6->SetLineWidth(3); ireal6->SetLineColor(4); grDataSub->Draw("APE"); refval->Draw("SAME"); i1->Draw("SAME"); i2->Draw("SAME"); i3->Draw("SAME"); i4->Draw("SAME"); i5->Draw("SAME"); i6->Draw("SAME"); ireal1->Draw("SAME"); ireal2->Draw("SAME"); ireal3->Draw("SAME"); ireal4->Draw("SAME"); ireal5->Draw("SAME"); ireal6->Draw("SAME"); TCanvas *cDataTest = new TCanvas("cDataTest", "Raw Data", 1000,1000); cDataTest->Divide(1,8); for(h = 0; h < DOMINO_NCH; h++) { cDataTest->cd(h+1); grData = (TGraphErrors *) grDataList->At(h); grData->SetMarkerStyle(20); grData->SetMarkerSize(0.5); grData->Draw("APE"); } // save root file with graph containing channel 5 data after pedestals subtraction. /* cout << "test" << endl; TString OutFile = DataSubFile; TFile *f = new TFile(OutFile,"RECREATE"); int h = anaChannel; TString key="DataSubGraph"; key += h; ((TGraphErrors*)grDataSubList->At(h))->Write(key); f->Close(); cout << " ---- Write data on file " << endl; */ // =======================================================// // =====================Matteo's Code=====================// // =======================================================// /* Int_t cht, incCht, decCht, xflag, nPeriods, iMax, iMin; Double_t xdiff, incDiff, decDiff, incDiffTemp, decDiffTemp, incXDiff, decXDiff; Double_t fitMax, fitMin, fitPeriod, chisquare; Double_t DominoXval[DOMINO_NCELL]; Double_t DominoYval[DOMINO_NCELL]; Double_t FitXval[DOMINO_NCELL]; Double_t FitYval[DOMINO_NCELL]; // opens grDataSub.root TString FileName = DataSubFile; TGraphErrors *grDataSub; int h = anaChannel; TFile *f = new TFile(FileName); TString key = "DataSubGraph"; key += h; grDataSub = (TGraphErrors *) f->Get(key); f->Close(); // Create a new graph with channel 5 data TGraphErrors *grDataSubAnaCh; int h = anaChannel; grDataSubAnaCh = (TGraphErrors *) grDataSubList->At(h); TGraphErrors *grDataSubFix = grDataSubAnaCh->Clone(); TGraphErrors *grRes = new TGraphErrors(DOMINO_NCELL); TList *grResPeriodList = new TList(); Double_t xtemp, ytemp, DominoMax, DominoMin; for (int ch = 0; ch < DOMINO_NCELL; ch++){ // get domino-output point and save in array grDataSubAnaCh->GetPoint(ch, DominoXval[ch], DominoYval[ch]); } // find the domino point with max y-value iMax = 0; for(int ch = 0; ch < DOMINO_NCELL; ch++) { if(DominoYval[ch] > DominoYval[iMax]) { DominoMax = DominoYval[ch]; iMax = ch; } } cout << "DominoMax e': " << DominoMax << endl; // find the domino point with min y-value iMin = 0; for (int ch = 0; ch < DOMINO_NCELL; ch++) { if(DominoYval[ch] < DominoYval[iMin]) { DominoMin = DominoYval[ch]; iMin = ch; } } cout << "DominoMin e': " << DominoMin << endl; // remove points from the graph that will be used for fit for (int ch = 0; ch < DOMINO_NCELL; ch++){ grDataSubFix->GetPoint(ch, xtemp, ytemp); if(ytemp > 0.8*DominoMax || ytemp < 0.2*DominoMin) grDataSubFix->RemovePoint(ch); } TF1 *fsin = new TF1("fsin", sigSin, 0., 1024., 4); fsin->SetParameters(600., DOMINO_NCELL / 4., 150., 150.); fsin->SetParNames("amplitude", "Period", "Phase", "DC-Offset"); grDataSubFix->Fit("fsin"); TF1 *fsinFit = grDataSubFix->GetFunction("fsin"); fsinFit->SetParNames("amplitude", "Period", "Phase", "DC-Offset"); chisquare = grDataSub->Chisquare(fsinFit); cout << "il chi quadro della funzione di fit e' : " << chisquare << endl; for (int ch = 0; ch < DOMINO_NCELL; ch++) { // get Fit-value and save in array FitXval[ch] = DominoXval[ch]; FitYval[ch] = fsinFit->Eval(FitXval[ch]); } fitPeriod = fsinFit->GetParameter("Period"); cout << "il periodo della funzione e': " << fitPeriod << endl; nPeriods = (Int_t) (DOMINO_NCELL/fitPeriod); cout << "il numero di periodi della funzione e': " << nPeriods << endl; fitMax = fsinFit->GetMaximum(); cout << "il massimo della funzione e': " << fitMax << endl; fitMin = fsinFit->GetMinimum(); cout << "il minimo della funzione e': " << fitMin << endl; // computes the y difference between the ch-domino point and the i-fit point // and stops when the difference changes sign // // first and last points are not included in the cicle // // if the fit point y-value is bigger or smaller than the fit function max*0.8 or min*0.2 // the point is removed for (int ch = 1; ch < DOMINO_NCELL - 1; ch++) { if(FitYval[ch] > 0.8*fitMax || FitYval[ch] < 0.2*fitMin) { grRes->RemovePoint(ch); continue; } incDiff = DominoYval[ch] - FitYval[ch]; incDiffTemp = DominoYval[ch] - FitYval[ch + 1]; decDiff = DominoYval[ch] - FitYval[ch]; decDiffTemp = DominoYval[ch] - FitYval[ch - 1]; if(abs(incDiffTemp) < abs(incDiff) || (sign(incDiff) != sign(incDiffTemp) && abs(decDiffTemp) > abs(decDiff))) { for (int i = ch; i < DOMINO_NCELL; i++, incDiff = incDiffTemp) { incDiffTemp = DominoYval[ch] - FitYval[i]; if (sign(incDiff) != sign(incDiffTemp)) { if(abs(incDiffTemp) < abs(incDiff)) incCht = i; else incCht = i - 1; break; } } xflag = 1; } else if(abs(decDiffTemp) < abs(decDiff) || (sign(decDiff) != sign(decDiffTemp) && abs(incDiffTemp) > abs(incDiff))) { for (int j = ch; j >= 0 ; j--, decDiff = decDiffTemp) { decDiffTemp = DominoYval[ch] - FitYval[j]; if (sign(decDiff) != sign(decDiffTemp)) { if(abs(decDiffTemp) < abs(decDiff)) decCht = j; else decCht = j + 1; break; } } xflag = -1; } if(xflag == 1) xdiff = FitXval[incCht] - DominoXval[ch]; else xdiff = FitXval[decCht] - DominoXval[ch]; grRes->SetPoint(ch, (Double_t) ch, xdiff); } cout << "Draw Time Residuals" << endl; TString Title = "Time Residuals"; TCanvas *timeres = new TCanvas("timeres", Title, 1200, 780); grRes->SetMarkerStyle(20); grRes->SetMarkerSize(0.3); grRes->GetYaxis()->SetLabelSize(0.12); grRes->GetXaxis()->SetLabelSize(0.12); grRes->Draw("APE"); // The previous graph is now split in N graphs, where N is the number of fit periods // this will be needed to set the function phase // // iMax = 0; // // for(ch = 0; ch < fitPeriod - 1; ch++) { // if(FitYval[ch] > FitYval[iMax]) iMax = ch; // } cout << "il primo massimo ha l'indice : " << iMax << endl; for (i = 0; i < nPeriods; i++) { TGraphErrors *grResPeriod = new TGraphErrors((Int_t) fitPeriod); grResPeriodList->Add(grResPeriod); for(ch = i*fitPeriod + 1; ch < fitPeriod + (i*fitPeriod); ch++) { if(FitYval[ch] > 0.8*fitMax || FitYval[ch] < 0.2*fitMin) { grResPeriod->RemovePoint(ch); continue; } incDiff = DominoYval[ch] - FitYval[ch]; incDiffTemp = DominoYval[ch] - FitYval[ch + 1]; decDiff = DominoYval[ch] - FitYval[ch]; decDiffTemp = DominoYval[ch] - FitYval[ch - 1]; if(abs(incDiffTemp) < abs(incDiff) || (sign(incDiff) != sign(incDiffTemp) && abs(decDiffTemp) > abs(decDiff))) { for (int k = ch; k < k*fitPeriod + fitPeriod; k++, incDiff = incDiffTemp) { incDiffTemp = DominoYval[ch] - FitYval[k]; if (sign(incDiff) != sign(incDiffTemp)) { if(abs(incDiffTemp) < abs(incDiff)) incCht = k; else incCht = k - 1; break; } } xflag = 1; } else if(abs(decDiffTemp) < abs(decDiff) || (sign(decDiff) != sign(decDiffTemp) && abs(incDiffTemp) > abs(incDiff))) { for (int j = ch; j > i*fitPeriod; j--, decDiff = decDiffTemp) { decDiffTemp = DominoYval[ch] - FitYval[j]; if (sign(decDiff) != sign(decDiffTemp)) { if(abs(decDiffTemp) < abs(decDiff)) decCht = j; else decCht = j + 1; break; } } xflag = -1; } if(xflag == 1) xdiff = FitXval[incCht] - DominoXval[ch]; else xdiff = FitXval[decCht] - DominoXval[ch]; grResPeriod->SetPoint(ch - i*fitPeriod, (Double_t) (ch - i*fitPeriod), xdiff); } } TCanvas *timeresperiod = new TCanvas("timeresperiod", "Time Residuals Period", 1200, 780); for(i = 0; i < nPeriods; i++) { grResPeriod = ((TGraphErrors *) grResPeriodList->At(i)); grResPeriod->SetMarkerStyle(20); grResPeriod->SetMarkerSize(0.3); grResPeriod->GetYaxis()->SetLabelSize(0.12); grResPeriod->GetXaxis()->SetLabelSize(0.12); grResPeriod->Draw("APEsame"); } cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Average Charge - Pedestal subtracted"; TCanvas *csubdata = new TCanvas("csubdata", Title, 1200, 780); grDataSubAnaCh->SetMarkerStyle(20); grDataSubAnaCh->SetMarkerSize(0.3); grDataSubAnaCh->GetYaxis()->SetLabelSize(0.12); grDataSubAnaCh->GetXaxis()->SetLabelSize(0.12); grDataSubAnaCh->Draw("APE"); fsinFit->Draw("same"); */ // draw extra graphs if (DrawExtraGraphs == 1) { cout << " ----- DRAW Results ------" << endl; //================ DRAW Results ================== TCanvas *c = new TCanvas("ctmp", "test", 800, 800); c->Divide(3, 3); for (int pad = 1; pad < 10; pad++) { c->cd(pad); ((TH1 *) hCellList->At(pad * 512 + 219))->DrawCopy(); hCellSub = (TH1F *) hCellSubList->At(pad * 512 + 219); hCellSub->SetLineColor(2); hCellSub->DrawCopy("same"); } cout << "Draw RMS distributions" << endl; TString Title = "RMS distributions per channel"; TCanvas *c4 = new TCanvas("c4", Title, 700, 700); c4->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { c4->cd(i + 2); hRMSdist = (TH1F *) hRMSList->At(i); hRMSFitdist = (TH1F *) hRMSFitList->At(i); hRMSFitdist->SetLineColor(2); hRMSFitdist->DrawCopy(); hRMSdist->DrawCopy("same"); } TList *grDataCh0SubList = new TList(); TGraphErrors *grDataCh0Sub; for(h = 0; h< DOMINO_NCELL; h++) { grDataCh0Sub = new TGraphErrors(DOMINO_NCELL); grDataCh0SubList->Add(grDataCh0Sub); } TGraphErrors *grDataSubCh0 = (TGraphErrors *) grDataSubList->At(6); for(h = 0; h < DOMINO_NCH; h++) { grDataSub = (TGraphErrors *) grDataSubList->At(h); grDataCh0Sub = (TGraphErrors *) grDataCh0SubList->At(h); for(ch = 0; ch < DOMINO_NCELL; ch++) { grDataSubCh0->GetPoint(ch, x1, y1); grDataSub->GetPoint(ch, x2, y2); grDataCh0Sub->SetPoint(ch, x1 , y2 - y1); } } TCanvas *cDataCH0Sub = new TCanvas("cDataCH0Sub","cDataCH0Sub", 1000,1000); cDataCH0Sub->Divide(1,8); for(h = 0; h < DOMINO_NCH; h++) { cDataCH0Sub->cd(h+1); grDataCh0Sub = (TGraphErrors *) grDataCh0SubList->At(h); grDataCh0Sub->GetYaxis()->SetLabelSize(0.12); grDataCh0Sub->GetXaxis()->SetLabelSize(0.12); grDataCh0Sub->Draw("APEL"); } cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Average Charge - Pedestal subtracted"; TCanvas *csubdata = new TCanvas("csubdata", Title, 1000, 1000); csubdata->Divide(3,3); for(h = 0; h < DOMINO_NCH; h++) { csubdata->cd(h+1); TString title = "DataSub channel "; title += h; TH1F *hCellDataSub = new TH1F(title, title, 100, -20, 20); grDataSub = (TGraphErrors *) grDataSubList->At(h); for(ch = 0; ch < DOMINO_NCELL; ch++) { grDataSub->GetPoint(ch, x, y); hCellDataSub->Fill(y); } hCellDataSub->Fit("gaus", "Q"); hCellDataSub->GetXaxis()->SetTitle("ADC Counts"); hCellDataSub->GetFunction("gaus")->SetLineColor(4); hCellDataSub->DrawCopy(); } cout << "breakpoint" << endl; TCanvas *csubdata2 = new TCanvas("csubdata2", "DataSub for every channel", 1000, 1000); TString title = "DataSub every channel "; TH1F *hCellChDataSubTot = new TH1F(title, title, 100, -20, 20); for(h = 0; h < DOMINO_NCH; h++) { grDataSub = (TGraphErrors *) grDataSubList->At(h); for(ch = 0; ch < DOMINO_NCELL; ch++) { grDataSub->GetPoint(ch, x, y); hCellChDataSubTot->Fill(y); } hCellChDataSubTot->Fit("gaus", "Q"); hCellChDataSubTot->GetXaxis()->SetTitle("ADC Counts"); hCellChDataSubTot->GetFunction("gaus")->SetLineColor(4); hCellChDataSubTot->Draw(); } cout << "Draw Pedestals" << endl; TString Title = "Pedestals"; TCanvas *c2 = new TCanvas("c2", Title, 1050, 780); c2->SetBorderMode(0); c2->SetBorderSize(0.); c2->Divide(1, 8); // gStyle->SetCanvasBorderMode(0.); // gStyle->SetCanvasBorderSize(0.); Double_t x, y; for (int h = 0; h < DOMINO_NCH; h++) { c2->cd(h + 1); grPed = ((TGraphErrors *) grPedList->At(h)); grPed->SetMarkerStyle(20); grPed->SetMarkerSize(0.5); grPed->GetYaxis()->SetLabelSize(0.12); grPed->GetXaxis()->SetLabelSize(0.12); // cout << " err:" << grPed->GetErrorY(102) << " " ; // cout << x << "--" << y << endl; grPed->Draw("APE"); } cout << "Draw Data - Average charge" << endl; TString Title = "Average_Charge"; TCanvas *cdata = new TCanvas("cdata", Title, 1050, 780); cdata->Divide(1, 8); Double_t x, y; for (int h = 0; h < DOMINO_NCH; h++) { cdata->cd(h + 1); grData = ((TGraphErrors *) grDataList->At(h)); grData->SetMarkerStyle(20); grData->SetMarkerSize(0.3); grData->GetYaxis()->SetLabelSize(0.12); grData->GetXaxis()->SetLabelSize(0.12); grData->GetPoint(10, x, y); // cout << x << "-" << y << endl; grData->Draw("APE"); } cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Average Charge - Pedestal subtracted"; TCanvas *csubdata = new TCanvas("csubdata", Title, 1200, 780); csubdata->Divide(1, 8); TF1 *fsin = new TF1("fsin", sigSin, 0., 1024., 4); TH1D *resDist = new TH1D("resDist", "Residuals Signal", 100, -100., 100.); cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Residuals"; TCanvas *residuals = new TCanvas("residuals", Title, 1200, 780); resDist->DrawCopy(); } fclose(fdata); hCellList->Delete(); hCellSubList->Delete(); hRMSList->Delete(); hRMSFitList->Delete(); }
int main(int argc, char *argv[]){ // int argcb; // char **argvb; TApplication *app = new TApplication("app", &argc, argv); TH1::AddDirectory(kFALSE);//avoid name overwrites but could cause other memory histogram issues // h->SetDirectory(0); for the current histogram h double worldsize=80; exp_core experiment(worldsize); // // Set the option you wish to run // int control =0; // 0 = EVERYTHING // 1 = geometry // 2 = Rutherford // 3 = Decay position // 4 = Distribution hits // 5 = Draw events for real time viewing bool save_text=true;//saves terminal output but no terminal output until completion // // Set the target // double density_targ=1.55; double density_back=19.32; target tharget(20,40,1000,180.0,0,10000,79,197); experiment.set_targ(tharget); // // Set the beam // double ebeam=120; //MeV experiment.set_beam(18,36,ebeam); // // Input your physics // double excited_Z=34; double excited_A=70; double initial_state_MeV = 1.4; double transition_keV = 200; bool excited_beam_like=false; double halflife=0.003;//in ns string dist="";// leave blank for a uniform distribution // // Setup Detectors // int config=0; // 0 normal, 1 stopper, 2 old int S3=1; // 0 off, 1 S3 simple, 2 S3 rings , 3 pin double overr=0; // mm >0 non-default S3 / pin position //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////// END OF USER INPUT //////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double t_d=0.2,t_u=0.35*pi; ///////// First we sort output files //////// // Create the names stringstream ss; ss<<"outputs/SPICE_"<<experiment.channelnames(experiment.get_BZ(),experiment.get_BA()); ss<<"_"<<experiment.channelnames(experiment.get_TZ(),experiment.get_TA()); if(tharget.backing_thickness>0) ss<<"_"<<experiment.channelnames(tharget.backing_Z,tharget.backing_A)<<"_backed"; ss<<"_"<<ebeam<<"MeV"; string file_title=ss.str(); // Check if the root file exists already bool exist=false; TFile* outfile= new TFile((file_title+".root").c_str(),"READ"); if(outfile->IsOpen()){exist=true;outfile->Close();delete outfile;} // Open the file root file to right, whether or not it exists outfile= new TFile((file_title+".root").c_str(),"UPDATE");//Open an existing file for writing. If no file exists, it is created. gROOT->cd();// // This code is for capturing the terminal output std::streambuf *psbuf, *backup; std::ofstream filestr; if(save_text){ // Append if the root file is being if(exist){filestr.open(file_title+".txt",std::ofstream::app);filestr<<endl<<"/////// APPEND //////"<<endl;} //appended else filestr.open(file_title+".txt"); backup = std::cout.rdbuf(); // back up cout's streambuf psbuf = filestr.rdbuf(); // get file's streambuf std::cout.rdbuf(psbuf); // assign streambuf to cout } // Create the canvas that is used as an inbetween for the whole program TCanvas * can_view = new TCanvas("can_view", "can_view", 1200, 600); gStyle->SetOptStat(0); can_view->cd(); ///////////////////////////////////////////////////// ////////////////// Draw Geometry //////////////////// ///////////////////////////////////////////////////// // This loop outputs graphics of the chosen detector geography if(control==0||control==1){spice_auto_setup(experiment,config,S3,overr); if(!outfile->GetDirectory("Geometry"))outfile->mkdir("Geometry"); gROOT->cd(); can_view->cd();can_view->Clear(); experiment.draw_exp(); outfile->cd("Geometry"); can_view->SetName("3Dview");can_view->Write("3Dview",TObject::kOverwrite); gROOT->cd(); can_view->cd();can_view->Clear(); experiment.draw_exp(2); outfile->cd("Geometry"); can_view->SetName("side_view");can_view->Write("side_view",TObject::kOverwrite); gROOT->cd(); can_view->cd();can_view->Clear(); experiment.draw_exp(3); outfile->cd("Geometry"); can_view->SetName("beam_view");can_view->Write("beam_view",TObject::kOverwrite); gROOT->cd(); can_view->cd();can_view->Clear(); experiment.draw_phi(); outfile->cd("Geometry"); can_view->SetName("theta_view");can_view->Write("theta_view",TObject::kOverwrite); gROOT->cd(); } ///////////////////////////////////////////////////// //////// Calculate Rutherford and Kinematics //////// ///////////////////////////////////////////////////// // This loop calculates the basic beam target kinematics and Rutherford scattering rates if(control==0||control==2){spice_auto_setup(experiment,config,S3,overr); //experiment.set_rutherford();//sets reaction experiment.set_elastic(); can_view->Clear(); can_view->Divide(2); can_view->cd(1); experiment.set_ruthmask(t_d,t_u,true,false);// Cut down on wasted simulations by only focusing on the region of interest experiment.draw_hit_pattern_2D(1,1000000,1,1,0); ((TH2D*)gPad->GetPrimitive("Hit_Map_copy"))->SetTitle("Target"); can_view->cd(2); experiment.set_ruthmask(t_d,t_u,false,true); experiment.draw_hit_pattern_2D(1,1000000,1,0,1); ((TH2D*)gPad->GetPrimitive("Hit_Map_copy"))->SetTitle("Beam"); outfile->cd(); can_view->SetName("Hit_map_rutherford");can_view->Write("Hit_map_rutherford",TObject::kOverwrite); gROOT->cd(); can_view->Clear();can_view->cd(); experiment.draw_primary_kinematics(); outfile->cd(); can_view->SetName("Kinematics");can_view->Write("Kinematics",TObject::kOverwrite); gROOT->cd(); experiment.auto_rutherford_OTT(100000,true); if(S3==2){spice_auto_setup(experiment,config,1,overr);experiment.auto_rutherford_OTT(100000,true);} } ///////////////////////////////////////////////////// ////// Experimental Interaction and Detection /////// ///////////////////////////////////////////////////// // This loop calculates data for the reaction of interest // if(control==0||control==3||control==4||control==5){ if(excited_Z<0||excited_A<0){ if(excited_beam_like){ experiment.set_reco(experiment.get_BZ(),experiment.get_BA()); }else{ experiment.set_elastic(); } }else{ experiment.set_reco(excited_Z,excited_A); } // Now we set the target interaction and decay information experiment.set_target_interaction(2);//E^2 is a reasonably approximation for most of our stuff experiment.set_E_star(initial_state_MeV); experiment.set_ICE(transition_keV); // experiment.density_targ=density_targ;// experiment.density_back=density_back; if(halflife>0) experiment.set_halflife_ns(halflife,density_targ,density_back); // Can set the densities directly as well //set some distribution if(dist.size()>0){ experiment.set_primary_dist(dist); }else{ //experiment.set_uniform(t_d,t_u); TFormula fot("fot","sin(x)"); experiment.set_primary_dist(&fot);//using this one so we can use the same masking for both } if(excited_beam_like)experiment.reverse_primary_dist();//because distribution defined for beam like by default but RECOIL is excited experiment.set_implant_escape(-1); //SET THIS so things dont escape when they go wack into things int z=2;// Detector number of the first heavy ion detector if(S3==2)z++;// If S3, skip the PCB. PCBs left out for the diodes in spice_auto_setup ////////////////////////////// ////// FINISHED SET UP /////// ////////////////////////////// experiment.print_reaction(); experiment.print_target(); experiment.print_decay(); // experiment.print_detectables(); outfile->cd(); experiment.dist_target_KE_beam.Write("KE_though_target",TObject::kOverwrite); gROOT->cd(); if(control==0||control==3){spice_auto_setup(experiment,config,S3,overr); experiment.basic_decay_check(100000); // Draw the target and decay things // quite important to check things are set and working right can_view->Clear();can_view->Divide(2); can_view->cd(1); experiment.draw_decay_Z(0,true,10); can_view->cd(2); experiment.draw_target_interaction(0,true); outfile->cd(); can_view->SetName("Ungated_Decay_Position");can_view->Write("Ungated_Decay_Position",TObject::kOverwrite); gROOT->cd(); for(int i=z;i<experiment.detN();i++){ //set only the daughter recoil as valid in the S3 or pins experiment.set_valid_part(i,0,0,1,0); } string n=experiment.channelnames(experiment.get_D1Z(),experiment.get_D1A())+"_Gated_Decay_Position"; experiment.mask_manual(t_d,t_u,true,false);//saves on wasted computation can_view->Clear();can_view->Divide(2); can_view->cd(1); experiment.draw_decay_Z(1,true,10); can_view->cd(2); experiment.draw_target_interaction(1,true); outfile->cd(); can_view->SetName(n.c_str());can_view->Write(n.c_str(),TObject::kOverwrite); gROOT->cd(); for(int i=z;i<experiment.detN();i++){ //set only the ejectile as valid in the S3 or pins experiment.set_valid_part(i,0,1,0,0); } string N=experiment.channelnames(experiment.get_EZ(),experiment.get_EA())+"_Gated_Decay_Position"; experiment.mask_manual(t_d,t_u,false,true);//saves on wasted computation can_view->Clear();can_view->Divide(2); can_view->cd(1); experiment.draw_decay_Z(1,true,10); can_view->cd(2); experiment.draw_target_interaction(1,true); outfile->cd(); can_view->SetName(N.c_str());can_view->Write(N.c_str(),TObject::kOverwrite); gROOT->cd(); } // Distribution hit loops if(control==0||control==4){spice_auto_setup(experiment,config,S3,overr); can_view->Clear(); can_view->cd(); experiment.mask_manual(t_d,t_u,true,true); double ra=experiment.manual_primary_dist_hist.Integral();//Ask what fraction we have masked too, as unmask integral = 1 // Print a basic output of fractions of hits cout<<endl<<endl<<"Multiply by fraction "<<ra; experiment.basic_hit_count(100000,true,1,1,0,0); string r=experiment.channelnames(experiment.get_RZ(),experiment.get_RA()); string e=experiment.channelnames(experiment.get_EZ(),experiment.get_EA()); experiment.manual_primary_dist_hist.SetLineWidth(2); TH1D full; // Get theta CM for different hit conditions // Fetch the manual CM distribution histogram and the speed masked one // We want to show the mask so we know we havent cut it too small can_view->Clear(); can_view->Divide(2); can_view->cd(1); experiment.mask_manual(t_d,t_u,true,false);//saves on wasted computation full=experiment.manual_primary_dist_store; ra=experiment.manual_primary_dist_hist.Integral();//Ask what fraction we have masked too, as unmask integral = 1 full.SetTitle(("CM_theta_dist_"+r+"_gated").c_str()); //Get theta CM for different hit condition TH1D recoh=experiment.theta_hist(500000,true,1,0,0,0); recoh.SetLineColor(2); recoh.Scale(ra*(full.GetBinWidth(1)/recoh.GetBinWidth(1)));//Some basic scaling to match distribution histogram full.DrawCopy(); experiment.manual_primary_dist_hist.DrawCopy("same"); recoh.DrawCopy("same"); can_view->cd(2); experiment.mask_manual(t_d,t_u,false,true);//saves on wasted computation full=experiment.manual_primary_dist_store; ra=experiment.manual_primary_dist_hist.Integral(); full.SetTitle(("CM_theta_dist_"+e+"_gated").c_str()); TH1D ejech=experiment.theta_hist(500000,true,0,1,0,0); ejech.SetLineColor(2); ejech.Scale(ra*(full.GetBinWidth(1)/ejech.GetBinWidth(1))); full.DrawCopy(); experiment.manual_primary_dist_hist.DrawCopy("same"); ejech.DrawCopy("same"); outfile->cd(); can_view->SetName("CM_angles");can_view->Write("CM_angles",TObject::kOverwrite); gROOT->cd(); can_view->Clear(); can_view->Divide(2); can_view->cd(1); experiment.mask_manual(t_d,t_u,true,false);//saves on wasted computation experiment.draw_hit_pattern_2D(1,500000,1,1,0); ((TH2D*)gPad->GetPrimitive("Hit_Map_copy"))->SetTitle(r.c_str()); can_view->cd(2); experiment.mask_manual(t_d,t_u,false,true);//saves on wasted computation experiment.draw_hit_pattern_2D(1,500000,1,0,1); ((TH2D*)gPad->GetPrimitive("Hit_Map_copy"))->SetTitle(e.c_str()); outfile->cd(); can_view->SetName("Hit_map_ditribution");can_view->Write("Hit_map_ditribution",TObject::kOverwrite); gROOT->cd(); can_view->Clear(); can_view->cd(); experiment.mask_manual(t_d,t_u,true,true);//saves on wasted computation experiment.auto_E_theta(500000,1,1,1); outfile->cd(); can_view->SetName("Theta_E");can_view->Write("Theta_E",TObject::kOverwrite); gROOT->cd(); } if(control==5){spice_auto_setup(experiment,config,S3,overr); can_view->Clear(); can_view->cd(); experiment.draw_hits_3D(2); } } // // // Next we spend 20 seconds drawing events so that if something is very wrong it can be corrected // // We set multiplicity=1 so it will only show us S3 good events // experiment.draw_hits_3D(2,1,true,0.5,1,true,20); // //draw_hits_3D(projection,hit_multiplicity,obstructions,display_time,refresh_rate,draw_misses,run_time) // // // if(save_text){ std::cout.rdbuf(backup); // restore cout's original streambuf filestr.close(); string x; ifstream inFile(file_title+".txt"); while (getline(inFile,x)){ cout << x << endl ; } inFile.close(); outfile->cd(); TMacro mac((file_title+".txt").c_str()); mac.Write("terminal.txt",TObject::kOverwrite); } outfile->Close(); cout<<endl<<"/////////////////////////////////////////////////////////////////////////"<<endl; app->Run(); return 0; }
void drawSys_merged() { // TH1::SetDefaultSumw2(); gStyle -> SetOptStat(0); const int kPPcentral = 1; const int kPPperipheral =2 ; const int kHIcentral = 3; const int kHIperipheral = 4; const int kPADATA = 5; const int kPAMC = 6; TH1D* dNdJetPt[7][5]; // [collision] [ ptbin] [Before/After variation] TH1D* dNdJetPtSys[7][5]; // [collision] [ ptbin] [Before/After variation] TH1D* dNdJetPtSysIaa[7][5]; // [collision] [ ptbin] [Before/After variation] TH1D* meanJetPt[7]; // [collision] [Before/After variation] TH1D* meanJetPtSys[7]; // [collision] [Before/After variation] TH1D* meanRjg[7]; TH1D* meanRjgSys[7]; TH1D* bmeanJetPt[7]; // [collision] [Before/After variation] TH1D* bmeanJetPtSys[7]; // [collision] [Before/After variation] TH1D* bmeanRjg[7]; TH1D* bmeanRjgSys[7]; TFile * f = new TFile("../resultHistograms_ppSmeared10030.root"); bmeanJetPt[1] =(TH1D*)f->Get(Form("meanJetPt_pp")); bmeanRjg[1] =(TH1D*)f->Get(Form("meanRjg_pp")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPt[1][ipt] = (TH1D*)f->Get(Form("dNdJetPt_pp_ptBin%d", ipt )); } f = new TFile("../resultHistograms_ppSmeared13099.root"); bmeanJetPt[2] =(TH1D*)f->Get(Form("meanJetPt_pp")); bmeanRjg[2] =(TH1D*)f->Get(Form("meanRjg_pp")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPt[2][ipt] = (TH1D*)f->Get(Form("dNdJetPt_pp_ptBin%d", ipt )); } // pbpb f = new TFile("../resultHistograms_jetResCorrection.root"); bmeanJetPt[3] =(TH1D*)f->Get(Form("meanJetPt_pbpb_centralityBin1")); bmeanRjg[3] =(TH1D*)f->Get(Form("meanRjg_pbpb_centralityBin1")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPt[3][ipt] = (TH1D*)f->Get(Form("dNdJetPt_pbpb_centralityBin1_ptBin%d", ipt )); } bmeanJetPt[4] =(TH1D*)f->Get(Form("meanJetPt_pbpb_centralityBin2")); bmeanRjg[4] =(TH1D*)f->Get(Form("meanRjg_pbpb_centralityBin2")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPt[4][ipt] = (TH1D*)f->Get(Form("dNdJetPt_pbpb_centralityBin2_ptBin%d", ipt )); } // pPb f = new TFile("../resultHistograms_jetResCorrection.root"); bmeanJetPt[5] =(TH1D*)f->Get(Form("meanJetPt_ppb")); bmeanRjg[5] =(TH1D*)f->Get(Form("meanRjg_ppb")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPt[5][ipt] = (TH1D*)f->Get(Form("dNdJetPt_ppb_ptBin%d", ipt )); } f = new TFile("../resultHistograms_MC_recoIsoPhoton.root"); bmeanJetPt[6] =(TH1D*)f->Get(Form("meanJetPt_ppb")); bmeanRjg[6] =(TH1D*)f->Get(Form("meanRjg_ppb")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPt[6][ipt] = (TH1D*)f->Get(Form("dNdJetPt_ppb_ptBin%d", ipt )); } TFile* fSys = new TFile("../merged/relativeSys_merged.root"); bmeanJetPtSys[1] =(TH1D*)fSys->Get("meanJetPt_pp_uncertainty_merged"); bmeanRjgSys[1] =(TH1D*)fSys->Get(Form("meanRjg_pp_uncertainty_merged")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPtSysIaa[1][ipt] = (TH1D*)fSys->Get(Form("dNdJetPt_IaaBin_pp_ptBin%d_uncertainty_merged", ipt )); } bmeanJetPtSys[2] = (TH1D*)bmeanJetPtSys[1]->Clone(Form("%s_2",bmeanJetPtSys[1]->GetName())); bmeanRjgSys[2] = (TH1D*)bmeanRjgSys[1]->Clone(Form("%s_2",bmeanRjgSys[1]->GetName())); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPtSysIaa[2][ipt] = (TH1D*)dNdJetPtSysIaa[1][ipt]->Clone(Form("%s_2",dNdJetPtSysIaa[1][ipt]->GetName())); } bmeanJetPtSys[3] =(TH1D*)fSys->Get("meanJetPt_pbpb_centralityBin1_uncertainty_merged"); bmeanRjgSys[3] =(TH1D*)fSys->Get(Form("meanRjg_pbpb_centralityBin1_uncertainty_merged")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPtSysIaa[3][ipt] = (TH1D*)fSys->Get(Form("dNdJetPt_IaaBin_pbpb_centralityBin1_ptBin%d_uncertainty_merged", ipt )); } bmeanJetPtSys[4] =(TH1D*)fSys->Get("meanJetPt_pbpb_centralityBin2_uncertainty_merged"); bmeanRjgSys[4] =(TH1D*)fSys->Get(Form("meanRjg_pbpb_centralityBin2_uncertainty_merged")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPtSysIaa[4][ipt] = (TH1D*)fSys->Get(Form("dNdJetPt_IaaBin_pbpb_centralityBin2_ptBin%d_uncertainty_merged", ipt )); } bmeanJetPtSys[5] =(TH1D*)fSys->Get("meanJetPt_ppb_uncertainty_merged"); bmeanRjgSys[5] =(TH1D*)fSys->Get(Form("meanRjg_ppb_uncertainty_merged")); for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPtSysIaa[5][ipt] = (TH1D*)fSys->Get(Form("dNdJetPt_IaaBin_ppb_ptBin%d_uncertainty_merged", ipt )); } // transplant the uncertainty for ( int coll = 1 ; coll<=5 ; coll++) { for ( int ipt = 1 ; ipt <=nPtBin ; ipt++) { dNdJetPtSys[coll][ipt] = (TH1D*) dNdJetPt[coll][ipt]->Clone(Form("dNdJetPtSys_coll%d_ipt%d",coll,ipt)); dNdJetPtSys[coll][ipt]->Reset(); for ( int ibin = 1 ; ibin<= dNdJetPtSys[coll][ipt]->GetNbinsX() ; ibin++) { float xx = dNdJetPtSys[coll][ipt]->GetBinCenter(ibin); float yy = dNdJetPtSysIaa[coll][ipt]->GetBinContent ( dNdJetPtSysIaa[coll][ipt]->FindBin(xx) ); if ( yy>1 ) yy = 1; dNdJetPtSys[coll][ipt]->SetBinContent(ibin,yy); } } } for(int icoll=1; icoll<=6; icoll++){ meanJetPt[icoll] = new TH1D(Form("%s_corrected", bmeanJetPt[icoll]->GetName()), "", nPtBin, ptBinPaDraw); meanRjg[icoll] = new TH1D(Form("%s_corrected", bmeanRjg[icoll]->GetName()), "", nPtBin, ptBinPaDraw); if(icoll<6){ meanJetPtSys[icoll] = new TH1D(Form("%s_corrected", bmeanJetPtSys[icoll]->GetName()), "", nPtBin, ptBinPaDraw); meanRjgSys[icoll] = new TH1D(Form("%s_corrected", bmeanRjgSys[icoll]->GetName()), "", nPtBin, ptBinPaDraw); } } for(int icoll=1; icoll<=6; icoll++){ meanPtHist(bmeanJetPt[icoll], meanJetPt[icoll]); meanPtHist(bmeanRjg[icoll], meanRjg[icoll]); if(icoll<6){ meanPtHist(bmeanJetPtSys[icoll],meanJetPtSys[icoll]) ; meanPtHist(bmeanRjgSys[icoll], meanRjgSys[icoll]); } } // RJG!! TCanvas* c2 = new TCanvas("c1","",1000,500); c2->Divide(2,1); c2->cd(2); handsomeTH1(meanRjg[1],1); // drawSys(TH1 *h,TH1 *sys, Int_t theColor= kYellow, Int_t fillStyle = -1, Int_t lineStyle = -1) TH1D* tempR = new TH1D("tempR",";p_{T}^{#gamma};R_{j#gamma}",100,40,130); tempR->Reset(); handsomeTH1(tempR,0); tempR->SetAxisRange(0,1.2,"Y"); tempR->Draw(); drawSys(meanRjg[1], meanRjgSys[1], kGreen); drawSys(meanRjg[3], meanRjgSys[3]); meanRjg[1]->Draw("same"); handsomeTH1(meanRjg[3],2 ); // meanRjg[3]->SetMarkerStyle(24); meanRjg[3]->Draw("same"); if ( 1==1 ){ TLegend *ly = new TLegend(0.4937249,0.262193,0.8493139,0.4740574,NULL,"brNDC"); easyLeg(ly,"2.76TeV"); ly->AddEntry(meanRjg[3],"PbPb 0-30%","p"); ly->AddEntry(meanRjg[1],"pp (smeared)","p"); ly->Draw(); } c2->cd(1); tempR->Draw(); handsomeTH1(meanRjg[2],1 ); drawSys(meanRjg[2], meanRjgSys[2], kGreen); drawSys(meanRjg[4], meanRjgSys[4]); meanRjg[2]->Draw("same"); handsomeTH1(meanRjg[4],2 ); meanRjg[4]->SetMarkerStyle(24); meanRjg[4]->Draw("same"); if ( 1==1 ){ TLegend *ly = new TLegend(0.4937249,0.262193,0.8493139,0.4740574,NULL,"brNDC"); easyLeg(ly,"2.76TeV"); ly->AddEntry(meanRjg[4],"PbPb 30-100%","p"); ly->AddEntry(meanRjg[2],"pp (smeared)","p"); ly->Draw(); } c2->SaveAs("pT_depedence_rjg_pp_pbpb.pdf"); TCanvas* c2pa = new TCanvas("c1pa","",500,500); handsomeTH1(meanRjg[1],1); // drawSys(TH1 *h,TH1 *sys, Int_t theColor= kYellow, Int_t fillStyle = -1, Int_t lineStyle = -1) // tempR->Draw(); TH1D* tempJ = new TH1D("tempJ",";p_{T}^{#gamma}; <p_{T}^{Jet}>",100,40,130); tempJ->Reset(); handsomeTH1(tempJ,0); tempJ->SetAxisRange(0,100,"Y"); tempJ->Draw(); drawSys(meanJetPt[5], meanJetPtSys[5], kYellow); handsomeTH1(meanJetPt[5],2); handsomeTH1(meanJetPt[6],1); meanJetPt[5]->Draw("same"); meanJetPt[6]->Draw("same"); if ( 1==1 ) { TLegend *ly = new TLegend(0.4484643,0.3088445,0.9140673,0.50102941,NULL,"brNDC"); easyLeg(ly,"5.02TeV pPb"); ly->AddEntry(meanJetPt[5],"DATA","p"); ly->AddEntry(meanJetPt[6],"PYTHIA+HIJING","p"); ly->Draw(); } c2pa->SaveAs("pT_dependence_rjg_pA_figure1.pdf"); TCanvas* c3pa = new TCanvas("c3pa","",500,500); tempR->Draw(); drawSys(meanRjg[5], meanRjgSys[5], kYellow); handsomeTH1(meanRjg[5],2); handsomeTH1(meanRjg[6],1); meanRjg[5]->Draw("same"); meanRjg[6]->Draw("same"); if ( 1==1 ) { TLegend *ly = new TLegend(0.4484643,0.3088445,0.9140673,0.50102941,NULL,"brNDC"); easyLeg(ly,"5.02TeV pPb"); ly->AddEntry(meanRjg[5],"DATA","p"); ly->AddEntry(meanRjg[6],"PYTHIA+HIJING","p"); ly->Draw(); } c3pa->SaveAs("pT_dependence_jetPt_pA_figure2.pdf"); TCanvas* c3 = new TCanvas("c3","",1000,500); c3->Divide(2,1); c3->cd(2); handsomeTH1(meanJetPt[1],1); // drawSys(TH1 *h,TH1 *sys, Int_t theColor= kYellow, Int_t fillStyle = -1, Int_t lineStyle = -1) tempJ->Draw(); drawSys(meanJetPt[1], meanJetPtSys[1], kGreen); drawSys(meanJetPt[3], meanJetPtSys[3]); meanJetPt[1]->Draw("same"); handsomeTH1(meanJetPt[3],2 ); meanJetPt[3]->Draw("same"); if ( 1==1 ){ TLegend *ly = new TLegend(0.4937249,0.262193,0.8493139,0.4740574,NULL,"brNDC"); easyLeg(ly,"2.76TeV"); ly->AddEntry(meanJetPt[3],"PbPb 0-30%","p"); ly->AddEntry(meanJetPt[1],"pp (smeared)","p"); ly->Draw(); } c3->cd(1); tempJ->Draw(); handsomeTH1(meanJetPt[2],1 ); // meanJetPt[2]->Draw(); drawSys(meanJetPt[2], meanJetPtSys[2], kGreen); drawSys(meanJetPt[4], meanJetPtSys[4]); meanJetPt[2]->Draw("same"); handsomeTH1(meanJetPt[4],2 ); meanJetPt[4]->SetMarkerStyle(24); meanJetPt[4]->Draw("same"); if ( 1==1 ){ TLegend *ly = new TLegend(0.4937249,0.262193,0.8493139,0.4740574,NULL,"brNDC"); easyLeg(ly,"2.76TeV"); ly->AddEntry(meanJetPt[4],"PbPb 30-100%","p"); ly->AddEntry(meanJetPt[2],"pp (smeared)","p"); ly->Draw(); } c3->SaveAs("pT_dependence_jetPt_pp_pbpb.pdf"); TH1D* hTempPt = new TH1D("hTemp",";p_{T}^{#gamma} (GeV);",200,10,300); TCanvas* c5 = new TCanvas("c5","",1200,700); makeMultiPanelCanvas(c5,nPtBin,2,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c5->cd(ipt+nPtBin); // draw pp hTempPt->SetXTitle("p_{T}^{Jet} (GeV)"); hTempPt->SetYTitle("#frac{dN}{dp_{T}} #frac{1}{N}"); hTempPt->SetAxisRange(10,150,"X"); // hTempPt->SetAxisRange(0,0.025,"Y"); hTempPt->SetAxisRange(0,0.07,"Y"); handsomeTH1(hTempPt,0); hTempPt->DrawCopy(); drawSys(dNdJetPt[1][ipt], dNdJetPtSys[1][ipt], kGreen); drawSys(dNdJetPt[3][ipt], dNdJetPtSys[3][ipt], kYellow); handsomeTH1(dNdJetPt[3][ipt],2); dNdJetPt[1][ipt]->Draw("same"); dNdJetPt[3][ipt]->Draw("same"); if ( ipt == 1 ) { TLegend *ly = new TLegend(0.4484643,0.6988445,0.9140673,0.9102941,NULL,"brNDC"); easyLeg(ly,"2.76TeV"); ly->AddEntry(meanJetPt[1],"PbPb 0-30%","p"); ly->AddEntry(meanJetPt[3],"pp (smeared)","p"); ly->Draw(); } c5->cd(ipt); hTempPt->DrawCopy(); drawSys(dNdJetPt[2][ipt], dNdJetPtSys[2][ipt], kGreen); drawSys(dNdJetPt[4][ipt], dNdJetPtSys[4][ipt], kYellow); handsomeTH1(dNdJetPt[4][ipt],2); dNdJetPt[4][ipt]->SetMarkerStyle(24); dNdJetPt[2][ipt]->Draw("same"); dNdJetPt[4][ipt]->Draw("same"); if ( ipt==1 ){ TLegend *ly = new TLegend(0.4484643,0.5088445,0.9140673,0.75102941,NULL,"brNDC"); easyLeg(ly,"2.76TeV"); ly->AddEntry(meanJetPt[4],"PbPb 30-100%","p"); ly->AddEntry(meanJetPt[2],"pp (smeared)","p"); ly->Draw(); } double dx1=0.15; if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15);//yeonju 130823 } c5->SaveAs("pT_dependence_jetPt_pp_pbpb_distribution.pdf"); TCanvas* c5pa = new TCanvas("c5pa","",1200,350); makeMultiPanelCanvas(c5pa,nPtBin,1,0.0,0.0,0.2,0.15,0.02); for ( int ipt = 1 ; ipt<=nPtBin ; ipt++) { c5pa->cd(ipt); // draw pp hTempPt->SetXTitle("p_{T}^{Jet} (GeV)"); hTempPt->SetYTitle("#frac{dN}{dp_{T}} #frac{1}{N}"); hTempPt->SetAxisRange(10,150,"X"); // hTempPt->SetAxisRange(0,0.025,"Y"); hTempPt->SetAxisRange(0,0.07,"Y"); handsomeTH1(hTempPt,0); hTempPt->DrawCopy(); drawSys(dNdJetPt[5][ipt], dNdJetPtSys[5][ipt], kYellow); handsomeTH1(dNdJetPt[5][ipt],2); dNdJetPt[6][ipt]->Draw("same"); dNdJetPt[5][ipt]->Draw("same"); if ( ipt == 1 ) { TLegend *ly = new TLegend(0.4855983,0.5529059,0.9512013,0.7645899,NULL,"brNDC"); easyLeg(ly,"5.02TeV pPb"); ly->AddEntry(meanJetPt[5],"Data","p"); ly->AddEntry(meanJetPt[6],"PYTHIA+HIJING","p"); ly->Draw(); } double dx1=0.15; if ( ipt == nPtBin ) drawText(Form("p_{T}^{#gamma} > %dGeV, ", (int)ptBin[ipt-1]), 0.12+dx1+0.25,0.85,1,15);//yeonju 130823 else drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, ", (int)ptBin[ipt-1], (int)ptBin[ipt]), 0.12+dx1,0.85,1,15);//yeonju 130823 } c5pa->SaveAs("pT_dependence_jetPt_pA_distribution.pdf"); }
void DrawTHStack(){ static const int nColor = 9; static const int colorCode[nColor] = { 1,2,3,6,4,8,1,9,5}; gStyle->SetOptStat(kFALSE); int sth=0; int Gth=0; TFile *f = TFile::Open(outG); TObjArray *hs[3]; std::vector<TH1D*> h[3]; TCanvas *c1 = new TCanvas("c1","stacked hists",10,10,600,600); c1->SetLogy(); TString dirname; TString name; TH1D* hFrame = new TH1D("","",4000,0,4000); hFrame->GetXaxis()->SetRangeUser(0,500); hFrame->GetYaxis()->SetRangeUser(1,1e5); hFrame->GetXaxis()->SetTitle("N_{part}"); hFrame->GetYaxis()->SetTitle("# of Events"); hFrame->DrawCopy(); if(Gth==0) name = "G0"; else if(Gth<nGlau && Gth>0) name = Form("Glau_%d",Gth); else name = Form("bin_%d",Gth-nGlau+1); TVectorD *centbin = (TVectorD*)f->Get(Form("std/G0/centbin")); TVectorD *kpoint = (TVectorD*)f->Get(Form("std/G0/kpoint")); for(int sth=0; sth<1; sth++){ if(sth==0){dirname = "std";} else if(sth==1){dirname ="Gri055";} else {dirname ="Gri101";} hs[sth] = (TObjArray*)f->Get(Form("%s/%s/Npartdis",dirname.Data(),name.Data())); h[sth].resize(N); for(int i=0;i<N;i++){ // h[sth][i] = (TH1D*)hs[sth]->GetStack()->At(N-1); h[sth][i] = (TH1D*)hs[sth]->At(i); h[sth][i]->SetLineColor(colorCode[i]); h[sth][i]->SetMarkerSize(1.0); h[sth][i]->SetMarkerStyle(20); h[sth][i]->SetMarkerColor(colorCode[i]); h[sth][i]->Draw("Psame"); // hs[sth]->Draw("Psame"); } } std::vector<TString> label(N); TLegend *leg0 = new TLegend(0.60,0.60,0.90,0.88); leg0->SetFillColor(10); leg0->SetBorderSize(0); leg0->SetTextFont(42); leg0->SetTextSize(0.030); for(int i=0;i<N;i++){ if(method==0)label[i] = Form("%.2f-%.2f%%",(*centbin)[i]*100,(*centbin)[i+1]*100); else label[i] = Form("%.2f-%.2f",(*kpoint)[i],(*kpoint)[i+1]); // leg0->AddEntry(h[0][i],"standard","p"); leg0->AddEntry(h[0][i],label[i],"p"); } // leg0->AddEntry(h[1],"Gribov #Omega=0.55","p"); // leg0->AddEntry(h[2],"Gribov #Omega=1.01","p"); leg0->Draw(); c1->Print("Npartdis.pdf"); c1->Print("Npartdis.png"); }
void MCtoSTATerrors() { TLatex *tplus = labelLatex(0.1364943,0.8114407,"MC sample"); TFile *file0 = TFile::Open("results/StandardCutflow/allmc.root"); TCanvas *c1 = new TCanvas(); //TCanvas *c2 = new TCanvas(); TH1D * LPplus = (TH1D*)file0->Get("RECO_PolPlots_50toinf/RECO_ICVarPFPlus"); TH1D * LPminus = (TH1D*)file0->Get("RECO_PolPlots_50toinf/RECO_ICVarPFMinus"); LPplus->Rebin(20); LPminus->Rebin(20); LPplus->Scale(0.3); LPminus->Scale(0.3); TH1D * newLPplus = (TH1D*)LPplus->Clone(); TH1D * newLPminus = (TH1D*)LPminus->Clone(); for(unsigned int i=1; i < LPplus->GetXaxis()->GetNbins(); i++) { newLPplus->SetBinError(i, TMath::Sqrt(LPplus->GetBinContent(i))); newLPminus->SetBinError(i, TMath::Sqrt(LPminus->GetBinContent(i))); } c1->cd(); newLPplus->GetYaxis()->SetTitle("Events / 300 nb^{-1}"); //newLPplus->GetXaxis()->SetTitle("LP(#mu^{+})"); newLPplus->GetXaxis()->SetTitle("LP(#mu)"); newLPplus->GetXaxis()->SetRangeUser(-1.0,2.0); newLPplus->SetLineWidth(3); newLPplus->SetLineStyle(2); newLPplus->SetLineColor(kRed); newLPplus->DrawCopy(); tplus->DrawClone("same"); // c2->cd(); // newLPminus->GetYaxis()->SetTitle("Events / 100 nb^{-1}"); // newLPminus->GetXaxis()->SetTitle("LP(#mu^{-})"); newLPminus->SetLineWidth(3); newLPminus->SetLineStyle(2); newLPminus->SetLineColor(kBlack); newLPminus->DrawCopy("same"); // tplus->DrawClone("same"); leg = new TLegend(0.762931,0.720339,0.8649425,0.8622881,NULL,"brNDC"); leg->AddEntry(newLPplus,"#mu^{+}","l"); leg->AddEntry(newLPminus,"#mu^{-}","l"); leg->SetFillColor(kWhite); leg->SetBorderSize(0); leg->SetTextFont(62); leg->DrawClone(); file0->Close(); return; }