int main(int argc, char * argv[]){
if(argc < 3){cout<<" Usage: executable input_file.root outfile.txt"<<endl; return -4;}
int sm_ = 18;
TFile f(argv[1]);
TProfile* pr = 0;
pr = (TProfile*) f.Get("rel_timing_prof_conv_blu");
if( !pr ){cout<<" timing profile not found in the root file"<<endl; return -1;}
float time[1701]; for(int i=0;i<1701;i++){time[i]=-100;}
float half_mean = 0;
for(int ch=1;ch<1701;ch++){
if ( ch<101 || (ch-1)%20 > 9){half_mean=137.4/25.;}// half1
else {half_mean=137.1/25.;}
time[ch] = pr->GetBinContent(ch)+half_mean;
if( fabs(pr->GetBinContent(ch))>0.2 || pr->GetBinEntries(ch)<500 ){
cout<<"cry: "<<ch<<" entries: "<<pr->GetBinEntries(ch)<<" rel timing: "<<pr->GetBinContent(ch)<<endl;
}
}
f.Close();
ofstream txt_channels;
txt_channels.open(argv[2],ios::out);
for(int i=1;i<1701;i++){
txt_channels <<sm_<<" "<<setw(4)<<i<<" \t "<<setw(8)<<setprecision(7)<<time[i]<< endl;
}
txt_channels.close();
return 0;
}
//------------------------------------------------------------------------------
double meanY( char* hs ) // for profiles only
{
TObject* obj = gDirectory->Get(hs);
if( !obj->InheritsFrom( "TProfile" ) ) {
cout << hs << " is not profile plot" << endl;
return 0;
}
TProfile* p = (TProfile*)obj;
double sumw = 0;
double sumy = 0;
for( int i = 1; i <= p->GetNbinsX(); ++i ) { // bin 0 is underflow
double w = p->GetBinEntries(i);
sumw += w;
sumy += w * p->GetBinContent(i);
}
if( sumw > 0.1 )
return sumy/sumw;
else
return 0;
}
void plotAnaMult4(char *infname="ana.root")
{
TFile *inf = new TFile(infname);
TTree *tData = (TTree*) inf->Get("Data_tree");
TTree *tMC = (TTree*) inf->Get("MC_tree");
TTree *tPP = (TTree*) inf->Get("PP_tree");
TCanvas *c1 = new TCanvas("c","",1200,700);
// c->Divide(4,1);
TCut recoCut = "leadingJetPt>120&&subleadingJetPt>50&&dphi>5*3.14159265358979/6.&&abs(leadingJetEta)<1.6&&abs(subleadingJetEta)<1.6";
TCut genCut = "genleadingJetPt>120&&gensubleadingJetPt>50&&genDphi>5*3.14159265358979/6.&&abs(genleadingJetEta)<1.6&&abs(gensubleadingJetEta)<1.6";
const int nPtBin=5;
Float_t PtBins[nPtBin+1] = {0.001,0.5,1,1.5,2,3.2};
Int_t centBin[5] = {200,100,60,20,0};
makeMultiPanelCanvas(c1,4,2,0.0,0.0,0.2,0.2,0.02);
for (int i=0;i<4;i++) {
c1->cd(i+1);
TH1D * empty=new TH1D("empty","",100,0,3.19);
// empty->Fill(0.5,1000);
empty->SetMaximum(39.99);
empty->SetMinimum(0.001);
empty->SetNdivisions(105,"X");
empty->GetXaxis()->SetTitleSize(28);
empty->GetXaxis()->SetTitleFont(43);
empty->GetXaxis()->SetTitleOffset(1.8);
empty->GetXaxis()->SetLabelSize(22);
empty->GetXaxis()->SetLabelFont(43);
empty->GetYaxis()->SetTitleSize(28);
empty->GetYaxis()->SetTitleFont(43);
empty->GetYaxis()->SetTitleOffset(1.8);
empty->GetYaxis()->SetLabelSize(22);
empty->GetYaxis()->SetLabelFont(43);
empty->GetXaxis()->CenterTitle();
empty->GetYaxis()->CenterTitle();
empty->SetXTitle("#Delta#eta_{1,2}");
empty->SetYTitle("Multiplicity Difference");
TProfile *pData = new TProfile(Form("pData%d",i),"",nPtBin,PtBins);
TProfile *pMC = new TProfile(Form("pMC%d",i),"",nPtBin,PtBins);
TProfile *pPP = new TProfile(Form("pPP%d",i),"",nPtBin,PtBins);
TProfile *pGen = new TProfile(Form("pGen%d",i),"",nPtBin,PtBins);
TCut centCut = Form("hiBin>=%d&&hiBin<%d",centBin[i+1],centBin[i]);
tData->Draw(Form("-multDiff:abs(leadingJetEta-subleadingJetEta)>>pData%d",i),recoCut&¢Cut);
tPP->Draw(Form("-multDiff:abs(leadingJetEta-subleadingJetEta)>>pPP%d",i),recoCut);
tMC->Draw(Form("-multDiff:abs(leadingJetEta-subleadingJetEta)>>pMC%d",i),recoCut&¢Cut);
tMC->Draw(Form("-genMultDiff:abs(genleadingJetEta-gensubleadingJetEta)>>pGen%d",i),genCut&¢Cut);
pMC->SetLineColor(2);
pMC->SetMarkerColor(2);
pPP->SetLineColor(4);
pPP->SetMarkerColor(4);
// pData->SetAxisRange(0,50,"Y");
// pData->SetAxisRange(0,0.49,"X");
empty->Draw();
double diff=0;
if (i==0) diff=0.1;
drawText(Form("%d-%d %%",(int)(0.5*centBin[i+1]),(int)(0.5*centBin[i])),0.22+diff,0.65);
if (i==0) drawText("PbPb #sqrt{s_{NN}}=2.76 TeV 150/#mub",0.22+diff,0.85);
if (i==0) drawText("pp #sqrt{s_{NN}}=2.76 TeV 5.3/pb",0.22+diff,0.75);
if (i==3) drawText("CMS Preliminary",0.3+diff,0.85);
Float_t sys[4]={1,1,2.5,3};
for (int j=1;j<=pData->GetNbinsX();j++)
{
TBox *b = new TBox(pData->GetBinLowEdge(j),pData->GetBinContent(j)-sys[i],pData->GetBinLowEdge(j+1),pData->GetBinContent(j)+sys[i]);
//b->SetFillColor(kGray);
b->SetFillStyle(0);
b->SetLineColor(1);
b->Draw();
TBox *b2 = new TBox(pPP->GetBinLowEdge(j),pPP->GetBinContent(j)-1,pPP->GetBinLowEdge(j+1),pPP->GetBinContent(j)+1);
//b2->SetFillColor(65);
b2->SetFillStyle(0);
b2->SetLineColor(4);
b2->Draw();
}
pData->Draw("same");
pMC->Draw("same");
pPP->Draw("same");
pGen->SetMarkerColor(4);
pGen->SetMarkerStyle(24);
pData->Draw("same");
// pGen->Draw(" same");
c1->cd(5+i);
TH1D *empty2 = (TH1D*)empty->Clone("empty2");
empty2->SetYTitle("PbPb - pp");
empty2->SetMinimum(-5);
empty2->SetMaximum(+29.99);
empty2->Draw();
// TProfile *pDiff = (TProfile*)pData->Clone("pDiff");
TH1D *pDiff = new TH1D("pDiff","",nPtBin,PtBins);
for (int j=1;j<=pData->GetNbinsX();j++)
{
pDiff->SetBinContent(j,pData->GetBinContent(j)-pPP->GetBinContent(j));
pDiff->SetBinError(j,sqrt(pData->GetBinError(j)*pData->GetBinError(j)+pPP->GetBinError(j)*pPP->GetBinError(j)));
TBox *b = new TBox(pDiff->GetBinLowEdge(j),pDiff->GetBinContent(j)-sys[i],pDiff->GetBinLowEdge(j+1),pDiff->GetBinContent(j)+sys[i]);
TBox *b2 = new TBox(pDiff->GetBinLowEdge(j),pDiff->GetBinContent(j)-sys[i],pDiff->GetBinLowEdge(j+1),pDiff->GetBinContent(j)+sys[i]);
b->SetFillColor(TColor::GetColor("#FFEE00"));
b2->SetLineColor(1);
b2->SetFillStyle(0);
b->Draw();
b2->Draw();
}
pDiff->Draw("p same");
TLegend *leg = new TLegend(0.3,0.6,0.9,0.9);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->AddEntry(pData,"PbPb","pl");
leg->AddEntry(pPP,"pp","pl");
leg->AddEntry(pMC,"PYTHIA+HYDJET","pl");
if (i==0) leg->Draw();
if (i==1) drawText("p_{T,1} > 120 GeV/c",0.22+diff,0.85);
if (i==1) drawText("p_{T,2} > 50 GeV/c",0.22+diff,0.75);
if (i==1) drawText("#Delta#phi_{1,2} > 5#pi/6",0.22+diff,0.65);
}
/*
TCanvas *c1 = new TCanvas("c1","",(ncent+1)*300,700);
makeMultiPanelCanvas(c1,ncent+1,2,0.0,0.0,0.2,0.2,0.02);
TH1D * empty=new TH1D("empty",Form(";%s;<#slash{p}_{T}^{#parallel}> (GeV)",axistitle[index_var].Data()),nalpha/2+1,frac);
TH1D * empty2=new TH1D("empty2",Form(";%s;<#slash{p}_{T}^{#parallel}> (GeV)",axistitle[index_var].Data()),nalpha/2+1,frac);
empty->Fill(0.5,1000);
empty2->Fill(0.5,1000);
if(doIntegrate){
if(index_var==0){
empty->SetMaximum(30);
empty->SetMinimum(-70);
}else{
empty->SetMaximum(35);
empty->SetMinimum(-45);
}
}else{
empty->SetMaximum(15);
empty->SetMinimum(-10);
empty2->SetMaximum(15);
empty2->SetMinimum(-10);
}
empty->GetXaxis()->SetTitleSize(28);
empty->GetXaxis()->SetTitleFont(43);
empty->GetXaxis()->SetTitleOffset(2.2);
empty->GetXaxis()->SetLabelSize(22);
empty->GetXaxis()->SetLabelFont(43);
empty->GetYaxis()->SetTitleSize(28);
empty->GetYaxis()->SetTitleFont(43);
empty->GetYaxis()->SetTitleOffset(2.2);
empty->GetYaxis()->SetLabelSize(22);
empty->GetYaxis()->SetLabelFont(43);
empty2->GetXaxis()->SetTitleSize(28);
empty2->GetXaxis()->SetTitleFont(43);
empty2->GetXaxis()->SetTitleOffset(2.2);
empty2->GetXaxis()->SetLabelSize(22);
empty2->GetXaxis()->SetLabelFont(43);
empty2->GetYaxis()->SetTitleSize(28);
empty2->GetYaxis()->SetTitleFont(43);
empty2->GetYaxis()->SetTitleOffset(2.2);
empty2->GetYaxis()->SetLabelSize(22);
empty2->GetYaxis()->SetLabelFont(43);
c1->cd(ncent+2);
*/
c1->SaveAs("results/MultiplicityDifference-DeltaEta.C");
c1->SaveAs("results/MultiplicityDifference-DeltaEta.gif");
c1->SaveAs("results/MultiplicityDifference-DeltaEta.eps");
c1->SaveAs("results/MultiplicityDifference-DeltaEta.pdf");
}
void process()
{
Int_t raw[512]; // buffer for input signal and bkg trees
// buffers for output trees
Int_t sig[512];
Int_t cmsig[512];
Int_t cm[16];
// pedestal
const char* fbkg_name = "Raw_Data_FZ320P_05_MSSD_2_250V_K237_Pedestal.dat-events.root";
TFile* fbkg = TFile::Open(fbkg_name);
if (!fbkg) cout<< "File not found: " << fbkg <<endl<<exitl;
TTree* tree = (TTree*) fbkg->Get("etree");
tree->SetBranchAddress("raw", &raw);
TH2* h2d = (TH2*) fbkg->Get("h2d");
new TCanvas;
h2d->Draw();
TProfile* profile = (TProfile*) fbkg->Get("profile");
//new TCanvas;
//profile->Draw();
Int_t pedestal[512];
for (int i=0; i<512; i++) {
// pedestal[i] = profile->GetBinContent(i+1) - 0.5;
// pedestal[i] = profile->GetBinContent(i+1) + 0.5;
pedestal[i] = profile->GetBinContent(i+1);
}
// cout << "\nPedestals for every channel\n" << endl;
// for (int i=0; i<512; i++) {
// cout << pedestal[i] << " ";
// if (i>0 && (i+1)%128==0)
// cout << endl;
// }
cout<< "processing bkg" <<endl;
// output file with tree
const char* obfname = "FZ320P_05_MSSD_2-bkg.root";
TFile* obfile = TFile::Open(obfname, "recreate");
TTree* btree = new TTree("btree", "btree");
btree->Branch("sig", &sig, "sig[512]/I");
btree->Branch("cmsig", &cmsig, "cmsig[512]/I");
btree->Branch("cm", &cm, "cm[16]/I");
btree->SetMarkerStyle(6);
btree->SetMarkerColor(2);
for (int jentry=0; jentry<tree->GetEntries(); ++jentry)
{
tree->GetEvent(jentry);
// sig
for (int i=0; i<512; ++i) {
sig[i] = raw[i] - pedestal[i];
}
// calc common mode
Int_t group32[32];
Int_t index32[32];
for (int igroup=0; igroup<16; ++igroup) {
for (int istrip=0; istrip<32; ++istrip) // istrip is number inside group of 32
{
group32[istrip] = sig[igroup*32 + istrip];
}
// sort array group32 in ascending order
TMath::Sort(32, group32, index32, kFALSE);
Int_t median = group32[index32[14]];
cm[igroup] = median;
}
// subtract common mode
for (int istrip=0; istrip<512; ++istrip) {
Int_t igroup = istrip/32;
cmsig[istrip] = sig[istrip] - cm[igroup];
}
// Fill sig, cmsig, cm
btree->Fill();
}
obfile->Write();
/////////////////////////////////////////////////
//
// signal tree
//
/////////////////////////////////////////////////
cout<< "processing signal" <<endl;
TChain* chain = new TChain("etree");
chain->Add("Raw_Data_FZ320P_05_MSSD_250V_K237_Position_1.dat-events.root");
chain->Add("Raw_Data_FZ320P_05_MSSD_250V_K237_Position_2.dat-events.root");
chain->Add("Raw_Data_FZ320P_05_MSSD_2_250V_K237_Position_3.dat-events.root");
chain->Add("Raw_Data_FZ320P_05_MSSD_2_250V_K237_Position_4.dat-events.root");
chain->SetBranchAddress("raw", &raw);
// output file with tree
const char* osfname = "FZ320P_05_MSSD_2-signal.root";
TFile* osfile = TFile::Open(osfname, "recreate");
TTree* stree = new TTree("stree", "stree");
stree->Branch("sig", &sig, "sig[512]/I");
stree->Branch("cmsig", &cmsig, "cmsig[512]/I");
stree->Branch("cm", &cm, "cm[16]/I");
stree->SetMarkerStyle(6);
stree->SetMarkerColor(2);
for (int jentry=0; jentry<chain->GetEntries(); ++jentry)
{
chain->GetEvent(jentry);
// sig
for (int i=0; i<512; ++i) {
sig[i] = raw[i] - pedestal[i];
}
// calc common mode
Int_t group32[32];
Int_t index32[32];
for (int igroup=0; igroup<16; ++igroup) {
for (int istrip=0; istrip<32; ++istrip) // istrip is number inside group of 32
{
group32[istrip] = sig[igroup*32 + istrip];
}
// sort array group32 in ascending order
TMath::Sort(32, group32, index32, kFALSE);
Int_t median = group32[index32[14]];
cm[igroup] = median;
}
// subtract common mode
for (int istrip=0; istrip<512; ++istrip) {
Int_t igroup = istrip/32;
cmsig[istrip] = sig[istrip] - cm[igroup];
}
// Fill sig, cmsig, cm
stree->Fill();
}
osfile->Write();
////////////////////////////////////////////////////////
//
// process trees
//
///////////////////////////////////////////////////////
cout<< "results" <<endl;
Double_t a, mean, sigma;
TH1F* h_sigma_bkg = new TH1F("h_sigma_bkg","CM subtr. noise for groups", 16,0,16);
TH1F* h_mean_sig = new TH1F("h_mean_sig","CM subtr. signal for groups", 16,0,16);
TH1F* h_SN = new TH1F("h_SN","Signal to Noise Ratio for groups", 16,0,16);
new TCanvas;
btree->Draw("cmsig","Iteration$>=0&&Iteration$<32");
fitgr(0,0, "Q", "goff", btree->GetHistogram());
pargaus(a,mean,sigma,"htemp");
//cout<< "mean = " << mean << " sigma = " << sigma <<endl;
//-- png("FZ320P_05_MSSD_2-bkg-ex");
new TCanvas;
// for (int igroup=0; igroup<16; ++igroup) {
for (int igroup=0; igroup<15; ++igroup) {
Int_t ch1 = igroup*32;
Int_t ch2 = (igroup+1)*32;
btree->Draw("cmsig",Form("Iteration$>=%d&&Iteration$<%d",ch1,ch2),"");
fitgr(0,0, "", "", btree->GetHistogram());
pargaus(a,mean,sigma,"htemp");
// h_sigma_bkg->Fill(igroup, sigma);
h_sigma_bkg->SetBinContent(igroup+1, sigma);
}
new TCanvas;
h_sigma_bkg->Draw();
//-- png("FZ320P_05_MSSD_2-bkg-allgroups");
// signal
new TCanvas;
stree->Draw("cmsig","cmsig>8 &&Iteration$>=0&&Iteration$<32");
//-- png("FZ320P_05_MSSD_2-sig-ex");
new TCanvas;
// for (int igroup=0; igroup<16; ++igroup) {
for (int igroup=0; igroup<15; ++igroup) {
Int_t ch1 = igroup*32;
Int_t ch2 = (igroup+1)*32;
stree->Draw("cmsig",Form("cmsig>8 &&Iteration$>=%d&&Iteration$<%d",ch1,ch2),"");
gPad->Update();
gPad->Modified();
mean = stree->GetHistogram()->GetMean();
h_mean_sig->SetBinContent(igroup+1, mean);
}
new TCanvas;
h_mean_sig->Draw();
//-- png("FZ320P_05_MSSD_2-signal-allgroups");
for (int igroup=0; igroup<16; ++igroup) {
Double_t signal32 = h_mean_sig->GetBinContent(igroup+1);
Double_t noise32 = h_sigma_bkg->GetBinContent(igroup+1);
Double_t snr = 0;
if (noise32 > 0) snr = signal32 / noise32;
h_SN->SetBinContent(igroup+1, snr);
}
new TCanvas;
h_SN->Draw();
//-- png("FZ320P_05_MSSD_2-SN-allgroups");
}
void fitBjetJES(int ppPbPb=1, int cbinlo=12, int cbinhi=40){
if(!ppPbPb){
cbinlo=0;
cbinhi=40;
}
gStyle->SetOptTitle(0);
gStyle->SetOptStat(0);
TFile *fL;
if(!ppPbPb)fL=new TFile("histos/ppMC_hiReco_jetTrig_highPurity_JEC.root");
else fL=new TFile("histos/PbPbQCDMC_pt30by3_ipHICalibCentWeight.root");
// these are dummy files for pp
TFile *fB=new TFile("histos/PbPbBMC_pt30by3_ipHICalibCentWeight.root");
TFile *fC=new TFile("histos/PbPbCMC_pt30by3_ipHICalibCentWeight.root");
TNtuple *tL = (TNtuple*) fL->Get("nt");
TNtuple *tB = (TNtuple*) fB->Get("nt");
TNtuple *tC = (TNtuple*) fC->Get("nt");
float jtptL, refptL, jtetaL, weightL, refparton_flavorForBL, binL;
tL->SetBranchAddress("jtpt",&jtptL);
tL->SetBranchAddress("jteta",&jtetaL);
tL->SetBranchAddress("refpt",&refptL);
tL->SetBranchAddress("weight",&weightL);
if(ppPbPb)tL->SetBranchAddress("bin",&binL);
tL->SetBranchAddress("refparton_flavorForB",&refparton_flavorForBL);
float jtptB, refptB, jtetaB, weightB, refparton_flavorForBB, binB;
tB->SetBranchAddress("jtpt",&jtptB);
tB->SetBranchAddress("jteta",&jtetaB);
tB->SetBranchAddress("refpt",&refptB);
tB->SetBranchAddress("weight",&weightB);
if(ppPbPb)tB->SetBranchAddress("bin",&binB);
tB->SetBranchAddress("refparton_flavorForB",&refparton_flavorForBB);
float jtptC, refptC, jtetaC, weightC, refparton_flavorForBC, binC;
tC->SetBranchAddress("jtpt",&jtptC);
tC->SetBranchAddress("jteta",&jtetaC);
tC->SetBranchAddress("refpt",&refptC);
tC->SetBranchAddress("weight",&weightC);
if(ppPbPb)tC->SetBranchAddress("bin",&binC);
tC->SetBranchAddress("refparton_flavorForB",&refparton_flavorForBC);
TProfile *hL = new TProfile("hL","hL",250,50,300,0,10);
TProfile *hB = new TProfile("hB","hB",250,50,300,0,10);
TProfile *hC = new TProfile("hC","hC",250,50,300,0,10);
hL->Sumw2(),hB->Sumw2(),hC->Sumw2();
for(int i=0;i<tL->GetEntries();i++){
tL->GetEntry(i);
if(!ppPbPb) binL=39;
if(fabs(jtetaL)<2 && binL>=cbinlo && binL<cbinhi)
hL->Fill(refptL,jtptL/refptL,weightL);
if(!ppPbPb){
if(fabs(jtetaL)<2 && binL>=cbinlo && binL<cbinhi && abs(refparton_flavorForBL)==5)
hB->Fill(refptL,jtptL/refptL,weightL);
if(fabs(jtetaL)<2 && binL>=cbinlo && binL<cbinhi && abs(refparton_flavorForBL)==4)
hC->Fill(refptL,jtptL/refptL,weightL);
}
}
if(ppPbPb){
for(int i=0;i<tB->GetEntries();i++){
tB->GetEntry(i);
if(fabs(jtetaB)<2 && binB>=cbinlo && binB<cbinhi && abs(refparton_flavorForBB)==5)
hB->Fill(refptB,jtptB/refptB,weightB);
}
for(int i=0;i<tC->GetEntries();i++){
tC->GetEntry(i);
if(fabs(jtetaC)<2 && binC>=cbinlo && binC<cbinhi && abs(refparton_flavorForBC)==4)
hC->Fill(refptC,jtptC/refptC,weightC);
}
}
hL->SetMinimum(0.);
hL->SetLineColor(kBlue);
hB->SetLineColor(kRed);
hC->SetLineColor(kGreen);
hL->SetMarkerColor(kBlue);
hB->SetMarkerColor(kRed);
hC->SetMarkerColor(kGreen);
//hL->SetMarkerStyle(4);
//hB->SetMarkerStyle(4);
//hC->SetMarkerStyle(4);
hL->SetXTitle("genJet p_{T} (GeV/c)");
hL->SetYTitle("<reco p_{T} / gen p_{T} >");
hL->GetXaxis()->SetRangeUser(50.,199.999);
hL->GetYaxis()->SetRangeUser(0.5,1.05);
TCanvas *c1=new TCanvas("c1","c1",800,600);
c1->SetGridx(1);
c1->SetGridy(1);
hL->Draw("e1");
hB->Draw("e1,same");
hC->Draw("e1,same");
TLegend *leg=new TLegend(0.4,0.15,0.9,0.45);
leg->SetBorderSize(0);
leg->SetFillStyle(0);
if(ppPbPb&&cbinlo==0&&cbinhi==40)leg->SetHeader("Pythia+Hydjet, 0-100%");
leg->AddEntry(hL,"Inclusive jets","pl");
leg->AddEntry(hC,"c-jets","pl");
leg->AddEntry(hB,"b-jets","pl");
leg->Draw();
TCanvas *c2=new TCanvas("c2","c2",1);
/*
TH1F *hL2 = (TH1F*)hL->Clone("hL2");
TH1F *hB2 = (TH1F*)hB->Clone("hB2");
hL2->Add(hB2,-1);
hL2->Draw();
*/
TH1F *hcorr = new TH1F("hcorr","hcorr",250,50,300);
hcorr->Sumw2();
for(int i=0;i<hL->GetNbinsX();i++){
cout<<" b resp "<<hB->GetBinContent(i+1)<<endl;
cout<<" l resp "<<hL->GetBinContent(i+1)<<endl;
cout<<" l offset "<<1.-hL->GetBinContent(i+1)<<endl;
cout<<" corrected b resp "<<hB->GetBinContent(i+1)+1.-hL->GetBinContent(i+1)<<endl;
float jesOffset = 1.-hL->GetBinContent(i+1);
hcorr->SetBinContent(i+1,hB->GetBinContent(i+1)+jesOffset);
hcorr->SetBinError(i+1,sqrt(hB->GetBinError(i+1)*hB->GetBinError(i+1)+hL->GetBinError(i+1)*hL->GetBinError(i+1)));
}
hcorr->SetMinimum(0.5);
hcorr->SetMaximum(1.1);
hcorr->SetLineColor(kRed);
hcorr->SetMarkerColor(kRed);
hcorr->SetMarkerStyle(4);
hcorr->Draw();
TF1 *fCorr = new TF1("fCorr","[0]+[1]*log(x)+[2]*log(x)*log(x)",50,300);
fCorr->SetLineWidth(1);
fCorr->SetLineColor(kBlue);
hcorr->Fit(fCorr);
TFile *fout;
if(ppPbPb) fout =new TFile(Form("bJEShistos/bJetScale_PbPb_Cent_fineBin_%d_%d.root",cbinlo,cbinhi),"recreate");
else fout =new TFile("bJEShistos/bJetScale_PP_fineBin.root","recreate");
hcorr->Write();
fCorr->Write();
fout->Close();
}
void read_tpvar(const char* file, int YS,
const char* inputtable_pt, const char* outputtable_pt,
const char* inputtable_rap, const char* outputtable_rap,
const char* inputtable_cent="nocentrality", const char* outputtable_cent="nocentrality")
{
// YS decides on the binning.
// YS=1 -> fine binning
// YS=2 -> coarse binning
// YS=0 -> both
// YS=4 -> both, except centrality where only fine (for 1S in pbpb)
TFile *f = new TFile("tpvar.root","RECREATE");
TTree *tr = new TTree("tree","tree");
tr->ReadFile(file,"name/C:binlow/F:binhigh/F:eff/F:stat/F:syst/F");
unsigned int NPTNS = YS==1 ? NPT1S : NPT2S;
unsigned int NRAPNS = YS==1 ? NRAP1S : NRAP2S;
unsigned int NCENTNS = YS==1 ? NCENT1S : NCENT2S;
double *ptbins_NS = YS==1 ? ptbins_1S : ptbins_2S;
double *rapbins_NS = YS==1 ? rapbins_1S : rapbins_2S;
int *centbins_NS = YS==1 ? centbins_1S : centbins_2S;
bool docentrality=strcmp(inputtable_cent,"nocentrality");
ifstream intable_pt(inputtable_pt);
ifstream intable_rap(inputtable_rap);
ifstream intable_cent; if (docentrality) intable_cent.open(inputtable_cent);
ofstream outtable_pt(outputtable_pt);
ofstream outtable_rap(outputtable_rap);
ofstream outtable_cent; if (docentrality) outtable_cent.open(outputtable_cent);
double binmin, binmax, eff0, efferr, effmean;
TString var("pt_SF");
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_NS[0],ptbins_NS[NPTNS]),"PROFs");
// tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_NS[0],40.),"PROFs"); // ugly fix
TProfile *htemp = (TProfile*) gDirectory->Get("htemp");
binmin=ptbins_NS[0];
binmax=ptbins_NS[NPTNS]; //40.;//(ugly fix)
eff0=firsteff(tr,var.Data(),binmin,binmax);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_pt,outtable_pt,binmin,binmax,eff0,efferr);
delete htemp;
skip_lines(intable_pt,1);// \hline
if (YS==0||YS==4)
{
NPTNS=NPT2S; ptbins_NS=ptbins_2S;
}
for (unsigned int i=0; i<NPTNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),ptbins_1S[i],ptbins_1S[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_1S[i],ptbins_1S[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=ptbins_NS[i];
binmax=ptbins_NS[i+1];
eff0=firsteff(tr,var.Data(),ptbins_NS[i],ptbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_pt,outtable_pt,binmin,binmax,eff0,efferr);
delete htemp;
}
if (YS==0||YS==4)
{
NPTNS=NPT1S; ptbins_NS=ptbins_1S;
outtable_pt << "\\hline" << endl;
skip_lines(intable_pt,1);// \hline
for (unsigned int i=0; i<NPT1S; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),ptbins_1S[i],ptbins_1S[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_1S[i],ptbins_1S[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=ptbins_NS[i];
binmax=ptbins_NS[i+1];
eff0=firsteff(tr,var.Data(),ptbins_NS[i],ptbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_pt,outtable_pt,binmin,binmax,eff0,efferr);
delete htemp;
}
}
var = TString("rapidity_SF");
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),rapbins_NS[0],rapbins_NS[NRAPNS]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=rapbins_NS[0];
binmax=rapbins_NS[NRAPNS];
eff0=firsteff(tr,var.Data(),rapbins_NS[0],rapbins_NS[NRAPNS]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
delete htemp;
if (YS==0||YS==4)
{
NRAPNS=NRAP2S; rapbins_NS=rapbins_2S;
}
for (unsigned int i=0; i<NRAPNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),rapbins_NS[i],rapbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),rapbins_NS[i],rapbins_NS[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=rapbins_NS[i];
binmax=rapbins_NS[i+1];
eff0=firsteff(tr,var.Data(),rapbins_NS[i],rapbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_rap,outtable_rap,binmin,binmax,eff0,efferr);
delete htemp;
}
if (YS==0||YS==4)
{
outtable_rap << "\\hline" << endl;
skip_lines(intable_rap,1);// \hline
NRAPNS=NRAP1S; rapbins_NS=rapbins_1S;
for (unsigned int i=0; i<NRAPNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),rapbins_NS[i],rapbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),rapbins_NS[i],rapbins_NS[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=rapbins_NS[i];
binmax=rapbins_NS[i+1];
eff0=firsteff(tr,var.Data(),rapbins_NS[i],rapbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_rap,outtable_rap,binmin,binmax,eff0,efferr);
delete htemp;
}
}
if (!docentrality) return;
var = TString("centrality_SF");
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),centbins_NS[0]*2.5,centbins_NS[NCENTNS]*2.5),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=centbins_NS[0]*2.5;
binmax=centbins_NS[NCENTNS]*2.5;
eff0=firsteff(tr,var.Data(),centbins_NS[0]*2.5,centbins_NS[NCENTNS]*2.5);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
delete htemp;
if (YS==0)
{
NCENTNS=NCENT2S; centbins_NS=centbins_2S;
}
else if (YS==4)
{
NCENTNS=NCENT1S; centbins_NS=centbins_1S;
}
for (unsigned int i=0; i<NCENTNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),centbins_NS[i],centbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=centbins_NS[i]*2.5;
binmax=centbins_NS[i+1]*2.5;
eff0=firsteff(tr,var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_cent,outtable_cent,binmin,binmax,eff0,efferr);
delete htemp;
}
if (YS==0)
{
NCENTNS=NCENT1S; centbins_NS=centbins_1S;
outtable_cent << "\\hline" << endl;
skip_lines(intable_cent,1);// \hline
for (unsigned int i=0; i<NCENTNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),centbins_NS[i],centbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=centbins_NS[i]*2.5;
binmax=centbins_NS[i+1]*2.5;
eff0=firsteff(tr,var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_cent,outtable_cent,binmin,binmax,eff0,efferr);
delete htemp;
}
}
f->Write();
f->Close();
}
void analisi_tree_1hit(){ //faccio gli istogrammi dal Tree T creato nel file CheckESD.C
gROOT->Reset();
gStyle->SetOptStat(0012);
gStyle->SetOptFit(0111);
Bool_t kCal=kFALSE;
TFile *fcal = TFile::Open("calibration.root");
TProfile *hCalX;
TProfile *hCalZ;
if(fcal){
kCal=kTRUE;
hCalX = (TProfile *) fcal->Get("hCalX");
hCalZ = (TProfile *) fcal->Get("hCalZ");
}
else{
hCalX= new TProfile("hCalX","x alignement per strip;# strip;#DeltaX (cm)",1700,0,1700);
hCalZ= new TProfile("hCalZ","z alignement per strip;# strip;#DeltaX (cm)",1700,0,1700);
}
// check alignment
TProfile *hx = new TProfile("hx","x alignement per strip;# strip;#DeltaX (cm)",1700,0,1700);
TProfile *hz = new TProfile("hz","z alignement per strip;# strip;#DeltaZ (cm)",1700,0,1700);
// definire istogrammi (ricordarsi di fare il write nel file successivamente)
//TH1F *hdeltat = new TH1F("hdeltat","inside the pad (cl_{1}) - cluster along x;t_{1} - t_{2} (ps)",400,-500,500);
//TH1F *hdeltax = new TH1F("hdeltax","inside the pad (cl_{1}) - cluster along x;#Deltax_{1} - #Deltax_{2} (cm)",100,-10,10);
TH1F *hch = new TH1F("hch","inside the pad (cl_{1}) - cluster along x;ch_{1} - ch_{2}",500,0,500);
//TH2F *pxt = new TH2F("pxt","inside the pad (cl_{1}) - cluster along x ;t_{1} - t_{2} (ps);cl_{1} #Deltax (cm)",41,-20.5*24.4,20.5*24.4,100,-4,4); // 24.4 ps quantizzazione TDC
//TH2F *pzt = new TH2F("pzt","inside the pad (cl_{1}) - cluster along z ;t_{1} - t_{2} (ps);cl_{1} #Deltaz (cm)",41,-20.5*24.4,20.5*24.4,100,-4,4); // 24.4 ps quantizzazione TDC
//CFC:Istogramma numero cluster(qua coincidono con le hit)
//TH1F *hnc = new TH1F("hnc","Number of Hits",12,0.,12.);
//Istogramma tempi TOF
TH1F *ht1 = new TH1F("ht1","TOF's Time ",41,0.,30000.);
//Istogramma 1D per i residui
TH1F *hresx1 = new TH1F("hresx1","Residui x1",100,-10.,10.);
TH1F *hresz1 = new TH1F("hresz1","Residui z1",100,-10.,10.);
TH1F *hresdist1 = new TH1F("hresdist1","Residui sqrt(x1^2+z1^2)",100,-10.,10.);
//Istogramma 2D per i residui
TH2F *h2resxz1 = new TH2F("h2resxz1" , "Residui dx1 e dz1", 100, -4. , 4. , 100 , -4. , 4.);
//Istogramma tempi meno tempi attesi
TH1F *ht1_texp = new TH1F("ht1_texp","",100,-2000.,2000.);
TH1F *ht1_texptot = new TH1F("ht1_texptot","",100,-2000.,2000.);
//TH1F *hexp_time_pi = new TH1F("hexp_time_pi","hexp_time_pi",1000,0.,30000.);
TProfile *hprofx = new TProfile("hprofx","Profile t1-t_exp_pi vs dx1",26, -2.,2.);
TProfile *hprofxcorr = new TProfile("hprofxcorr","Profile t1-t_exp_pi corr vs dx1",26, -2.,2.);
TProfile *hprofz = new TProfile("hprofz","Profile t1-t_exp_pi vs dz1",26, -3.,3.);
TProfile *hprofd=new TProfile("hprofd","Profile t1-t_exp_pi vs d",26, 0.,4.);
TH1F *htbest = new TH1F("htbest","htbest",100,-2000.,2000.);
TH1F *htcorrtw= new TH1F("htcorrtw","htcorrtw",100,-2000.,2000.);
//TH2F *h2dxdzt1_texp=new TH2F("h2dxdzt1_texp","h2dxdzt1_texp",30,-10.25.,10.25,50,-10.75.,10.75.);
//TH2F *h2dxdzt1_texp_dummy=new TH2F("h2dxdzt1_texp_dummy","h2dxdzt1_texp_dummy",30,-10.25.,10.25,50,-10.75.,10.75.);
TH2F *h2dxdzt1_texp=new TH2F("h2dxdzt1_texp","h2dxdzt1_texp",20,-1.25,1.25,10,-1.75,1.75);
TH2F *h2dxdzt1_texp_dummy=new TH2F("h2dxdzt1_texp_dummy","h2dxdzt1_texp_dummy",20,-1.25,1.25,10,-1.75,1.75);
//Istogramma 2D distanza eff vs delay time
TH2F *h2t1_texp_deff= new TH2F("h2t1_texp_deff" , "Delay time 0 vs deff", 50, 0. , 10.,100,-400.,400.);
TH2F *h2t1_texp_deff_tw= new TH2F("h2t1_texp_deff_tw" , "Delay time 0 corr tw vs deff", 50, 0. , 10.,100,-400.,400.);
TProfile *hprofdeff=new TProfile("hprofdeff","Profile t1-t_exp_pi vs deff",50, -3.,10.);
// Utilizzo TOT.
TH2F *h2t1_texp_TOT= new TH2F("h2t1_texp_TOT" , "Delay time vs TOT", 50, 0. , 100.,100,-400.,400.);
TProfile *hproft1_texp_TOT = new TProfile("hproft1_texp_TOT","Profile t1-t_exp_pi vs TOT",50, 0. , 100.);
TH2F *h2t1_deff_TOT= new TH2F("h2t1_deff_TOT" , "deff vs TOT", 50, 0. , 100.,50, 0. , 10.);
TH2F *h2t1_TOT_deff= new TH2F("h2t1_TOT_deff" , "TOT vs deff",50, 0. , 10., 50, 0. , 100.);
TFile *f = new TFile("AnalysisResults.root");
TTree *T = (TTree*)f->Get("T"); //in generale . (e non freccia) se Tfile è un oggetto e NON un puntatore(*)
//Varibili tree "T"
//Int_t nevento;
//Int_t ntracks;
Int_t ncluster;
Float_t tempo[100];//con start time sottratto
Float_t DeltaX[100];
Float_t DeltaZ[100];
Int_t ChannelTOF[100];
Float_t impulso_trasv;
Float_t exp_time_pi[100];
Float_t L[100];
Float_t TOT[100];
Float_t res[3];
Int_t charge;
Float_t phi,eta;
Float_t secAngle;
Float_t cval[5];
Float_t thetay;
Float_t StartTime,StartTimeRes;
Float_t z;
//T->Branch("nevento",&nevento,"nevento/I");
//T->SetBranchAddress("ntracks",&ntracks);
T->SetBranchAddress("ncluster",&ncluster);
T->SetBranchAddress("tempo",tempo);
T->SetBranchAddress("DeltaX",DeltaX);
T->SetBranchAddress("DeltaZ",DeltaZ);
T->SetBranchAddress("ChannelTOF",ChannelTOF);
T->SetBranchAddress("impulso_trasv",&impulso_trasv);
T->SetBranchAddress("exp_time_pi",exp_time_pi);
T->SetBranchAddress("L",L);
T->SetBranchAddress("TOT",TOT);
T->SetBranchAddress("res",res);
T->SetBranchAddress("charge",&charge);
T->SetBranchAddress("phi",&phi);
T->SetBranchAddress("eta",&eta);
T->SetBranchAddress("secPhi",&secAngle);
T->SetBranchAddress("cval",cval);
T->SetBranchAddress("thetay",&thetay);
T->SetBranchAddress("StartTime",&StartTime);
T->SetBranchAddress("StartTimeRes",&StartTimeRes);
Int_t nentries = (Int_t)T->GetEntries();
for(Int_t i=0;i<nentries;i++) {
T->GetEntry(i);
for(Int_t ip=0;ip<ncluster;ip++){
tempo[ip] -= StartTime;
Int_t strip=ChannelTOF[0]/96;
if(kCal){
DeltaX[ip] -= hCalX->GetBinContent(strip+1);
DeltaZ[ip] -= hCalZ->GetBinContent(strip+1);
}
}
if(ncluster == 1){
if(impulso_trasv>1.3){
hx->Fill(int(ChannelTOF[0]/96),DeltaX[0]);
hz->Fill(int(ChannelTOF[0]/96),DeltaZ[0]);
if(!kCal){
hCalX->Fill(int(ChannelTOF[0]/96),DeltaX[0]);
hCalZ->Fill(int(ChannelTOF[0]/96),DeltaZ[0]);
}
h2resxz1->Fill(DeltaX[0],DeltaZ[0]);
h2resxz1->GetXaxis()->SetTitle("Dx1 (cm)");
h2resxz1->GetYaxis()->SetTitle("Dz1 (cm)");
hresx1->Fill(DeltaX[0]);
hresx1->GetXaxis()->SetTitle("Dx1 (cm)");
hresz1->Fill(DeltaZ[0]);
hresz1->GetXaxis()->SetTitle("Dz1 (cm)");
hresdist1->Fill(sqrt(DeltaX[0]*DeltaX[0]+DeltaZ[0]*DeltaZ[0]));
hresdist1->GetXaxis()->SetTitle("sqrt(Dx^2+Dz^2) (cm)");
}
if(impulso_trasv>0.8 && impulso_trasv<1.){ // serve per gli exp time
//if( TMath::Abs(DeltaZ[0])<1.75){
if(TMath::Abs(tempo[0]-exp_time_pi[0])<800./* per avere circa 3 sigma che sia un pi*/ ){
if(TMath::Abs(DeltaX[0])<1.5){
//if((ChannelTOF[0]/48)%2==0){z=1.75+DeltaZ[0];}
//if((ChannelTOF[0]/48)%2 == 1){z=1.75-DeltaZ[0];}
if((ChannelTOF[0]/48)%2==0){z=DeltaZ[0];}
if((ChannelTOF[0]/48)%2 == 1){z= -DeltaZ[0];}
Float_t w=tempo[0]- exp_time_pi[0];
h2dxdzt1_texp->Fill(DeltaX[0],z, w);
h2dxdzt1_texp_dummy->Fill(DeltaX[0],z);
if( TMath::Abs(DeltaZ[0])<1.75 && TMath::Abs(DeltaX[0])<1.25){ //sto selezionando che il pad matchato sia dove passa la traccia, poichè altrimenti nel grafico con d e delay time vi sarebbero degli effetti di bordo
Float_t t1=tempo[0];
ht1->Fill(t1);
ht1->GetXaxis()->SetTitle("t1(ps)");
//cout<<(ChannelTOF[0]/48)%2<<endl;
Float_t d;
if((ChannelTOF[0]/48)%2 == 0){
d=sqrt(DeltaX[0]*DeltaX[0]+(1.75+DeltaZ[0])*(1.75+DeltaZ[0])); //da quello che ho capito il pad 0 è quello in alto quindi ha punto d raccolta in alto
/*
if((ChannelTOF[0]/96)==((ChannelTOF[0]+48)/96)) //if fatto per capire quale sia quallo in alto e quale quello in basso poichè hanno una raccolta di carica differente
{
cout<<"ciao, io ,pad 0, sono quello sopra"<<endl;
}
*/
}
if((ChannelTOF[0]/48)%2 == 1) {
d=sqrt(DeltaX[0]*DeltaX[0]+(1.75-DeltaZ[0])*(1.75-DeltaZ[0])); //da quello che ho capito il pad 1 è quello in basso quindi ha punto d raccolta in basso
/*//if fatto per capire quale sia quallo in alto e quale quello in basso poichè hanno una raccolta di carica differente
if((ChannelTOF[0]/96)==((ChannelTOF[0]+48)/96))
{
cout<<"ciao, io ,pad 1, sono quello sopra"<<endl;
}
*/
}
Float_t res1 = DeltaX[0]*DeltaX[0] + DeltaZ[0]*DeltaZ[0];
//Float_t posx = (DeltaX[0])*(ChannelTOF[0]-ChannelTOF[1]);
// hdeltax->Fill(posx);
//hdeltax->GetXaxis()->SetTitle("posx (cm)");
//
// pxt->Fill(tempo[0], DeltaX[0]);
// pxt->GetXaxis()->SetTitle("t (cm)");
// pxt->GetYaxis()->SetTitle("dx (cm)");
// pzt->Fill(tempo[0], DeltaZ[0]);
// pzt->GetXaxis()->SetTitle("t(cm)");
// pzt->GetYaxis()->SetTitle("Dz1 (cm)");
hch->Fill(ChannelTOF[0]);
hch->GetXaxis()->SetTitle("ch");
Float_t tw1=tempo[0]- exp_time_pi[0];
ht1_texp->Fill(tw1);
ht1_texp->GetXaxis()->SetTitle("t_{1} - t_{exp #pi} (ps)");
//cerco correlazione tra TOT e delay time
h2t1_texp_TOT->Fill(TOT[0],tw1);
h2t1_texp_TOT->GetXaxis()->SetTitle("TOT ");
h2t1_texp_TOT->GetYaxis()->SetTitle("t_{1}-t_{exp #pi} (ps)");
hproft1_texp_TOT->Fill(TOT[0],tw1 ,1);
hproft1_texp_TOT->GetXaxis()->SetTitle("TOT");
hproft1_texp_TOT->GetYaxis()->SetTitle("t_{0}-t_{exp #pi} (ps)");
/////////////////////PROFILE 1
//riempio istogrammma, poi lo fitto fuori dal loop
// hprofx->Fill(DeltaX[0],tw1 ,1);
// hprofx->GetXaxis()->SetTitle("dx (cm)");
// hprofx->GetYaxis()->SetTitle("t_{1}-t_{exp #pi} (ps)");
//
// hprofz->Fill(DeltaZ[0],tw1 ,1);
// hprofz->GetXaxis()->SetTitle("dz (cm)");
// hprofz->GetYaxis()->SetTitle("t_{1}-t_{exp #pi} (ps)");
hprofd->Fill(d,tw1 ,1);
hprofd->GetXaxis()->SetTitle("d (cm)");
hprofd->GetYaxis()->SetTitle("t_{1}-t_{exp #pi} (ps)");
//}
}
}
}
}
}
}
h2dxdzt1_texp->Divide(h2dxdzt1_texp_dummy);
h2dxdzt1_texp->SetOption("LEGO2");
h2dxdzt1_texp->GetXaxis()->SetTitle("dx (cm)");
h2dxdzt1_texp->GetYaxis()->SetTitle("dz (cm)");
//Double_t par[0]=0;
//Double_t par[1]=0;
TF2 *myfunc=new TF2("myfunc"," [0] * sqrt(x*x+[1]*[1]*(1.75+y)*(1.75+y))+[2]", -1.25,1.25,-1.75,1.75);
myfunc->SetParameter(1,0.5);
h2dxdzt1_texp->Fit(myfunc,"R");
Double_t vel1, alfa;
vel1= pow(myfunc->GetParameter(0),-1);
alfa= myfunc->GetParameter(1);
cout<<"Ciao, io sono la velocità in 3d "<<vel1<<endl;
for(Int_t i=0;i<nentries;i++){
T->GetEntry(i);
for(Int_t ip=0;ip<ncluster;ip++){
tempo[ip] -= StartTime;
Int_t strip=ChannelTOF[0]/96;
if(kCal){
DeltaX[ip] -= hCalX->GetBinContent(strip+1);
DeltaZ[ip] -= hCalZ->GetBinContent(strip+1);
}
}
if(ncluster == 1) {
if(impulso_trasv>0.8 && impulso_trasv<1.){ // serve per gli exp time
if(TMath::Abs(tempo[0]-exp_time_pi[0])<800./* per avere circa 3 sigma che sia un pi*/ ){
if(TMath::Abs(DeltaX[0])<1.5){
if((ChannelTOF[0]/48)%2==0){z=DeltaZ[0];}
if((ChannelTOF[0]/48)%2==1){z= -DeltaZ[0];}
Float_t deff=sqrt(DeltaX[0]*DeltaX[0]+ alfa*alfa * (1.75+z)*(1.75+z)*(z>-1.75));
Float_t tw1tot=tempo[0]- exp_time_pi[0];
h2t1_texp_deff->Fill(deff,tw1tot);
h2t1_texp_deff->GetXaxis()->SetTitle("deff (cm)");
h2t1_texp_deff->GetYaxis()->SetTitle("delay time (ps)");
hprofdeff ->Fill(deff,tw1tot ,1);
hprofdeff->GetXaxis()->SetTitle("deff (cm)");
hprofdeff->GetYaxis()->SetTitle("t_{1}-t_{exp #pi} (ps)");
h2t1_deff_TOT->Fill(TOT[0],deff);
h2t1_deff_TOT->GetXaxis()->SetTitle("TOT (ps)");
h2t1_deff_TOT->GetYaxis()->SetTitle("deff (cm)");
h2t1_TOT_deff->Fill(deff, TOT[0]);
h2t1_TOT_deff->GetXaxis()->SetTitle("deff (cm)");
h2t1_TOT_deff->GetYaxis()->SetTitle("TOT (ps)");
}
}
}
}
}
TF1 *fs = new TF1("fs","gaus",-400.,400.);
h2t1_texp_deff->FitSlicesY(fs);
TH1D *h2t1_texp_deff_1 = (TH1D *) gDirectory->FindObject("h2t1_texp_deff_1");
h2t1_texp_deff_1->Draw("same");
//h2t1_texp_deff_2->Draw("same");
// TF1 *f1 = new TF1("f1","pol1",0., 2.15);
// h2t1_texp_deff_1->Fit("f1","R");
// Double_t vel2;
// vel2 = pow(f1->GetParameter(1),-1);
// cout<<"Ciao, io sono la velocità in 2d "<<vel2<<endl;
TF1 *f1 = new TF1("f1","[0]*TMath::Min(x,1.75)+[1]",0., 2.8); //Min(x,1.75) , l'1.75 è stato scelto guardando il fit, come meglio sembrava interploare. Per ora, per quanto ne so, è solo una coincidenza che coincida con pad z
h2t1_texp_deff_1->Fit(f1,"R");
Double_t p0,vel2, offset_tw;
p0=f1->GetParameter(0);
vel2= pow(p0,-1);
offset_tw=f1->GetParameter(1);
cout<<"Ciao, io sono la velocità in 2d "<<vel2<<endl;
for(Int_t i=0;i<nentries;i++){
T->GetEntry(i);
for(Int_t ip=0;ip<ncluster;ip++){
tempo[ip] -= StartTime;
Int_t strip=ChannelTOF[0]/96;
if(kCal){
DeltaX[ip] -= hCalX->GetBinContent(strip+1);
DeltaZ[ip] -= hCalZ->GetBinContent(strip+1);
}
}
if(ncluster == 1){
if(impulso_trasv>0.8 && impulso_trasv<1.){ // serve per gli exp time
if(TMath::Abs(tempo[0]-exp_time_pi[0])<800./* per avere circa 3 sigma che sia un pi*/ ){
if(TMath::Abs(DeltaX[0])<1.5){
if((ChannelTOF[0]/48)%2==0){z=DeltaZ[0];}
if((ChannelTOF[0]/48)%2==1){z= -DeltaZ[0];}
Float_t deff=sqrt(DeltaX[0]*DeltaX[0]+ alfa*alfa * (1.75+z)*(1.75+z)*(z>-1.75));
if(deff<2.8){
Float_t tw1tot=tempo[0]- exp_time_pi[0];
ht1_texptot->Fill(tw1tot);
ht1_texptot->GetXaxis()->SetTitle("t_{1} - t_{exp #pi} (ps)");
Float_t tw1corrtw=tw1tot-(offset_tw + p0 *TMath::Min(deff,Float_t(1.75)));//Min(x,1.75) , l'1.75 è stato scelto guardando il fit, come meglio sembrava interploare. Per ora, per quanto ne so, è solo una coincidenza che coincida con pad z
htcorrtw->Fill(tw1corrtw);
htcorrtw->GetXaxis()->SetTitle("t_corr_tw (ps)");
h2t1_texp_deff_tw->Fill(deff,tw1corrtw);
h2t1_texp_deff_tw->GetXaxis()->SetTitle("deff (cm)");
h2t1_texp_deff_tw->GetYaxis()->SetTitle("delay time corr_tw (ps)");
}
}
}
}
}
}
TF1 *fstw = new TF1("fstw","gaus",-400.,400.);
h2t1_texp_deff_tw->FitSlicesY(fstw);
TH1D *h2t1_texp_deff_tw_1 = (TH1D *) gDirectory->FindObject("h2t1_texp_deff_tw_1");
TH1D *h2t1_texp_deff_tw_2 = (TH1D *) gDirectory->FindObject("h2t1_texp_deff_tw_2");
h2t1_texp_deff_tw_1->Draw("same");
h2t1_texp_deff_tw_2->Draw("same");
// TF1 *f1 = new TF1("f1","pol1",-1.25,0.5);
// //hprofx->GetYaxis()->SetRangeUser(-40.,100.);
// hprofx->Fit("f1","R");
// Double_t offset_p1,x1_p1;
// offset_p1= f1->GetParameter(0);
// x1_p1= f1->GetParameter(1);
// for(Int_t i=0;i<nentries;i++)
// {
// T->GetEntry(i);
// for(Int_t ip=0;ip<ncluster;ip++)
// tempo[ip] -= StartTime;
// if(ncluster == 1)
// {
// if(impulso_trasv>0.8 && impulso_trasv<1.2) // serve per gli exp time
// {
// //if( TMath::Abs(DeltaZ[0])<1.75)
// //{
// if(TMath::Abs(tempo[0]-exp_time_pi[0])<800./* per avere circa 3 sigmca che sia un pi*/ )
// {
//
// //Float_t posx = (DeltaX[0])* dch;
// Float_t tw1=tempo[0]- exp_time_pi[0];
//
// Float_t tw1corr=tw1-(offset_p1 + x1_p1 *DeltaX[0]);
//
// hprofxcorr->Fill(DeltaX[0],tw1corr,1);
// hprofxcorr->GetXaxis()->SetTitle("Dx1 (cm)");
// hprofxcorr->GetYaxis()->SetTitle("t1_corr=t1-t_exp_pi corr(ps)");
//
// htbest->Fill(tw1corr);
// htbest->GetXaxis()->SetTitle("t_best=t1_corr(ps)");
//
// //}
// }
// }
// }
// }
//
// TF1 *f1c = new TF1("f1c","pol1",-1.25,0.5);
// hprofxcorr->Fit("f1c","R");
TFile *fo2 = new TFile("output_ist_tree_1hit.root","RECREATE");
hch->Write();
ht1->Write();
h2resxz1->Write();
hresx1->Write();
hresz1->Write();
hresdist1->Write();
//hdeltax->Write();
//pxt->Write();
//pzt->Write();
//hdeltach->Write();
ht1_texp->Write();
ht1_texptot->Write();
//hprofx->Write();
//hprofz->Write();
//hprofxcorr->Write();
//htbest->Write();
hprofd->Write();
h2dxdzt1_texp->Write();
//h2dxdzt1_texp_dummy->Write();
h2t1_texp_deff->Write();
h2t1_texp_deff_1->Write();
//h2t1_texp_deff_2->Write();
hprofdeff->Write();
htcorrtw->Write();
h2t1_texp_deff_tw->Write();
h2t1_texp_deff_tw_1->Write();
h2t1_texp_deff_tw_2->Write();
h2t1_texp_TOT->Write();
hproft1_texp_TOT->Write();
h2t1_deff_TOT->Write();
h2t1_TOT_deff->Write();
hx->Write();
hz->Write();
fo2->Close();
if(!kCal){
printf("write calibration\n");
fcal = new TFile("calibration.root","RECREATE");
hCalX->Write();
hCalZ->Write();
fcal->Close();
}
system("say Ehi you, I have done");
}
void extractFlowVZERO(Int_t icentr,const char *type,Int_t arm,Float_t pTh,Bool_t isMC,Int_t addbin){
LoadLib();
char name[100];
snprintf(name,100,"AnalysisResults%s.root",type);
if(!fo) fo = new TFile(name);
new TCanvas();
Int_t cMin[] = {0,5,10,20,30,40,50,60,70};
Int_t cMax[] = {5,10,20,30,40,50,60,70,80};
if(kNUOcorr){ // Compute correction for NUO in TOF
compareTPCTOF(icentr,0,arm,pTh,addbin);
// compareTPCTOF(icentr,1,arm,pTh,addbin);
// compareTPCTOF(icentr,2,arm,pTh,addbin);
// compareTPCTOF(icentr,3,arm,pTh,addbin);
// compareTPCTOF(icentr,4,arm,pTh,addbin);
}
TProfile *pAll;
pAll=extractFlowVZEROsingle(icentr,0,arm,0,pTh,addbin,"all",0,1);
pAll->SetMarkerStyle(24);
TProfile *pPiTOF,*pPiTPC,*pPiTPC2;
pPiTOF=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTOF",1,1);
pPiTPC=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTPC",0,0);
pPiTPC2=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTPC2",2,2);
pPiTPC->Add(pPiTPC2);
TH1D *hPi = pPiTOF->ProjectionX("hPi");
hPi->SetLineColor(4);
hPi->SetMarkerColor(4);
hPi->SetMarkerStyle(20);
for(Int_t i=1;i <=hPi->GetNbinsX();i++){
Float_t x = hPi->GetBinCenter(i);
if(x < 0.2){
hPi->SetBinContent(i,0);
hPi->SetBinError(i,0);
}
else if(x < 0.5){
hPi->SetBinContent(i,pPiTPC->GetBinContent(i));
hPi->SetBinError(i,pPiTPC->GetBinError(i));
}
else{
if(kNUOcorr){
hPi->SetBinContent(i,pPiTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
hPi->SetBinError(i,pPiTOF->GetBinError(i));
}
else{
hPi->SetBinContent(i,pPiTOF->GetBinContent(i));
hPi->SetBinError(i,pPiTOF->GetBinError(i));
}
}
}
TProfile *pElTOF,*pElTPC,*pElTPC2;
pElTOF=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTOF",1,1);
pElTPC=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTPC",0,0);
pElTPC2=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTPC2",2,2);
pElTPC->Add(pElTPC2);
TH1D *hEl = pElTOF->ProjectionX("hEl");
hEl->SetLineColor(6);
hEl->SetMarkerColor(6);
hEl->SetMarkerStyle(20);
for(Int_t i=1;i <=hEl->GetNbinsX();i++){
Float_t x = hEl->GetBinCenter(i);
if(x < 0.2){
hEl->SetBinContent(i,0);
hEl->SetBinError(i,0);
}
else if(x < 0.3){
hEl->SetBinContent(i,pElTPC->GetBinContent(i));
hEl->SetBinError(i,pElTPC->GetBinError(i));
}
else{
if(kNUOcorr){
hEl->SetBinContent(i,pElTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
hEl->SetBinError(i,pElTOF->GetBinError(i));
}
else{
hEl->SetBinContent(i,pElTOF->GetBinContent(i));
hEl->SetBinError(i,pElTOF->GetBinError(i));
}
}
}
TProfile *pKTOF,*pKTPC,*pKTPC2;
pKTOF=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTOF",1,1);
pKTPC=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTPC",0,0);
pKTPC2=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTPC2",2,2);
pKTPC->Add(pKTPC2);
TH1D *hK = pKTOF->ProjectionX("hKa");
hK->SetLineColor(1);
hK->SetMarkerColor(1);
hK->SetMarkerStyle(21);
for(Int_t i=1;i <=hK->GetNbinsX();i++){
Float_t x = hK->GetBinCenter(i);
if(x < 0.25){
hK->SetBinContent(i,0);
hK->SetBinError(i,0);
}
else if(x < 0.45){
hK->SetBinContent(i,pKTPC->GetBinContent(i));
hK->SetBinError(i,pKTPC->GetBinError(i));
}
else{
if(kNUOcorr){
hK->SetBinContent(i,pKTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
hK->SetBinError(i,pKTOF->GetBinError(i));
}
else{
hK->SetBinContent(i,pKTOF->GetBinContent(i));
hK->SetBinError(i,pKTOF->GetBinError(i));
}
}
}
TProfile *pPrTOF,*pPrTOF2,*pPrTPC,*pPrTPC2;
pPrTOF=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTOF",1,1,-1,-1);
pPrTOF2=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTOF2",1,1,-1,1);
pPrTPC=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTPC",0,0,-1,-1);
pPrTPC2=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTPC2",2,2,-1,-1);
pPrTPC->Add(pPrTPC2);
TH1D *hPr = pPrTOF->ProjectionX("hPr");
hPr->SetLineColor(2);
hPr->SetMarkerColor(2);
hPr->SetMarkerStyle(22);
for(Int_t i=1;i <=hPr->GetNbinsX();i++){
Float_t x = hPr->GetBinCenter(i);
if(x < 0.3){
hPr->SetBinContent(i,0);
hPr->SetBinError(i,0);
}
else if(x < 1.0){
hPr->SetBinContent(i,pPrTPC->GetBinContent(i));
hPr->SetBinError(i,pPrTPC->GetBinError(i));
}
else{
if(x < 3){
if(kNUOcorr){
hPr->SetBinContent(i,pPrTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i));
hPr->SetBinError(i,pPrTOF->GetBinError(i));
}
else{
hPr->SetBinContent(i,pPrTOF->GetBinContent(i));
hPr->SetBinError(i,pPrTOF->GetBinError(i));
}
}
else{
if(kNUOcorr){
hPr->SetBinContent(i,pPrTOF2->GetBinContent(i) + hNUO[0]->GetBinContent(i));
hPr->SetBinError(i,pPrTOF2->GetBinError(i));
}
else{
hPr->SetBinContent(i,pPrTOF2->GetBinContent(i));
hPr->SetBinError(i,pPrTOF2->GetBinError(i));
}
}
}
}
pAll->Draw();
hPi->Draw("SAME");
hK->Draw("SAME");
hPr->Draw("SAME");
char name[100];
// PID correction
if(kPIDcorr){
TFile *fPidTOF = new TFile("$ALICE_ROOT/PWGCF/FLOW/other/BayesianPIDcontTPCTOF.root");
TFile *fPidTPC = new TFile("$ALICE_ROOT/PWGCF/FLOW/other/BayesianPIDcontTPC.root");
// pi histos
sprintf(name,"Pi_IDas_Picentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiPi=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Pi_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiEl=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Pi_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiKa=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Pi_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiPr=(TH1D *) fPidTOF->Get(name);
TH1D *hPidAll = new TH1D(*hPidPiPi);
hPidAll->Add(hPidPiKa);
hPidAll->Add(hPidPiPr);
hPidAll->Add(hPidPiEl);
hPidPiPi->Divide(hPidAll);
hPidPiKa->Divide(hPidAll);
hPidPiPr->Divide(hPidAll);
hPidPiEl->Divide(hPidAll);
sprintf(name,"Pi_IDas_Picentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiPiTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Pi_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiElTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Pi_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiKaTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Pi_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPiPrTPC=(TH1D *) fPidTPC->Get(name);
hPidAll->Reset();
hPidAll->Add(hPidPiPiTPC);
hPidAll->Add(hPidPiKaTPC);
hPidAll->Add(hPidPiPrTPC);
hPidAll->Add(hPidPiElTPC);
hPidPiPiTPC->Divide(hPidAll);
hPidPiKaTPC->Divide(hPidAll);
hPidPiPrTPC->Divide(hPidAll);
hPidPiElTPC->Divide(hPidAll);
// K histos
sprintf(name,"Ka_IDas_Picentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaPi=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Ka_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaEl=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Ka_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaKa=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Ka_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaPr=(TH1D *) fPidTOF->Get(name);
hPidAll->Reset();
hPidAll->Add(hPidKaPi);
hPidAll->Add(hPidKaKa);
hPidAll->Add(hPidKaPr);
hPidAll->Add(hPidKaEl);
hPidKaPi->Divide(hPidAll);
hPidKaKa->Divide(hPidAll);
hPidKaPr->Divide(hPidAll);
hPidKaEl->Divide(hPidAll);
sprintf(name,"Ka_IDas_Picentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaPiTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Ka_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaElTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Ka_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaKaTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Ka_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidKaPrTPC=(TH1D *) fPidTPC->Get(name);
hPidAll->Reset();
hPidAll->Add(hPidKaPiTPC);
hPidAll->Add(hPidKaKaTPC);
hPidAll->Add(hPidKaPrTPC);
hPidAll->Add(hPidKaElTPC);
hPidKaPiTPC->Divide(hPidAll);
hPidKaKaTPC->Divide(hPidAll);
hPidKaPrTPC->Divide(hPidAll);
hPidKaElTPC->Divide(hPidAll);
// pr histos
sprintf(name,"Pr_IDas_Picentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrPi=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Pr_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrEl=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Pr_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrKa=(TH1D *) fPidTOF->Get(name);
sprintf(name,"Pr_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrPr=(TH1D *) fPidTOF->Get(name);
hPidAll->Reset();
hPidAll->Add(hPidPrPi);
hPidAll->Add(hPidPrKa);
hPidAll->Add(hPidPrPr);
hPidAll->Add(hPidPrEl);
hPidPrPi->Divide(hPidAll);
hPidPrKa->Divide(hPidAll);
hPidPrPr->Divide(hPidAll);
hPidPrEl->Divide(hPidAll);
sprintf(name,"Pr_IDas_Picentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrPiTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Pr_IDas_Elcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrElTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Pr_IDas_Kacentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrKaTPC=(TH1D *) fPidTPC->Get(name);
sprintf(name,"Pr_IDas_Prcentr%i_pth%4.2f",icentr,pTh);
TH1D *hPidPrPrTPC=(TH1D *) fPidTPC->Get(name);
hPidAll->Reset();
hPidAll->Add(hPidPrPiTPC);
hPidAll->Add(hPidPrKaTPC);
hPidAll->Add(hPidPrPrTPC);
hPidAll->Add(hPidPrElTPC);
hPidPrPiTPC->Divide(hPidAll);
hPidPrKaTPC->Divide(hPidAll);
hPidPrPrTPC->Divide(hPidAll);
hPidPrElTPC->Divide(hPidAll);
for(Int_t k=1;k <=hPi->GetNbinsX();k++){
Float_t pt = hPi->GetBinCenter(k);
Float_t xPi=hPi->GetBinContent(k)*hPidPiPi->Interpolate(pt) + hK->GetBinContent(k)*hPidPiKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidPiPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidPiEl->Interpolate(pt);
if(pt < 0.5)
xPi=hPi->GetBinContent(k)*hPidPiPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidPiKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidPiPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidPiElTPC->Interpolate(pt);
Float_t xKa=hPi->GetBinContent(k)*hPidKaPi->Interpolate(pt) + hK->GetBinContent(k)*hPidKaKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidKaPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidKaEl->Interpolate(pt);
if(pt < 0.45)
xKa=hPi->GetBinContent(k)*hPidKaPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidKaKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidKaPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidKaElTPC->Interpolate(pt);
Float_t xPr=hPi->GetBinContent(k)*hPidPrPi->Interpolate(pt) + hK->GetBinContent(k)*hPidPrKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidPrPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidPrEl->Interpolate(pt);
if(pt < 1)
xPr=hPi->GetBinContent(k)*hPidPrPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidPrKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidPrPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidPrElTPC->Interpolate(pt);
hPi->SetBinContent(k,hPi->GetBinContent(k)*2 - xPi);
hK->SetBinContent(k,hK->GetBinContent(k)*2 - xKa);
hPr->SetBinContent(k,hPr->GetBinContent(k)*2 - xPr);
}
}
// antiproton Feed down
TProfile *pFromLambda = extractFlowVZEROsingle(icentr,11,arm,0,pTh,addbin,"pFromLambda",1,1);
TProfile *piFromK = extractFlowVZEROsingle(icentr,12,arm,0,pTh,addbin,"piFromK",1,1,1,1);
TProfile *pFromLambda2 = extractFlowVZEROsingle(icentr,11,arm,0,0.6,addbin,"pFromLambdanoPID",0,1);
TProfile *piFromK2 = extractFlowVZEROsingle(icentr,12,arm,0,0.6,addbin,"piFromKnoPID",0,1);
TProfile *piFromK3 = extractFlowVZEROsingle(icentr,12,arm,0,0.6,addbin,"piFromKnoPIDtof",1,1);
TH1D *hFeedSyst = NULL;
if(kFEEDcorr){
hFeedSyst = new TH1D(*hPr);
hFeedSyst->SetName("hFeedSyst");
hFeedSyst->Reset();
for(Int_t k=1;k <=hPr->GetNbinsX();k++){
Float_t contam = 3.23174e-01 * TMath::Exp(- 9.46743e-01 * hPr->GetBinCenter(k));
Float_t corr = contam * pFromLambda->GetBinContent(k)/(1-contam);
Float_t corrErr = contam * pFromLambda->GetBinError(k)/(1-contam);
Float_t value = hPr->GetBinContent(k)/(1-contam) - corr;
Float_t valueErr = hPr->GetBinError(k)/(1-contam);
hFeedSyst->SetBinContent(k,hPr->GetBinContent(k) - value);
hFeedSyst->SetBinContent(k,sqrt(corrErr*corrErr + valueErr*valueErr - hPr->GetBinError(k)*hPr->GetBinError(k)));
hPr->SetBinContent(k,value);
hPr->SetBinError(k,sqrt(corrErr*corrErr + valueErr*valueErr));
}
hFeedSyst->Divide(hPr);
}
// write output
snprintf(name,100,"results%03i-%03iv%i_pTh%3.1f%s.root",cMin[icentr],cMax[icentr+addbin],arm,pTh,type);
TFile *fout = new TFile(name,"RECREATE");
pAll->ProjectionX()->Write();
hPi->Write();
hK->Write();
hPr->Write();
if(isMC){
TH1D *pTmp = extractFlowVZEROsingle(icentr,0,arm,1,pTh,addbin,"allMC",1,1,-1,1)->ProjectionX();
pTmp->SetLineColor(6);
pTmp->SetMarkerColor(6);
pTmp->SetMarkerStyle(24);
pTmp->Write();
pTmp = extractFlowVZEROsingle(icentr,1,arm,1,pTh,addbin,"piMC",1,1,-1,1)->ProjectionX();
pTmp->SetLineColor(4);
pTmp->SetMarkerColor(4);
pTmp->SetMarkerStyle(24);
pTmp->Write();
pTmp = extractFlowVZEROsingle(icentr,2,arm,1,pTh,addbin,"kaMC",1,1,-1,1)->ProjectionX();
pTmp->SetLineColor(1);
pTmp->SetMarkerColor(1);
pTmp->SetMarkerStyle(25);
pTmp->Write();
pTmp = extractFlowVZEROsingle(icentr,3,arm,1,pTh,addbin,"prMC",1,1,-1,-1)->ProjectionX();
pTmp->SetLineColor(2);
pTmp->SetMarkerColor(2);
pTmp->SetMarkerStyle(26);
pTmp->Write();
}
extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kProf")->Write();
extractFlowVZEROsingle(icentr,9,arm,0,pTh,addbin,"ks",0,1,1,1)->Write();
extractFlowVZEROsingle(icentr,9,arm,0,pTh,addbin,"ksMy",0,1,-1,-1)->Write();
extractFlowVZEROsingle(icentr,10,arm,0,pTh,addbin,"lambda")->Write();
pFromLambda->Write();
piFromK->Write();
pFromLambda2->Write();
piFromK2->Write();
piFromK3->Write();
if(hFeedSyst) hFeedSyst->Write();
fout->Close();
}
void DoEvolutions( const TString &sim, Int_t time, Int_t Nbins=1, const TString &options="") {
#ifdef __CINT__
gSystem->Load("libptools.so");
#endif
PGlobals::Initialize();
// Palettes!
gROOT->Macro("PPalettes.C");
TString opt = options;
// cout << "options = " << opt << endl;
// Load PData
PData *pData = PData::Get(sim.Data());
pData->LoadFileNames(time);
if(!pData->IsInit()) return;
Bool_t CYL = kFALSE;
if(sim.Contains("cyl")) { CYL = kTRUE; opt += "cyl"; }
Bool_t ThreeD = kFALSE;
if(sim.Contains("3D")) ThreeD = kTRUE;
// Some plasma constants
Double_t n0 = pData->GetPlasmaDensity();
Double_t kp = pData->GetPlasmaK();
Double_t skindepth = 1.0;
if(kp!=0.0) skindepth = 1/kp;
Double_t E0 = pData->GetPlasmaE0();
// Some initial beam properties:
Float_t Ebeam = pData->GetBeamEnergy() * PUnits::MeV;
Float_t gamma = pData->GetBeamGamma();
Float_t vbeam = pData->GetBeamVelocity();
Double_t rms0 = pData->GetBeamRmsY() * kp;
if(CYL) rms0 = pData->GetBeamRmsR() * kp;
// Time in OU
Float_t Time = pData->GetRealTime();
// z start of the plasma in normalized units.
Float_t zStartPlasma = pData->GetPlasmaStart() * kp;
// z start of the beam in normalized units.
Float_t zStartBeam = pData->GetBeamStart() * kp;
if(opt.Contains("center")) {
Time -= zStartPlasma;
if(opt.Contains("comov")) // Centers on the head of the beam.
Time += zStartBeam;
}
// Beam charge 2D and 1D histogram (on-axis)
// ------------------------------------------------------------------
TH2F *hDen2D = NULL;
if(pData->GetChargeFileName(1)) {
char hName[24];
sprintf(hName,"hDen2D");
hDen2D = (TH2F*) gROOT->FindObject(hName);
if(hDen2D) { delete hDen2D; hDen2D = NULL; }
if(!ThreeD)
hDen2D = pData->GetCharge(1,opt);
else
hDen2D = pData->GetCharge2DSliceZY(1,-1,1,opt+"avg");
hDen2D->SetName(hName);
hDen2D->GetXaxis()->CenterTitle();
hDen2D->GetYaxis()->CenterTitle();
hDen2D->GetZaxis()->CenterTitle();
if(opt.Contains("comov"))
hDen2D->GetXaxis()->SetTitle("k_{p}#zeta");
else
hDen2D->GetXaxis()->SetTitle("k_{p}z");
if(CYL)
hDen2D->GetYaxis()->SetTitle("k_{p}r");
else
hDen2D->GetYaxis()->SetTitle("k_{p}y");
hDen2D->GetZaxis()->SetTitle("n_{b}/n_{0}");
}
// Define ranges from the charge 2D histogram:
// Binning for 2D histograms:
// We get this values from the 2D density histogram.
Int_t x1Nbin = hDen2D->GetNbinsX();
Float_t x1Range = (hDen2D->GetXaxis()->GetXmax() - hDen2D->GetXaxis()->GetXmin());
Float_t x1Mid = (hDen2D->GetXaxis()->GetXmax() + hDen2D->GetXaxis()->GetXmin())/2.;
Float_t x1Min = hDen2D->GetXaxis()->GetXmin();
Float_t x1Max = hDen2D->GetXaxis()->GetXmax();
Int_t x2Nbin = hDen2D->GetNbinsY();
Float_t x2Range = (hDen2D->GetYaxis()->GetXmax() - hDen2D->GetYaxis()->GetXmin());
Float_t x2Mid = (hDen2D->GetYaxis()->GetXmax() + hDen2D->GetYaxis()->GetXmin())/2.;
Float_t x2Min = x2Mid - x2Range/2;
Float_t x2Max = x2Mid + x2Range/2;
if(Nbins==0) {
Nbins = TMath::Nint(rms0 / hDen2D->GetYaxis()->GetBinWidth(1)) ;
// cout << Form(" Rms0 = %6.2f Dx = %6.2f Nbins = %4i .",
// rms0, hDen2D->GetYaxis()->GetBinWidth(1), Nbins) << endl;
}
// Slice width limits.
Int_t FirstyBin = 0;
Int_t LastyBin = 0;
if(!CYL) {
FirstyBin = hDen2D->GetNbinsY()/2 + 1 - Nbins;
LastyBin = hDen2D->GetNbinsY()/2 + Nbins;
} else {
FirstyBin = 1;
LastyBin = Nbins;
}
// OUTPUT ROOT FILE WITH THE PLOTS:
TString filename = Form("./%s/Plots/Evolutions/Evolutions-%s.root",sim.Data(),sim.Data());
TFile * ifile = (TFile*) gROOT->GetListOfFiles()->FindObject(filename);
// if doesn't exist the directory should be created
if (!ifile) {
TString f = filename;
TString dir2 = f.Remove( f.Last( '/' ), f.Length() - f.Last( '/' ) );
TString dir1 = f.Remove( f.Last( '/' ), f.Length() - f.Last( '/' ) );
gSystem->mkdir( dir1 );
gSystem->mkdir( dir2 );
ifile = new TFile(filename,"UPDATE");
}
// Charge 1D histogram on axis
TH1F *hDen1D = NULL;
if(pData->GetChargeFileName(1)) {
TString opth1 = opt;
opth1 += "avg";
char hName[24];
sprintf(hName,"hDen1D");
hDen1D = (TH1F*) gROOT->FindObject(hName);
if(hDen1D) delete hDen1D;
if(ThreeD) {
hDen1D = pData->GetH1SliceZ3D(pData->GetChargeFileName(1)->c_str(),"charge",-1,Nbins,-1,Nbins,opth1.Data());
} else if(CYL) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0).
hDen1D = pData->GetH1SliceZ(pData->GetChargeFileName(1)->c_str(),"charge",1,Nbins,opth1.Data());
} else { // 2D cartesian
hDen1D = pData->GetH1SliceZ(pData->GetChargeFileName(1)->c_str(),"charge",-1,Nbins,opth1.Data());
}
hDen1D->SetName(hName);
if(opt.Contains("comov"))
hDen1D->GetXaxis()->SetTitle("k_{p}#zeta");
else
hDen1D->GetXaxis()->SetTitle("k_{p}z");
hDen1D->GetYaxis()->SetTitle("n_{b}/n_{0}");
}
// On-axis beam density vs \zeta vs time! _________________________________
TH2F *hDen1DvsTime = NULL;
if(hDen1D) {
char hName[24];
sprintf(hName,"hDen1DvsTime");
TH2F *hDen1DvsTimeOld = (TH2F*) ifile->Get(hName);
Int_t nBins = 1;
Float_t edge0 = Time-0.5;
Float_t edge1 = Time+0.5;
if(hDen1DvsTimeOld!=NULL) {
nBins = hDen1DvsTimeOld->GetNbinsX()+1;
Float_t binwidth = (Time - hDen1DvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1);
edge0 = hDen1DvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.;
edge1 = Time + binwidth/2.;
}
hDen1DvsTime = new TH2F("temp","",nBins,edge0,edge1,
hDen1D->GetNbinsX(),
hDen1D->GetBinLowEdge(1),
hDen1D->GetBinLowEdge(hDen1D->GetNbinsX()+1));
for(Int_t ix=1;ix<hDen1DvsTime->GetNbinsX();ix++) {
for(Int_t iy=1;iy<hDen1DvsTime->GetNbinsY();iy++) {
hDen1DvsTime->SetBinContent(ix,iy,hDen1DvsTimeOld->GetBinContent(ix,iy));
}
}
delete hDen1DvsTimeOld;
// Fill last bin with the newest values.
for(Int_t iy=1;iy<=hDen1D->GetNbinsX();iy++) {
hDen1DvsTime->SetBinContent(nBins,iy,hDen1D->GetBinContent(iy));
}
hDen1DvsTime->GetZaxis()->SetTitle("n_{b}/n_{0}");
hDen1DvsTime->GetYaxis()->SetTitle("k_{p}#zeta");
hDen1DvsTime->GetXaxis()->SetTitle("k_{p}z");
hDen1DvsTime->GetZaxis()->CenterTitle();
hDen1DvsTime->GetYaxis()->CenterTitle();
hDen1DvsTime->GetXaxis()->CenterTitle();
hDen1DvsTime->SetName(hName);
// Change the range of z axis
Float_t Denmax = hDen1DvsTime->GetMaximum();
hDen1DvsTime->GetZaxis()->SetRangeUser(0,Denmax);
hDen1DvsTime->Write(hName,TObject::kOverwrite);
}
// RMS (vs z) of the beam's charge distribution:
TProfile *hDen2Dprof = NULL;
TH1F *hRms = NULL;
Double_t axisPos = x2Mid;
if(hDen2D) {
TString pname = hDen2D->GetName();
pname += "_pfx";
hDen2Dprof = (TProfile*) gROOT->FindObject(pname.Data());
if(hDen2Dprof) { delete hDen2Dprof; hDen2Dprof = NULL; }
hDen2Dprof = hDen2D->ProfileX("_pfx",1,-1,"s");
hRms = (TH1F*) gROOT->FindObject("hRms");
if(hRms) delete hRms;
hRms = new TH1F("hRms","",x1Nbin,x1Min,x1Max);
if(CYL) axisPos = 0.0;
for(Int_t j=0;j<hRms->GetNbinsX();j++) {
Double_t rms = 0;
Double_t total = 0;
for(Int_t k=1;k<=x2Nbin;k++) {
Double_t value = hDen2D->GetBinContent(j,k);
Double_t radius = hDen2D->GetYaxis()->GetBinCenter(k) - axisPos;
if(CYL) {
rms += radius*radius*radius*value;
total += radius*value;
} else {
rms += radius*radius*value;
total += value;
}
// cout << Form(" (%i,%i) -> radius = %7.4f , density = %7.4f",j,k,radius,value) << endl;
}
rms /= total;
rms = sqrt(rms);
hRms->SetBinContent(j,rms);
}
hRms->GetXaxis()->SetTitle("k_{p}z");
if(opt.Contains("comov"))
hRms->GetXaxis()->SetTitle("k_{p}#zeta");
hRms->GetYaxis()->SetTitle("k_{p}#LTr#GT_{rms}");
}
// Transverse charge RMS vs \zeta vs time! _________________________________
TH2F *hRmsvsTime = NULL;
if(hRms) {
char hName[24];
sprintf(hName,"hRmsvsTime");
TH2F *hRmsvsTimeOld = (TH2F*) ifile->Get(hName);
Int_t nBins = 1;
Float_t edge0 = Time-0.5;
Float_t edge1 = Time+0.5;
if(hRmsvsTimeOld!=NULL) {
nBins = hRmsvsTimeOld->GetNbinsX()+1;
Float_t binwidth = (Time - hRmsvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1);
edge0 = hRmsvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.;
edge1 = Time + binwidth/2.;
}
hRmsvsTime = new TH2F("temp","",nBins,edge0,edge1,
hRms->GetNbinsX(),
hRms->GetBinLowEdge(1),
hRms->GetBinLowEdge(hRms->GetNbinsX()+1));
for(Int_t ix=1;ix<hRmsvsTime->GetNbinsX();ix++) {
for(Int_t iy=1;iy<hRmsvsTime->GetNbinsY();iy++) {
hRmsvsTime->SetBinContent(ix,iy,hRmsvsTimeOld->GetBinContent(ix,iy));
}
}
delete hRmsvsTimeOld;
// Fill last bin with the newest values.
for(Int_t iy=1;iy<=hRms->GetNbinsX();iy++) {
hRmsvsTime->SetBinContent(nBins,iy,hRms->GetBinContent(iy));
}
hRmsvsTime->GetZaxis()->SetTitle("#LTr#GT_{rms}");
hRmsvsTime->GetYaxis()->SetTitle("k_{p}#zeta");
hRmsvsTime->GetXaxis()->SetTitle("k_{p}z");
hRmsvsTime->GetZaxis()->CenterTitle();
hRmsvsTime->GetYaxis()->CenterTitle();
hRmsvsTime->GetXaxis()->CenterTitle();
hRmsvsTime->SetName(hName);
// Change the range of z axis
Float_t Rmsmax = hRmsvsTime->GetMaximum();
hRmsvsTime->GetZaxis()->SetRangeUser(0,Rmsmax);
hRmsvsTime->Write(hName,TObject::kOverwrite);
}
// INTEGRATED Beam's Charge:
// Total charge vs time :
TGraph *gQvsTime = NULL;
if(hDen2D) {
Double_t Q = 0;
for(Int_t i=1;i<=x1Nbin;i++) {
for(Int_t j=1;j<=x2Nbin;j++) {
Double_t value = hDen2D->GetBinContent(i,j);
if(CYL) {
Double_t radius = hDen2D->GetYaxis()->GetBinCenter(j);
Q += radius * value;
// cout << Form(" (%i,%i) -> radius = %7.4f , value = %7.4f",i,j,radius,value) << endl;
} else {
Q += value;
}
}
}
Double_t xbinsize = hDen2D->GetXaxis()->GetBinWidth(1);
Double_t ybinsize = hDen2D->GetYaxis()->GetBinWidth(1);
Q *= xbinsize * ybinsize;
if(!CYL && !ThreeD) {
Q *= TMath::Sqrt(2*TMath::Pi()) * rms0;
} else if(CYL) {
Q *= 2*TMath::Pi();
}
if(opt.Contains("units")) {
Double_t dV = skindepth * skindepth * skindepth;
Q *= n0 * dV;
Q *= (PConst::ElectronCharge/PUnits::picocoulomb);
cout << Form(" Integrated charge = %8i pC", TMath::Nint(Q)) << endl;
} else {
cout << Form(" Integrated charge = %8.4f n0 * kp^-3",Q) << endl;
}
Int_t nPoints = 0;
char gName[32];
sprintf(gName,"gQvsTime");
gQvsTime = (TGraph*) ifile->Get(gName);
if(gQvsTime==NULL) {
gQvsTime = new TGraph();
gQvsTime->SetName(gName);
nPoints = 0;
// Some cosmetics at creation time:
gQvsTime->SetLineWidth(3);
gQvsTime->SetLineColor(PGlobals::fieldLine);
gQvsTime->SetMarkerStyle(20);
gQvsTime->SetMarkerSize(0.4);
gQvsTime->SetMarkerColor(PGlobals::fieldLine);
gQvsTime->GetYaxis()->SetTitle("charge [n_{0}/k_{p}^{3}]");
gQvsTime->GetXaxis()->SetTitle("k_{p}z");
} else {
nPoints = gQvsTime->GetN();
}
gQvsTime->Set(nPoints+1);
gQvsTime->SetPoint(nPoints,Time,Q);
gQvsTime->Write(gName,TObject::kOverwrite);
}
// ------------------------------------------------------------------------------------
// Longitudinal phasespace
Int_t gNbin = 100;
// Float_t gMin = 80;
// Float_t gMax = 120;
Float_t gMin = 43.07 - 1.2;
Float_t gMax = 43.07 + 1.2;
TH2F *hGvsZ = NULL;
if(pData->GetRawFileName(1)) {
char hName[24];
sprintf(hName,"hGvsZ");
hGvsZ = (TH2F*) gROOT->FindObject(hName);
if(hGvsZ) { delete hGvsZ; hGvsZ = NULL; }
hGvsZ = new TH2F(hName,"",x1Nbin,x1Min,x1Max,gNbin,gMin,gMax);
pData->GetH2Raw(pData->GetRawFileName(1)->c_str(),"x1","gamma",hGvsZ,opt);
hGvsZ->GetXaxis()->CenterTitle();
hGvsZ->GetYaxis()->CenterTitle();
hGvsZ->GetZaxis()->CenterTitle();
hGvsZ->GetYaxis()->SetTitle("#gamma");
if(opt.Contains("comov")) {
hGvsZ->GetXaxis()->SetTitle("k_{p}#zeta");
hGvsZ->GetZaxis()->SetTitle("dN/d#zetad#gamma [a.u.]");
} else {
hGvsZ->GetXaxis()->SetTitle("k_{p}z");
hGvsZ->GetZaxis()->SetTitle("dN/dzd#gamma [a.u.]");
}
} else {
cout << Form("--> No RAW data file is present for species 1") << endl;
}
TH2F *hGvsTime = NULL;
TProfile *hGvsZprof = NULL;
TGraphErrors *gGvsZ = NULL;
if(hGvsZ) {
TString pname = hGvsZ->GetName();
pname += "_pfx";
hGvsZprof = (TProfile*) gROOT->FindObject(pname.Data());
if(hGvsZprof) delete hGvsZprof;
hGvsZprof = hGvsZ->ProfileX("_pfx",1,-1,"s");
gGvsZ = (TGraphErrors*) gROOT->FindObject("gGvsZ");
if(gGvsZ) delete gGvsZ;
Int_t Npoints = hGvsZprof->GetNbinsX();
Double_t *x = new Double_t[Npoints];
Double_t *y = new Double_t[Npoints];
Double_t *ex = new Double_t[Npoints];
Double_t *ey = new Double_t[Npoints];
for(Int_t j=0;j<Npoints;j++) {
x[j] = hGvsZprof->GetBinCenter(j);
y[j] = hGvsZprof->GetBinContent(j);
ex[j] = 0;
ey[j] = hGvsZprof->GetBinError(j);
}
gGvsZ = new TGraphErrors(Npoints,x,y,ex,ey);
gGvsZ->SetName("gGvsZ");
// PGlobals::SetH1Style((TH1*)gGvsZ,1);
PGlobals::SetGraphStyle(gGvsZ,1);
if(opt.Contains("comov"))
gGvsZ->GetXaxis()->SetTitle("k_{p}#zeta");
else
gGvsZ->GetXaxis()->SetTitle("k_{p}z");
gGvsZ->GetYaxis()->SetTitle("#LT#gamma#GT [MeV]");
char hName[24];
sprintf(hName,"hGvsTime");
TH2F *hGvsTimeOld = (TH2F*) ifile->Get(hName);
Int_t nBins = 1;
Float_t edge0 = Time-0.5;
Float_t edge1 = Time+0.5;
if(hGvsTimeOld!=NULL) {
nBins = hGvsTimeOld->GetNbinsX()+1;
Float_t binwidth = (Time - hGvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1);
edge0 = hGvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.;
edge1 = Time + binwidth/2.;
}
hGvsTime = new TH2F("temp","",nBins,edge0,edge1,
hGvsZprof->GetNbinsX(),
hGvsZprof->GetBinLowEdge(1),
hGvsZprof->GetBinLowEdge(hGvsZprof->GetNbinsX()+1));
for(Int_t ix=1;ix<hGvsTime->GetNbinsX();ix++) {
for(Int_t iy=1;iy<hGvsTime->GetNbinsY();iy++) {
hGvsTime->SetBinContent(ix,iy,hGvsTimeOld->GetBinContent(ix,iy));
}
}
delete hGvsTimeOld;
// Fill last bin with the newest values.
for(Int_t iy=1;iy<=hGvsZprof->GetNbinsX();iy++) {
hGvsTime->SetBinContent(nBins,iy,hGvsZprof->GetBinContent(iy));
}
hGvsTime->GetZaxis()->SetTitle("#LT#gamma#GT");
hGvsTime->GetYaxis()->SetTitle("k_{p}#zeta");
hGvsTime->GetXaxis()->SetTitle("k_{p}z");
hGvsTime->GetZaxis()->CenterTitle();
hGvsTime->GetYaxis()->CenterTitle();
hGvsTime->GetXaxis()->CenterTitle();
hGvsTime->SetName(hName);
// Change the range of z axis
Float_t Gmax = hGvsTime->GetMaximum();
Float_t Gmin = hGvsTime->GetMinimum();
hGvsTime->GetZaxis()->SetRangeUser(Gmin,Gmax);
hGvsTime->Write(hName,TObject::kOverwrite);
}
// ---------------------------------------------------------------------------------
// EM fields on - axis :
TString opth1 = opt;
opth1 += "avg";
// Get electric fields
const Int_t Nfields = 2;
TH1F **hE1D = new TH1F*[Nfields];
for(Int_t i=0;i<Nfields;i++) {
hE1D[i] = NULL;
if(!pData->GetEfieldFileName(i))
continue;
char nam[3]; sprintf(nam,"e%i",i+1);
if(ThreeD) {
if(i==0)
hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,-1,Nbins,opth1.Data());
else
hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,-Nbins,Nbins,opth1.Data());
} else if(CYL) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0).
if(i==0)
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,1,Nbins,opth1.Data());
else
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,1,Nbins,opth1.Data());
} else { // 2D cartesian
if(i==0)
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,opth1.Data());
else
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,opth1.Data());
}
char hName[24];
sprintf(hName,"hE_%i_%i",i,time);
hE1D[i]->SetName(hName);
if(opt.Contains("comov"))
hE1D[i]->GetXaxis()->SetTitle("k_{p}#zeta");
else
hE1D[i]->GetXaxis()->SetTitle("k_{p}z");
if(i==0)
hE1D[i]->GetYaxis()->SetTitle("E_{z}/E_{0}");
else if(i==1)
hE1D[i]->GetYaxis()->SetTitle("E_{y}/E_{0}");
else if(i==2)
hE1D[i]->GetYaxis()->SetTitle("E_{x}/E_{0}");
hE1D[i]->GetYaxis()->CenterTitle();
hE1D[i]->GetXaxis()->CenterTitle();
}
// Calculate wave positions:
// ----------------------------------------------------------------
// Calculate the crossings and the extremes of the Electric fields
Float_t Ecross[Nfields][100] = {{0.0}};
Float_t Eextr[Nfields][100] = {{0.0}};
Int_t Ncross[Nfields] = {0};
for(Int_t i=0;i<Nfields;i++) {
Ncross[i] = 0;
if(!hE1D[i]) continue;
// Only smooths the focusing if flag activated..
if(i>0 && opt.Contains("smooth")) {
// cout << " Smoothing fields on axis..." << endl;
hE1D[i]->Smooth(10);
}
Float_t maxZeta = zStartBeam;
if(opt.Contains("center"))
maxZeta -= zStartBeam;
for(Int_t ip=hE1D[i]->GetNbinsX();ip>1;ip--) {
Float_t Z2 = hE1D[i]->GetBinCenter(ip-1);
if(Z2 > maxZeta) continue;
Float_t E1 = hE1D[i]->GetBinContent(ip);
Float_t E2 = hE1D[i]->GetBinContent(ip-1);
Float_t Z1 = hE1D[i]->GetBinCenter(ip);
// cout << Form("Z1 = %6.4f Z2 = %6.4f E1 = %6.4f E2 = %6.4f", Z1, Z2, E1, E2) << endl;
if(E1*E2 >= 0) { // No change of sign means we are in a side of the zero axis.
if(fabs(E2)>fabs(Eextr[i][Ncross[i]])) {
Eextr[i][Ncross[i]] = E2;
}
}
if(E1*E2 < 0) { // change of sign means a crossing!
// The next crossing has to be far enough from the previous one:
Float_t zcross = -E1 * ( (Z2-Z1)/(E2-E1) ) + Z1;
if(Ncross[i]>0 && fabs(Ecross[i][Ncross[i]-1]-zcross)<TMath::PiOver2() ) continue;
// cout << " CROSS! " << endl;
// add the point
Ecross[i][Ncross[i]] = zcross;
Ncross[i]++;
}
}
cout << " -> Number of crossings for field " << i << " : " << Ncross[i] << endl;
for(Int_t ic=0;ic<Ncross[i];ic++) {
// cout << Form(" %2i: zeta = %6.4f E = %6.4f", ic, Ecross[i][ic], Eextr[i][ic]) << endl;
}
hE1D[i]->SetLineColor(kRed);
hE1D[i]->Write(hE1D[i]->GetName(),TObject::kOverwrite);
}
// Get the Graphs and histos from file
Int_t nPoints = 0;
TGraph ***gEcross = new TGraph**[Nfields];
TGraph ***gEextr = new TGraph**[Nfields];
TH2F **hEvsTime = new TH2F*[Nfields];
for(Int_t i=0;i<Nfields;i++) {
char hName[24];
sprintf(hName,"hEvsTime_%i",i);
TH2F *hEvsTimeOld = (TH2F*) ifile->Get(hName);
Int_t nBins = 1;
Float_t edge0 = Time-0.5;
Float_t edge1 = Time+0.5;
if(hEvsTimeOld!=NULL) {
nBins = hEvsTimeOld->GetNbinsX()+1;
Float_t binwidth = (Time - hEvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1);
edge0 = hEvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.;
edge1 = Time + binwidth/2.;
}
hEvsTime[i] = new TH2F("temp","",nBins,edge0,edge1,
hE1D[i]->GetNbinsX(),
hE1D[i]->GetBinLowEdge(1),
hE1D[i]->GetBinLowEdge(hE1D[i]->GetNbinsX()+1));
for(Int_t ix=1;ix<hEvsTime[i]->GetNbinsX();ix++) {
for(Int_t iy=1;iy<hEvsTime[i]->GetNbinsY();iy++) {
hEvsTime[i]->SetBinContent(ix,iy,hEvsTimeOld->GetBinContent(ix,iy));
}
}
delete hEvsTimeOld;
// Fill last bin with the newest values.
for(Int_t iy=1;iy<=hE1D[i]->GetNbinsX();iy++) {
hEvsTime[i]->SetBinContent(nBins,iy,hE1D[i]->GetBinContent(iy));
}
if(i==0)
hEvsTime[i]->GetZaxis()->SetTitle("E_{z}/E_{0}");
else if(i==1)
hEvsTime[i]->GetZaxis()->SetTitle("E_{y}/E_{0}");
else if(i==2)
hEvsTime[i]->GetZaxis()->SetTitle("E_{x}/E_{0}");
hEvsTime[i]->GetYaxis()->SetTitle("k_{p}#zeta");
hEvsTime[i]->GetXaxis()->SetTitle("k_{p}z");
hEvsTime[i]->GetZaxis()->CenterTitle();
hEvsTime[i]->GetYaxis()->CenterTitle();
hEvsTime[i]->GetXaxis()->CenterTitle();
hEvsTime[i]->SetName(hName);
// Change the range of z axis for the fields to be symmetric.
Float_t Emax = hEvsTime[i]->GetMaximum();
Float_t Emin = hEvsTime[i]->GetMinimum();
if(Emax > TMath::Abs(Emin))
Emin = -Emax;
else
Emax = -Emin;
hEvsTime[i]->GetZaxis()->SetRangeUser(Emin,Emax);
hEvsTime[i]->Write(hName,TObject::kOverwrite);
// ---
gEcross[i] = new TGraph*[Ncross[i]];
gEextr[i] = new TGraph*[Ncross[i]];
char gName[24];
Int_t ifail = 0;
for(Int_t ic=0;ic<Ncross[i];ic++) {
sprintf(gName,"gEcross_%i_%i",i,ic);
gEcross[i][ic] = (TGraph*) ifile->Get(gName);
if(gEcross[i][ic]==NULL) {
gEcross[i][ic] = new TGraph();
gEcross[i][ic]->SetName(gName);
nPoints = 0;
// Some cosmetics at creation time:
if(i==1) gEcross[i][ic]->SetLineStyle(2);
else gEcross[i][ic]->SetLineStyle(1);
gEcross[i][ic]->SetLineWidth(1);
gEcross[i][ic]->SetLineColor(kGray+1);
gEcross[i][ic]->SetMarkerStyle(20);
gEcross[i][ic]->SetMarkerSize(0.4);
gEcross[i][ic]->SetMarkerColor(kGray+1);
gEcross[i][ic]->GetYaxis()->SetTitle("k_{p}#zeta]");
gEcross[i][ic]->GetXaxis()->SetTitle("k_{p}z");
} else {
nPoints = gEcross[i][ic]->GetN();
}
// Check the new crossings respect the previous ones:
// Double_t t,zeta;
// if(nPoints>0) {
// gEcross[i][ic]->GetPoint(nPoints-1,t,zeta);
// if(fabs(zeta-Ecross[i][ic+ifail])>TMath::Pi()) {
// ic--;
// ifail++;
// continue;
// }
// }
gEcross[i][ic]->Set(nPoints+1);
gEcross[i][ic]->SetPoint(nPoints,Time,Ecross[i][ic+ifail]);
gEcross[i][ic]->Write(gName,TObject::kOverwrite);
// if(ic==Ncross[i]-1) continue;
sprintf(gName,"gEextr_%i_%i",i,ic);
gEextr[i][ic] = (TGraph*) ifile->Get(gName);
if(gEextr[i][ic]==NULL) {
gEextr[i][ic] = new TGraph();
gEextr[i][ic]->SetName(gName);
nPoints = 0;
// Some cosmetics at creation time:
if(i==0) {
gEextr[i][ic]->SetLineWidth(3);
gEextr[i][ic]->SetLineColor(PGlobals::fieldLine);
gEextr[i][ic]->SetMarkerStyle(20);
gEextr[i][ic]->SetMarkerSize(0.4);
gEextr[i][ic]->SetMarkerColor(PGlobals::fieldLine);
gEextr[i][ic]->GetYaxis()->SetTitle("E_{z}/E_{0}");
gEextr[i][ic]->GetXaxis()->SetTitle("k_{p}z");
} else if(i==1) {
gEextr[i][ic]->SetLineWidth(1);
gEextr[i][ic]->SetLineColor(kGray+2);
gEextr[i][ic]->SetMarkerStyle(20);
gEextr[i][ic]->SetMarkerSize(0.4);
gEextr[i][ic]->SetMarkerColor(kGray+2);
gEextr[i][ic]->GetYaxis()->SetTitle("E_{y}/E_{0}");
gEextr[i][ic]->GetXaxis()->SetTitle("k_{p}z");
}
} else {
nPoints = gEextr[i][ic]->GetN();
}
gEextr[i][ic]->Set(nPoints+1);
gEextr[i][ic]->SetPoint(nPoints,Time,Eextr[i][ic]);
gEextr[i][ic]->Write(gName,TObject::kOverwrite);
}
}
ifile->Close();
}
// Soft radiation corrections for L3Res
void softrad(double etamin=0.0, double etamax=1.3, bool dodijet=false) {
setTDRStyle();
writeExtraText = false; // for JEC paper CWR
TDirectory *curdir = gDirectory;
// Open jecdata.root produced by reprocess.C
TFile *fin = new TFile("rootfiles/jecdata.root","UPDATE");
assert(fin && !fin->IsZombie());
const int ntypes = 3;
const char* types[ntypes] = {"data", "mc", "ratio"};
const int nmethods = 2;
const char* methods[nmethods] = {"mpfchs1", "ptchs"};
const int nsamples = (dodijet ? 4 : 3);
const char* samples[4] = {"gamjet", "zeejet", "zmmjet", "dijet"};
string sbin = Form("eta%02.0f-%02.0f",10*etamin,10*etamax);
const char* bin = sbin.c_str();
const int nalphas = 4;
const int alphas[nalphas] = {30, 20, 15, 10};
// Z+jet bins
const double ptbins1[] = {30, 40, 50, 60, 75, 95, 125, 180, 300, 1000};
const int npt1 = sizeof(ptbins1)/sizeof(ptbins1[0])-1;
TH1D *hpt1 = new TH1D("hpt1","",npt1,&ptbins1[0]);
TProfile *ppt1 = new TProfile("ppt1","",npt1,&ptbins1[0]);
// gamma+jet bins
const double ptbins2[] = {30, 40, 50, 60, 75, 100, 125, 155, 180,
210, 250, 300, 350, 400, 500, 600, 800};
const int npt2 = sizeof(ptbins2)/sizeof(ptbins2[0])-1;
TH1D *hpt2 = new TH1D("hpt2","",npt2,&ptbins2[0]);
TProfile *ppt2 = new TProfile("ppt2","",npt2,&ptbins2[0]);
// dijet bins
const double ptbins4[] = {20, 62, 107, 175, 242, 310, 379, 467,
628, 839, 1121, 1497, 2000};
const int npt4 = sizeof(ptbins4)/sizeof(ptbins4[0])-1;
TH1D *hpt4 = new TH1D("hpt4","",npt4,&ptbins4[0]);
TProfile *ppt4 = new TProfile("ppt4","",npt4,&ptbins4[0]);
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextSize(0.045);
map<string,const char*> texlabel;
texlabel["gamjet"] = "#gamma+jet";
texlabel["zeejet"] = "Z#rightarrowee+jet";
texlabel["zmmjet"] = "Z#rightarrow#mu#mu+jet";
texlabel["dijet"] = "Dijet";
texlabel["ptchs"] = "p_{T} balance (CHS)";
texlabel["mpfchs"] = "MPF raw (CHS)";
texlabel["mpfchs1"] = "MPF type-I (CHS)";
// overlay of various alpha values
TCanvas *c1 = new TCanvas("c1","c1",ntypes*400,nmethods*400);
c1->Divide(ntypes,nmethods);
TH1D *h1 = new TH1D("h1",";p_{T} (GeV);Response",1270,30,1300);
// extrapolation vs alpha for each pT bin
vector<TCanvas*> c2s(ntypes*nmethods);
for (unsigned int icanvas = 0; icanvas != c2s.size(); ++icanvas) {
TCanvas *c2 = new TCanvas(Form("c2_%d",icanvas),Form("c2_%d",icanvas),
1200,1200);
c2->Divide(3,3);
c2s[icanvas] = c2;
}
TH1D *h2 = new TH1D("h2",";#alpha;Response",10,0.,0.4);
h2->SetMaximum(1.08);
h2->SetMinimum(0.88);
// krad corrections
TCanvas *c3 = new TCanvas("c3","c3",ntypes*400,nmethods*400);
c3->Divide(ntypes,nmethods);
TH1D *h3 = new TH1D("h3",";p_{T,ref} (GeV);FSR sensitivity: -dR/d#alpha [%]",
1270,30,1300);
cout << "Reading in data" << endl << flush;
// Read in plots vs pT (and alpha)
map<string, map<string, map<string, map<int, TGraphErrors*> > > > gemap;
map<string, map<string, map<string, map<int, TGraphErrors*> > > > gamap;
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
for (int isample = 0; isample != nsamples; ++isample) {
for (int ialpha = 0; ialpha != nalphas; ++ialpha) {
fin->cd();
assert(gDirectory->cd(types[itype]));
assert(gDirectory->cd(bin));
TDirectory *d = gDirectory;
const char *ct = types[itype];
const char *cm = methods[imethod];
const char *cs = samples[isample];
const int a = alphas[ialpha];
// Get graph made vs pT
string s = Form("%s/%s/%s_%s_a%d",types[itype],bin,cm,cs,a);
TGraphErrors *g = (TGraphErrors*)fin->Get(s.c_str());
if (!g) cout << "Missing " << s << endl << flush;
assert(g);
// Clean out empty points
// as well as trigger-biased ones for dijets
// as well as weird gamma+jet high pT point
for (int i = g->GetN()-1; i != -1; --i) {
if (g->GetY()[i]==0 || g->GetEY()[i]==0 ||
(string(cs)=="dijet" && g->GetX()[i]<70.) ||
(string(cs)=="gamjet" && g->GetX()[i]>600. && etamin!=0))
g->RemovePoint(i);
}
gemap[ct][cm][cs][a] = g;
// Sort points into new graphs vs alpha
TH1D *hpt = (isample==0 ? hpt2 : hpt1);
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { hpt = hpt4; ppt = ppt4; } // pas-v6
for (int i = 0; i != g->GetN(); ++i) {
double pt = g->GetX()[i];
ppt->Fill(pt, pt);
int ipt = int(hpt->GetBinLowEdge(hpt->FindBin(pt))+0.5);
//int ipt = int(pt+0.5);
TGraphErrors *ga = gamap[ct][cm][cs][ipt];
if (!ga) {
ga = new TGraphErrors(0);
ga->SetMarkerStyle(g->GetMarkerStyle());
ga->SetMarkerColor(g->GetMarkerColor());
ga->SetLineColor(g->GetLineColor());
gamap[ct][cm][cs][ipt] = ga;
}
int n = ga->GetN();
ga->SetPoint(n, 0.01*a, g->GetY()[i]);
ga->SetPointError(n, 0, g->GetEY()[i]);
} // for i
} // for ialpha
} // for isample
} // for imethod
} // for itype
cout << "Drawing plots vs pT for each alpha" << endl << flush;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
const char *ct = types[itype];
const char *cm = methods[imethod];
int ipad = ntypes*imethod + itype + 1; assert(ipad<=6);
c1->cd(ipad);
gPad->SetLogx();
h1->SetMaximum(itype<2 ? 1.15 : 1.08);
h1->SetMinimum(itype<2 ? 0.85 : 0.93);
h1->SetYTitle(Form("Response (%s)",ct));
h1->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3, #alpha=0.1--0.3");
TLegend *leg = tdrLeg(0.60,0.75,0.90,0.90);
for (int isample = 0; isample != nsamples; ++isample) {
for (int ialpha = 0; ialpha != nalphas; ++ialpha) {
const char *cs = samples[isample];
const int a = alphas[ialpha];
TGraphErrors *g = gemap[ct][cm][cs][a]; assert(g);
// Clean out points with very large uncertainty for plot readability
for (int i = g->GetN()-1; i != -1; --i) {
if (g->GetEY()[i]>0.02) g->RemovePoint(i);
}
g->Draw("SAME Pz");
if (ialpha==0) leg->AddEntry(g,texlabel[cs],"P");
}
} // for isample
// Individual plots for JEC paper
if ( true ) { // paper
TH1D *h = new TH1D(Form("h_5%s_%s",ct,cm),
Form(";p_{T} (GeV);Response (%s)",ct),
1270,30,1300);
h->GetXaxis()->SetMoreLogLabels();
h->GetXaxis()->SetNoExponent();
h->SetMinimum(0.88);
h->SetMaximum(1.13);
writeExtraText = true;
extraText = (string(ct)=="mc" ? "Simulation" : "");
lumi_8TeV = (string(ct)=="mc" ? "" : "19.7 fb^{-1}");
TCanvas *c0 = tdrCanvas(Form("c0_%s_%s",cm,ct), h, 2, 11, true);
c0->SetLogx();
TLegend *leg = tdrLeg(0.55,0.68,0.85,0.83);
tex->DrawLatex(0.55,0.85,texlabel[cm]);
tex->DrawLatex(0.55,0.18,"|#eta| < 1.3, #alpha=0.3");
//tex->DrawLatex(0.55,0.18,"Anti-k_{T} R=0.5");
// Loop over Z+jet and gamma+jet (only, no dijet/multijet)
for (int isample = 0; isample != min(3,nsamples); ++isample) {
const char *cs = samples[isample];
TGraphErrors *g = gemap[ct][cm][cs][30]; assert(g);
g->Draw("SAME Pz");
leg->AddEntry(g,texlabel[cs],"P");
} // for isample
if (etamin==0) {
c0->SaveAs(Form("pdf/paper_softrad_%s_%s_vspt.pdf",ct,cm));
c0->SaveAs(Form("pdfC/paper_softrad_%s_%s_vspt.C",ct,cm));
}
else {
c0->SaveAs(Form("pdf/an_softrad_%s_%s_eta%1.0f-%1.0f_vspt.pdf",
ct,cm,10*etamin,10*etamax));
}
} // paper
} // for imethod
} // for itype
c1->cd(0);
//cmsPrel(_lumi, true);
CMS_lumi(c1, 2, 33);
c1->SaveAs("pdf/softrad_2x6_vspt.pdf");
cout << "Drawing plots vs alpha for each pT" << endl << flush;
cout << "...and fitting slope vs alpha" << endl << flush;
map<string, map<string, map<string, TGraphErrors* > > > gkmap;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
int icanvas = nmethods*imethod + itype; assert(icanvas<=6);
TCanvas *c2 = c2s[icanvas]; assert(c2);
const char *ct = types[itype];
const char *cm = methods[imethod];
const int npads = 9;
for (int ipad = 0; ipad != npads; ++ipad) {
c2->cd(ipad+1);
h2->SetYTitle(Form("Response (%s)",ct));
h2->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3");
tex->DrawLatex(0.20,0.75,Form("%1.0f < p_{T} < %1.0f GeV",
hpt1->GetBinLowEdge(ipad+1),
hpt1->GetBinLowEdge(ipad+2)));
TLegend *leg = tdrLeg(0.65,0.75,0.90,0.90);
leg->AddEntry(gemap[ct][cm]["gamjet"][30], texlabel["gamjet"], "P");
leg->AddEntry(gemap[ct][cm]["zeejet"][30], texlabel["zeejet"], "P");
leg->AddEntry(gemap[ct][cm]["zmmjet"][30], texlabel["zmmjet"], "P");
leg->AddEntry(gemap[ct][cm]["dijet"][30], texlabel["dijet"], "P");
}
for (int isample = 0; isample != nsamples; ++isample) {
const char *cs = samples[isample];
map<int, TGraphErrors*> &gam = gamap[ct][cm][cs];
map<int, TGraphErrors*>::iterator itpt;
for (itpt = gam.begin(); itpt != gam.end(); ++itpt) {
int ipt = itpt->first;
int jpt = hpt1->FindBin(ipt);
if (jpt>npads) continue;
assert(jpt<=npads);
c2->cd(jpt);
TGraphErrors *ga = itpt->second; assert(ga);
ga->Draw("SAME Pz");
// Fit slope
TF1 *f1 = new TF1(Form("f1_%s_%s_%s_%d",ct,cm,cs,ipt),
"(x<1)*([0]+[1]*x) + (x>1 && x<2)*[0] +"
"(x>2)*[1]",-1,1);
f1->SetLineColor(ga->GetLineColor());
f1->SetParameters(1,0);
const double minalpha = (isample==0 ? 10./ipt : 5./ipt);
// Constrain slope to within reasonable values
// in the absence of sufficient data using priors
if (true) { // use priors
int n = ga->GetN();
// For response, limit to 1+/-0.02 (we've corrected for L3Res
ga->SetPoint(n, 1.5, 1);
ga->SetPointError(n, 0, 0.02);
n = ga->GetN();
if (imethod==1) { // pT balance
// For pT balance, estimate slope of <vecpT2>/alpha from data
// => 7.5%/0.30 = 25%
// Approximate uncertainty on this to be
// 0.5%/0.30 ~ 1.5% for data, 0.5%/0.30 ~ 1.5% for Z+jet MC, and
// 2%/0.30 ~ 6% for gamma+jet MC (same as slope)
if (itype==0) ga->SetPoint(n, 2.5, -0.250); // DT
if (itype==1 && isample!=0) ga->SetPoint(n, 2.5, -0.250); // MC
if (itype==1 && isample==0) ga->SetPoint(n, 2.5, -0.190);
if (itype==2 && isample!=0) ga->SetPoint(n, 2.5, -0.000); // rt
if (itype==2 && isample==0) ga->SetPoint(n, 2.5, -0.060);
//
// BUG: found 2015-01-08 (no effect on ratio)
//if (itype==1) ga->SetPointError(n, 0, -0.015);
if (itype==0) ga->SetPointError(n, 0, -0.015); // DT
if (itype==1 && isample!=0) ga->SetPointError(n, 0, -0.015); // MC
if (itype==1 && isample==0) ga->SetPointError(n, 0, -0.060);
if (itype==2 && isample!=0) ga->SetPointError(n, 0, -0.015); // rt
if (itype==2 && isample==0) ga->SetPointError(n, 0, -0.060);
}
if (imethod==0) { // MPF
// For MPF, expectation is no slope
// Maximal slope would be approximately
// (<vecpT2>/alpha ~ 25% from pT balance) times
// (response difference between pT1 and vecpT2~10%)
// => 0.25*0.10 = 2.5%
// For data/MC, estimate uncertainty as half of this
// => 1.25%
ga->SetPoint(n, 2.5, 0.);
if (itype!=2) ga->SetPointError(n, 0, 0.025);
if (itype==2) ga->SetPointError(n, 0, 0.0125);
} // MPF
} // use priors
if (ga->GetN()>2) {
f1->SetRange(minalpha, 3.);
ga->Fit(f1,"QRN");
if (f1->GetNDF()>=0) {
f1->DrawClone("SAME");
f1->SetRange(0,0.4);
f1->SetLineStyle(kDashed);
f1->DrawClone("SAME");
// Store results
TGraphErrors *gk = gkmap[ct][cm][cs];
if (!gk) {
gk = new TGraphErrors(0);
gk->SetMarkerStyle(ga->GetMarkerStyle());
gk->SetMarkerColor(ga->GetMarkerColor());
gk->SetLineColor(ga->GetLineColor());
gkmap[ct][cm][cs] = gk;
}
int n = gk->GetN();
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { ppt = ppt4; } // pas-v6
double pt = ppt->GetBinContent(ppt->FindBin(ipt));
gk->SetPoint(n, pt, f1->GetParameter(1));
gk->SetPointError(n, 0, f1->GetParError(1));
} // f1->GetNDF()>=0
} // ga->GetN()>2
} // for itpt
} // for isample
c2->SaveAs(Form("pdf/softrad_3x3_%s_%s_vsalpha.pdf",ct,cm));
}
}
cout << "Drawing plots of kFSR vs pT" << endl;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
const char *ct = types[itype];
const char *cm = methods[imethod];
TMultiGraph *mgk = new TMultiGraph();
int ipad = ntypes*imethod + itype + 1; assert(ipad<=6);
c3->cd(ipad);
gPad->SetLogx();
h3->SetMaximum(imethod==0 ? 0.05 : (itype!=2 ? 0.1 : 0.25));
h3->SetMinimum(imethod==0 ? -0.05 : (itype!=2 ? -0.4 : -0.25));
h3->SetYTitle(Form("k_{FSR} = dR/d#alpha (%s)",ct));
h3->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3");
TLegend *leg = tdrLeg(0.60,0.75,0.90,0.90);
for (int isample = 0; isample != nsamples; ++isample) {
const char *cs = samples[isample];
TGraphErrors *gk = gkmap[ct][cm][cs]; assert(gk);
leg->AddEntry(gk,texlabel[cs],"P");
// Fit each sample separately for pT balance
if (true) {
TF1 *fk = new TF1(Form("fk_%s_%s_%s",ct,cm,cs),
"[0]+[1]*log(0.01*x)+[2]*pow(log(0.01*x),2)",
30,1300);
fk->SetParameters(-0.25,-0.5);
fk->SetLineColor(gk->GetLineColor());
gk->Fit(fk, "QRN");
tex->SetTextColor(fk->GetLineColor());
tex->DrawLatex(0.55,0.27-0.045*isample,
Form("#chi^{2}/NDF = %1.1f / %d",
fk->GetChisquare(), fk->GetNDF()));
tex->SetTextColor(kBlack);
// Error band
const int n = fk->GetNpar();
TMatrixD emat(n,n);
gMinuit->mnemat(emat.GetMatrixArray(), n);
TF1 *fke = new TF1(Form("fk_%s_%s_%s",ct,cm,cs),
sr_fitError, 30, 1300, 1);
_sr_fitError_func = fk;
_sr_fitError_emat = &emat;
fke->SetLineStyle(kSolid);
fke->SetLineColor(fk->GetLineColor()-10);
fke->SetParameter(0,-1);
fke->DrawClone("SAME");
fke->SetParameter(0,+1);
fke->DrawClone("SAME");
fk->DrawClone("SAME");
gk->DrawClone("SAME Pz");
// Store soft radiation corrections in fsr subdirectory
assert(fin->cd(ct));
assert(gDirectory->cd(bin));
if (!gDirectory->FindObject("fsr")) gDirectory->mkdir("fsr");
assert(gDirectory->cd("fsr"));
TH1D *hk = (TH1D*)(isample==0 ? hpt2->Clone() : hpt1->Clone());
hk->SetName(Form("hkfsr_%s_%s",cm,cs));
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { ppt = ppt4; } // pas-v6
for (int i = 1; i != hk->GetNbinsX()+1; ++i) {
double pt = ppt->GetBinContent(i);
if (pt>30 && pt<1300) {
hk->SetBinContent(i, fk->Eval(pt));
hk->SetBinError(i, fabs(fke->Eval(pt)-fk->Eval(pt)));
}
else {
hk->SetBinContent(i, 0);
hk->SetBinError(i, 0);
}
}
hk->Write(hk->GetName(), TObject::kOverwrite);
// Factorize error matrix into eigenvectors
// Remember: A = Q*Lambda*Q^-1, where
// A is emat, Q is eigmat, and Lambda is a diagonal matrix with
// eigenvalues from eigvec on the diagonal. For eigenmatrix
// Q^-1 = Q^T, i.e. inverse matrix is the original transposed
TVectorD eigvec(n);
TMatrixD eigmat = emat.EigenVectors(eigvec);
// Eigenvectors are the columns and sum of eigenvectors squared
// equals original uncertainty. Calculate histograms from the
// eigenvectors and store them
TF1 *fkeig = (TF1*)fk->Clone(Form("%s_eig",fk->GetName()));
fkeig->SetLineStyle(kDotted);
for (int ieig = 0; ieig != n; ++ieig) {
// Eigenvector functions
for (int i = 0; i != n; ++i) {
fkeig->SetParameter(i, fk->GetParameter(i)
+ eigmat[i][ieig] * sqrt(eigvec[ieig]));
}
fkeig->DrawClone("SAMEL");
// Eigenvector histograms evaluated at bin mean pT
TH1D *hke = (TH1D*)hk->Clone(Form("%s_eig%d",hk->GetName(),ieig));
hke->Reset();
for (int i = 0; i != gk->GetN(); ++i) {
double pt = gk->GetX()[i];
int ipt = hke->FindBin(pt);
// Need to store central value as well, because
// uncertainty sources are signed
hke->SetBinContent(ipt, fkeig->Eval(pt)-fk->Eval(pt));
hke->SetBinError(ipt, fabs(fkeig->Eval(pt)-fk->Eval(pt)));
}
hke->Write(hke->GetName(), TObject::kOverwrite);
}
cout << "." << flush;
} // if tree
} // for isample
} // for imethod
} // for itype
c3->cd(0);
//cmsPrel(_lumi, true);
CMS_lumi(c3, 2, 33);
c3->SaveAs("pdf/softrad_2x6_kfsr.pdf");
fin->Close();
curdir->cd();
} // softrad
void recurseFile(TDirectory *indir, TDirectory *outdir,
double etawid, double etamid) {
TDirectory *curdir = gDirectory;
// Automatically go through the list of keys (directories)
TList *keys = indir->GetListOfKeys();
TListIter itkey(keys);
TObject *key, *obj;
TDirectory *dir;
while ( (key = itkey.Next()) ) {
if (_debug) cout << key->GetName() << endl << flush;
obj = ((TKey*)key)->ReadObj(); assert(obj);
dir = indir;
// Found a subdirectory: copy it to output and go deeper
if (obj->InheritsFrom("TDirectory")) {
//assert(outdir->mkdir(obj->GetName()));
outdir->mkdir(obj->GetName());
assert(outdir->cd(obj->GetName()));
TDirectory *outdir2 = outdir->GetDirectory(obj->GetName()); assert(outdir2);
outdir2->cd();
assert(indir->cd(obj->GetName()));
TDirectory *indir2 = indir->GetDirectory(obj->GetName());
indir2->cd();
// Check if directory name contains information on eta bin width
float etamin, etamax;
if ( (sscanf(indir->GetName(),"Eta_%f-%f",&etamin,&etamax)==2)
&& (etamax>etamin) ) {
etawid = 2.*(etamax-etamin);
etamid = 0.5*(etamax+etamin);
//cout << "Eta bin width: " << etawid << flush << endl;
}
recurseFile(indir2, outdir2, etawid, etamid);
//outdir2->Write(); // does this speedup or slow down?
} // inherits from TDirectory
// Found a plot: normalize if hpt, then copy to output
if (obj->InheritsFrom("TH1")) {
outdir->cd();
TObject *obj2 = obj->Clone(obj->GetName());
// Normalize hpt and hselpt histograms
// Same for hbpt
if (string(obj2->GetName())=="hpt" ||
string(obj2->GetName())=="hpt_evt" ||
string(obj2->GetName())=="hpt_jet" ||
string(obj2->GetName())=="hpt_pre" ||
string(obj2->GetName())=="hpt0" ||
string(obj2->GetName())=="hpt1" ||
string(obj2->GetName())=="hpt2" ||
string(obj2->GetName())=="hpt3" ||
string(obj2->GetName())=="hpt_jk1" ||
string(obj2->GetName())=="hpt_jk2" ||
string(obj2->GetName())=="hpt_jk3" ||
string(obj2->GetName())=="hpt_jk4" ||
string(obj2->GetName())=="hpt_jk5" ||
string(obj2->GetName())=="hpt_jk6" ||
string(obj2->GetName())=="hpt_jk7" ||
string(obj2->GetName())=="hpt_jk8" ||
string(obj2->GetName())=="hpt_jk9" ||
string(obj2->GetName())=="hpt_jk10" ||
string(obj2->GetName())=="hpt_l1off" ||
string(obj2->GetName())=="hpt_l1fast" ||
string(obj2->GetName())=="hpt_plus" ||
string(obj2->GetName())=="hpt_minus" ||
string(obj2->GetName())=="hpt0_plus" ||
string(obj2->GetName())=="hpt0_minus" ||
string(obj2->GetName())=="hpt_noid" ||
string(obj2->GetName())=="hpt_noevtid" ||
string(obj2->GetName())=="hpt_nojetid" ||
string(obj2->GetName())=="hpt_ak5calo" ||
string(obj2->GetName())=="hpt_ak5pf" ||
string(obj2->GetName())=="hpt_evt_ak5pf" ||
string(obj2->GetName())=="hpt_jet_ak5pf" ||
string(obj2->GetName())=="hselpt" ||
string(obj2->GetName())=="hpt_r" ||
string(obj2->GetName())=="hpt_g" ||
string(obj2->GetName())=="hpt_gg" ||
string(obj2->GetName())=="hpt_g0" ||
string(obj2->GetName())=="hpt_g0tw" ||
string(obj2->GetName())=="hdjmass" ||
string(obj2->GetName())=="hdjmass0" ||
string(obj2->GetName())=="hdjmass0_hgg") {
cout << "." << flush;
TH1D *hpt = (TH1D*)obj2;
bool isgen = TString(obj2->GetName()).Contains("pt_g");
bool isoth = (TString(obj2->GetName()).Contains("pt_no") ||
TString(obj2->GetName()).Contains("djmass") ||
TString(obj2->GetName()).Contains("hpt0") ||
TString(obj2->GetName()).Contains("l1off") ||
TString(obj2->GetName()).Contains("l1fast"));
bool iscalo = (TString(obj2->GetName()).Contains("_ak5calo"));
bool ispf5 = (TString(obj2->GetName()).Contains("_ak5pf"));
bool ispre = (TString(obj2->GetName()).Contains("_pre"));
bool isjk = (TString(obj2->GetName()).Contains("hpt_jk"));
bool isjet = (TString(obj2->GetName()).Contains("hpt_jet"));
TProfile *peff = (TProfile*)dir->Get("peff"); assert(peff);
TH1D *hlumi = (TH1D*)dir->Get("hlumi"); assert(hlumi);
TH1D *hlumi0 = (TH1D*)dir->Get("../jt450/hlumi"); assert(hlumi0);
if (_jp_usetriglumi) {
TH1D *hlumi_orig = (TH1D*)outdir->FindObject("hlumi_orig");
if (!hlumi_orig) hlumi_orig = (TH1D*)hlumi->Clone("hlumi_orig");
// regular prescaled luminosity
TH1D *hlumi_new = (TH1D*)outdir->FindObject("hlumi");
if (hlumi_new) hlumi = hlumi_new;
string strg = dir->GetName();
double lumi = triglumi[strg];
for (int i = 1; i != hlumi->GetNbinsX()+1; ++i) {
hlumi->SetBinContent(i, lumi);
}
// unprescaled luminosity
double lumi0 = triglumi["jt450"];
for (int i = 1; i != hlumi0->GetNbinsX()+1; ++i) {
hlumi0->SetBinContent(i, lumi0);
}
} // _jp_usetriglumi
// Test MC-based normalization for trigger efficiency
bool dotrigeff = ((string(obj2->GetName())=="hpt") || isjk || isjet);
TH1D *htrigeff = (TH1D*)outdir->FindObject("htrigeff");
TH1D *htrigeffmc = (TH1D*)outdir->FindObject("htrigeffmc");
TH1D *htrigeffsf = (TH1D*)outdir->FindObject("htrigeffsf");
TH1D *hpt_notrigeff = 0;
if (!htrigeff && _jp_dotrigeff) {
TFile *fmc = new TFile("output-MC-1.root","READ");
assert(fmc && !fmc->IsZombie());
assert(fmc->cd("Standard"));
fmc->cd("Standard");
TDirectory *dmc0 = fmc->GetDirectory("Standard");
//assert(gDirectory->cd(Form("Eta_%1.1f-%1.1f",
// etamid-0.25*etawid,etamid+0.25*etawid)));
//TDirectory *dmc = gDirectory;
TDirectory *dmc = dmc0->GetDirectory(Form("Eta_%1.1f-%1.1f",
etamid-0.25*etawid,etamid+0.25*etawid));
assert(dmc);
dmc->cd();
// Add MC truth based trigger efficiency
if(!htrigeffmc && dmc->cd(dir->GetName())) {
TDirectory *dir1 = dmc->GetDirectory(dir->GetName()); assert(dir1);
TH1D *hpty = (TH1D*)dir1->Get("hpt"); assert(hpty);
assert(dmc->cd("mc"));
dmc->cd("mc");
TDirectory *dir2 = dmc->GetDirectory("mc"); assert(dir2);
TH1D *hptx = (TH1D*)dir2->Get(Form("hpt_%s",dir->GetName()));
outdir->cd();
if (hpty && hptx) htrigeffmc = (TH1D*)hpty->Clone("htrigeffmc");
if (hpty && hptx) htrigeffmc->Divide(hpty,hptx,1,1,"B");
}
// Add data/MC scale factor for trigger efficiency
if (_nh_dt && !htrigeffsf) {
assert(dmc->cd(dir->GetName()));
dmc->cd(dir->GetName());
TDirectory *dirmc = dmc->GetDirectory(dir->GetName()); assert(dirmc);
TProfile *pm = (TProfile*)dirmc->Get("ptrigefftp");
TProfile *pd = (TProfile*)dir->Get("ptrigefftp");
outdir->cd();
if (pm && pd) htrigeffsf = pm->ProjectionX("htrigeffsf");
if (pm && pd) htrigeffsf->Divide(pd,pm,1);
}
// Combine MC trigger efficiency and scalefactor
if (htrigeffmc) { // not available for 'mc' directory
outdir->cd();
htrigeff = (TH1D*)htrigeffmc->Clone("htrigeff");
assert(!_nh_dt || htrigeffsf);
if (_nh_dt) htrigeff->Multiply(htrigeffsf);
TH1D *h = (TH1D*)dir->Get("hpt");
assert(outdir->FindObject("hpt_notrigeff")==0);
outdir->cd();
hpt_notrigeff = (TH1D*)h->Clone("hpt_notrigeff");
}
fmc->Close();
} // dotrigeff
// Scale data to account for time dependence
bool dotimedep = ((string(obj2->GetName())=="hpt") || isjk || isjet);
TH1D *htimedep = (TH1D*)outdir->FindObject("htimedep");
TH1D *htimefit = (TH1D*)outdir->FindObject("htimefit");
TH1D *hpt_notimedep = 0, *hpt_withtimedep = 0;
double ktime = 1.;
if (!htimedep) {
TH1D *h = (TH1D*)dir->Get("hpt");
TH1D *hsel = (TH1D*)dir->Get("hselpt");
TH1D *hpre = (TH1D*)dir->Get("hpt_pre");
//TH1D *hlumi0 = (TH1D*)dir->Get("../jt450/hlumi");
// Fix luminosity for unprescaled trigger
//string strg = dir->GetName();
//double lum0 = triglumi["jt450"];
//for (int i = 1; i != hlumi0->GetNbinsX()+1; ++i) {
//hlumi0->SetBinContent(i, lum0);
//}
outdir->cd();
if (h) hpt_notimedep = (TH1D*)h->Clone("hpt_notimedep");
if (hpre && h) htimedep = (TH1D*)hpre->Clone("htimedep");
if (hpre && h) htimedep->Divide(hpre,h);//,1,1,"B");
// Figure out trigger luminosities
double lumi = 0;
if (hlumi) lumi = hlumi->GetBinContent(1);
double lumi0 = 0;
if (hlumi0) lumi0 = hlumi0->GetBinContent(1);
if (htimedep && lumi && lumi0) {
htimedep->Scale(lumi / lumi0);
}
// Find proper pT range and fit
double minpt = 0.;
double maxpt = 6500.;
if (hsel) {
for (int i = 1; i != hsel->GetNbinsX()+1; ++i) {
if (hsel->GetBinContent(i)!=0 &&
hsel->GetBinLowEdge(i)>=_jp_xmin57) {
if (minpt<20) minpt = hsel->GetBinLowEdge(i);
maxpt = hsel->GetBinLowEdge(i+1);
}
}
}
TF1 *ftmp = new TF1("ftmp","[0]",minpt,maxpt);
ftmp->SetParameter(0,1);
if (htimedep && htimedep->Integral()>0) htimedep->Fit(ftmp,"QRN");
if (htimedep && ftmp->GetParameter(0)>0)
ktime = 1./ftmp->GetParameter(0);
if (htimedep) {
outdir->cd();
htimefit = (TH1D*)hsel->Clone("htimefit");
hpt_withtimedep = (TH1D*)h->Clone("hpt_withtimedep");
for (int i = 1; i != htimefit->GetNbinsX()+1; ++i) {
if (hsel->GetBinContent(i)!=0) {
htimefit->SetBinContent(i, ftmp->GetParameter(0));
htimefit->SetBinError(i, ftmp->GetParError(0));
}
// Calculate with time dependence here to add ktime fit error
hpt_withtimedep->SetBinContent(i, hpt_notimedep->GetBinContent(i)
* htimefit->GetBinContent(i));
double err1 = hpt_notimedep->GetBinError(i)
/ hpt_notimedep->GetBinContent(i);
double err2 = htimefit->GetBinError(i)
/ htimefit->GetBinContent(i);
hpt_withtimedep->SetBinError(i, hpt_notimedep->GetBinContent(i)
* sqrt(pow(err1,2) + pow(err2,2)));
}
}
} // dotimedep
if (!(hpt->GetNbinsX()==peff->GetNbinsX() || isoth || isgen) ||
!(hpt->GetNbinsX()==hlumi->GetNbinsX() || isoth || isgen)) {
cerr << "Hist " << hpt->GetName() << " " << dir->GetName()
<< " Nbins=" << hpt->GetNbinsX() << endl << flush;
assert(hpt->GetNbinsX()==peff->GetNbinsX() || isoth);
assert(hpt->GetNbinsX()==hlumi->GetNbinsX() || isoth);
}
for (int i = 1; i != hpt->GetNbinsX()+1; ++i) {
// Normalization for bin width in y, pT
double norm = hpt->GetBinWidth(i) * etawid;
double trigeff = 1.;
double pt = hpt->GetBinCenter(i);
// Normalization for all the common efficiencies
if (peff->GetBinContent(i)!=0 && !isgen)
norm *= peff->GetBinContent(i);
// Test MC-based normalization for trigger efficiency
if (dotrigeff && htrigeff && _jp_dotrigeff) {
if (htrigeff->GetBinContent(i)!=0) {
trigeff = min(1.,max(0.,htrigeff->GetBinContent(i)));
if (_jp_dotrigefflowptonly && pt>=114) trigeff = 1;
norm *= trigeff;
}
}
// Normalization for luminosity
if (hlumi->GetBinContent(i)!=0 && !isoth && !isgen && !ispre)
norm *= hlumi->GetBinContent(i);
if (hlumi->GetBinContent(1)!=0 && isoth && !isgen && !ispre)
norm *= hlumi->GetBinContent(1);
if (hlumi0->GetBinContent(1)!=0 && !isoth && !isgen && ispre)
norm *= hlumi0->GetBinContent(1);
// Fix luminosity from .csv VTX to lumiCalc vdM
if (!_nh_mc) norm *= _lumiscale;
// Scale normalization for jackknife
if (isjk) norm *= 0.9;
if (_nh_mc && _jp_pthatbins) norm *= 1.;
if (_nh_mc && !_jp_pthatbins) {
norm /= 2500.; //(xsecw / (sumw * adhocw) ); // equals 2551.;
}
// Correct data for time-dependence
double norm_notime = norm;
if (dotimedep && htimedep && _jp_dotimedep) {
norm *= ktime;
}
if (!(peff->GetBinContent(i)!=0||hpt->GetBinContent(i)==0 || isgen ||
iscalo || ispf5 || isoth || hpt->GetBinCenter(i)<_jp_recopt
|| hpt->GetBinCenter(i)*cosh(etamid)>3500.)) {
cerr << "Hist " << hpt->GetName() << " " << dir->GetName()
<< " pt=" << hpt->GetBinCenter(i)
<< " etamid = " << etamid << endl << flush;
assert(peff->GetBinContent(i)!=0||hpt->GetBinContent(i)==0||isgen||
hpt->GetBinCenter(i)<_jp_recopt);
}
/*
if (!(hlumi->GetBinContent(i)!=0 || hpt->GetBinContent(i)==0
|| isoth || isgen || hpt->GetBinCenter(i)<_jp_recopt)) {
cerr << "Hist " << hpt->GetName() << " " << dir->GetName()
<< " pt=" << hpt->GetBinCenter(i) << endl << flush;
assert(hlumi->GetBinContent(i)!=0 || hpt->GetBinContent(i)==0
|| isoth || hpt->GetBinCenter(i)<_jp_recopt);
}
*/
assert(norm!=0);
hpt->SetBinContent(i, hpt->GetBinContent(i) / norm);
hpt->SetBinError(i, hpt->GetBinError(i) / norm);
if (hpt_notrigeff) {
hpt_notrigeff->SetBinContent(i, hpt_notrigeff->GetBinContent(i)
/ norm * trigeff);
hpt_notrigeff->SetBinError(i, hpt_notrigeff->GetBinError(i)
/ norm * trigeff);
}
if (hpt_notimedep) {
hpt_notimedep->SetBinContent(i, hpt_notimedep->GetBinContent(i)
/ norm_notime);
hpt_notimedep->SetBinError(i, hpt_notimedep->GetBinError(i)
/ norm_notime);
}
if (hpt_withtimedep) { // ktime already applied => use norm_notime
hpt_withtimedep->SetBinContent(i, hpt_withtimedep->GetBinContent(i)
/ norm_notime);
hpt_withtimedep->SetBinError(i, hpt_withtimedep->GetBinError(i)
/ norm_notime);
}
} // for i
} // hpt
dir->cd();
} // inherits from TH1
} // while key
curdir->cd();
} // recurseFile
