void wfd_raw_fill_reset(const int run_nr = 0)
{
int i;
char name[256];
const int n_crates = WFD_NUMBER_OF_CRATES;
TH2D *h2[n_crates];
//=========================================================
// *** initialize style ***
//=========================================================
init();
gStyle->SetOptStat(11);
//=========================================================
// *** open canvas ***
//=========================================================
TCanvas *c1 = new TCanvas("c1","c1",0,0,800,1000);
c1->Draw();
c1->cd();
c1->Divide(2,3,0.001,0.001,10);
//=========================================================
// *** receive and plot histograms ***
//=========================================================
for (i=0; i<n_crates; i++) {
sprintf(name,"WFDrawFillHasResetBlock%s",wfd_crate_name[i]);
h2[i] = (TH2D*) get_hist(name, run_nr);
if ( !h2[i] ) continue;
int ipad = i+1;
c1->cd(ipad);
h2[i]->Draw("ColZ");
c1->GetPad(ipad)->Update();
h2[i]->SetXTitle("fill counter");
h2[i]->SetYTitle("(slot-1)*4 + chan.");
h2[i]->GetXaxis()->SetRangeUser(0.0,2000.0);
TPaletteAxis *palette = (TPaletteAxis*)h2[i]->GetListOfFunctions()->FindObject("palette");
if ( palette ) {
palette->SetX2NDC( palette->GetX1NDC()+0.01 );
palette->Draw();
}
}
c1->SaveAs("../png/wfd_raw_fill_reset.png");
}
// Make 2D efficiency plots
void makeplots2D( TH2& eff, TString name) {
gROOT->ProcessLine(".L ~/tdrstyle.C");
setTDRStyle();
const Int_t NRGBs = 5;
const Int_t NCont = 200;
Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 };
Double_t red[NRGBs] = { 0.00, 0.00, 0.87, 1.00, 0.51 };
Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 };
Double_t blue[NRGBs] = { 0.51, 1.00, 0.12, 0.00, 0.00 };
TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
tdrStyle->SetNumberContours(NCont);
if(name.Contains("_Pt")) {
eff.GetXaxis()->SetTitle("p_{T} (GeV/c)");
eff.GetYaxis()->SetTitle("#eta ");
}
if(name.Contains("_Phi")) {
eff.GetXaxis()->SetTitle("#phi ");
eff.GetYaxis()->SetTitle("#eta ");
}
eff.GetYaxis()->SetTitleOffset(1);
tdrStyle->SetPadLeftMargin(0.08);
tdrStyle->SetPadRightMargin(0.1);
TCanvas canvas("canvas",name,600,600);
eff.Draw("colz");
gPad->Update();
TPaletteAxis* palette =
(TPaletteAxis*)eff.GetListOfFunctions()->FindObject("palette");
palette->SetLabelSize(0.02);
canvas.SaveAs(name + TString(".eps"));
canvas.SaveAs(name + TString(".gif"));
canvas.Close();
}
TPaletteAxis* MovePaletteHorizontally(TH1 *histo, Double_t step) {
TPaletteAxis *palette = (TPaletteAxis*)histo->GetListOfFunctions()->FindObject("palette");
if (palette) {
palette->SetX1NDC(palette->GetX1NDC()-step);
palette->SetX2NDC(palette->GetX2NDC()-step);
palette->GetAxis()->SetLabelOffset(0.01);
} else {
std::cout << "Palette not found!" << std::endl;
}
return palette;
}
void repositionPalette(std::string name)
{
// Reposition and resize palette
TH2F *h = (TH2F*)gDirectory->GetList()->FindObject(name.c_str());
TPaletteAxis *pal;
pal = (TPaletteAxis*)h->FindObject("palette");
pal->SetX1NDC(0.83);
pal->SetY1NDC(0.14);
pal->SetX2NDC(0.88);
pal->SetY2NDC(0.60);
pal->SetLabelSize(.04);
}
void repositionPalette(std::string name)
{
// Reposition and resize palette
TH2F *h = (TH2F*)gDirectory->GetList()->FindObject(name.c_str());
TPaletteAxis *pal;
pal = (TPaletteAxis*)h->FindObject("palette");
if (0==pal)
{
cout << "Palette not found - cannot reposition it" << endl;
return;
}
pal->SetX1NDC(0.83);
pal->SetY1NDC(0.14);
pal->SetX2NDC(0.88);
pal->SetY2NDC(0.60);
pal->SetLabelSize(.04);
cout << "Repo" << endl;
}
// -----------------------------------------------------------------------------
// Create plots
void plot( std::string& path,
std::string& type,
std::string& sample,
std::string& dir,
std::string& histo,
double lumi,
bool scale ) {
std::string canvas_name = histo + "_" + dir + "_" + type + "_" + sample;
// Create canvas
TCanvas* canvas = new TCanvas(canvas_name.c_str(),"");
canvas->SetFillColor(0);
canvas->SetFrameBorderMode(0);
canvas->SetFrameFillColor(0);
canvas->SetTopMargin(0.10);
canvas->SetBottomMargin(0.12);
canvas->SetLeftMargin(0.12);
canvas->SetRightMargin(0.15);
// Retrieve histogram
std::string file_name = path + type + "_" + sample + ".root";
TFile* f = new TFile(file_name.c_str(),"READ");
TDirectory* d = (TDirectory*)f->Get(dir.c_str());
TH2D* his = (TH1*)d->Get(histo.c_str());
if ( !his ) return;
//his->Rebin2D(2,2);
if ( true ) { gPad->SetLogz(); }
if ( scale ) his->Scale( lumi / 100. );
his->SetMaximum(1.e4);
his->SetMinimum(1.e-5);
//his->SetMinimum( his->GetMinimum(1.e-12) );
// his->SetMaximum( 20000. );
// his->SetMinimum( 2.e-4 );
// his->SetMaximum( 20000. );
// his->SetMinimum( 20. );
double xmin = his->GetXaxis()->GetXmin();
double xmax = his->GetXaxis()->GetXmax();
double ymin = his->GetYaxis()->GetXmin();
double ymax = his->GetYaxis()->GetXmax();
// Reset title
std::string title = ";" + std::string(his->GetXaxis()->GetTitle()) + ";" + std::string(his->GetYaxis()->GetTitle());
his->SetTitle(title.c_str());
his->GetXaxis()->SetTitle("x_{2}");
his->GetXaxis()->SetTitleOffset(1.2);
his->GetYaxis()->SetTitle("x_{1}");
his->GetYaxis()->SetTitleOffset(1.4);
his->Draw("COLZ");
gPad->Update();
// Lumi
if (1) {
std::stringstream ss;
ss << "#int L dt = " << lumi << " pb^{-1}";
double xpos = 0.05 * (xmax-xmin)+xmin;
double ypos = 0.25 * (ymax-ymin)+ymin;
TLatex* text1 = new TLatex(xpos,ypos,ss.str().c_str());
text1->SetTextAlign(12);
text1->SetTextSize(0.035);
text1->Draw();
}
// Jet type
if (1) {
double xpos = 0.05 * (xmax-xmin)+xmin;
double ypos = 0.15 * (ymax-ymin)+ymin;
TText* text2 = new TText(xpos,ypos,type.c_str());
text2->SetTextAlign(12);
text2->SetTextSize(0.035);
text2->Draw();
}
// Sample
if (1) {
double xpos = 0.05 * (xmax-xmin)+xmin;
double ypos = 0.10 * (ymax-ymin)+ymin;
TText* text3 = new TText(xpos,ypos,sample.c_str());
text3->SetTextAlign(12);
text3->SetTextSize(0.035);
text3->Draw();
}
// Stats
gStyle->SetOptStat("i");
his->SetStats(1);
TPaveStats* stats = (TPaveStats*)his->GetListOfFunctions()->FindObject("stats");
std::string stats_pos = "br";
if ( stats ) {
stats->SetFillColor(0);
stats->SetLineColor(0);
stats->SetShadowColor(0);
if ( stats_pos == "tr" ) {
stats->SetX1NDC(0.60); stats->SetY1NDC(0.68); stats->SetX2NDC(0.83); stats->SetY2NDC(0.88);
} else if ( stats_pos == "br" ) {
stats->SetX1NDC(0.60); stats->SetY1NDC(0.18); stats->SetX2NDC(0.83); stats->SetY2NDC(0.28);
} else {
stats->SetX1NDC(0.60); stats->SetY1NDC(0.68); stats->SetX2NDC(0.83); stats->SetY2NDC(0.88);
}
}
// Scale
gStyle->SetPalette(1);
TPaletteAxis* palette = (TPaletteAxis*)his->GetListOfFunctions()->FindObject("palette");
if ( palette ) {
palette->SetY1NDC(0.2);
palette->SetY2NDC(0.8);
}
canvas->Modified();
canvas->cd();
canvas->SetSelected(canvas);
canvas->SaveAs(std::string(canvas_name+".png").c_str());
//canvas->Write();
}
void makeEfficiency_74X_setBr(bool isPrompt=false, bool isPair=true, bool isEmbedded=true, bool isPtCut = false, bool doWeight = false)
{
gROOT->Macro("./JpsiStyle.C");
gStyle->SetPaintTextFormat(".3f"); // for text colz
//string strDir = "eff_74X_setBr"; // directory name
//string strDir = "eff_74X_setBr_wDetached"; // directory name
string strDir = "eff_74X_noRegitMuDetached"; // directory name
int initev =0;
int nevt = -1; //all
//int nevt = 1000;
int ptbin = 11.;
double ptmin = 0.;
double ptmax = 11.;
if (isEmbedded && !isPrompt) { ptbin = 22.; ptmax = 22.; }
int rapbin = 12;
double rapmin = -2.4;
double rapmax = 2.4;
int lxybin = 10;
double lxymin = 0.;
double lxymax = 1.;
string strPrompt;
string strEmbd;
string strPair;
if(isPrompt){ strPrompt = "prompt"; }
else { strPrompt = "nonprompt"; }
if(isEmbedded){ strEmbd = "embd"; }
else { strEmbd = "nonembd"; }
if(isPair){ strPair = "Pair"; }
else { strPair = "Trk"; }
cout << "strPrompt = " << strPrompt.c_str() << endl;
cout << "strEmbd = " << strEmbd.c_str() << endl;
cout << "strPair = " << strPair.c_str() << endl;
////// read-in file & tree
TFile * refFile;
if (isEmbedded){
////// 740pre3 -embd
//if (isPrompt){ refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_PromptJpsi_step2nMatch_KYO_regit_embd_20150211.root");}
//else { refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_B2JpsiMuMu_step2nMatch_KYO_regit_embd_20150211.root");}
////// 740pre3 -embd with HiDetachedTripletStep
//if (isPrompt){ refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_PromptJpsi_step2nMatch_KYO_regit_wDetached_embd_20150224.root");}
//else { refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_B2JpsiMuMu_step2nMatch_KYO_regit_wDetached_embd_20150224.root");}
////// 740pre3 - remove some regit : noRegitMuDetached
if (isPrompt){ refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_PromptJpsi_step2nMatch_KYO_regit_noRegitMuDetached_embd_20150310.root");}
else { refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_B2JpsiMuMu_step2nMatch_KYO_regit_noRegitMuDetached_embd_20150310.root");}
}
else {
//730pre2 -nonembd
if (isPrompt){ refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_PromptJpsi_step2nMatch_KYO_regit_20141121.root");}
else { refFile = new TFile("/home/songkyo/kyo/regitSample/tot_Pythiagun_B2Jpsi_step2nMatch_KYO_regit_20141203_no9_32_90.root");}
}
TTree *tr = new TTree();
if(isPair) { tr = (TTree*)refFile->Get("mcmatchanalysis/pnSimRecoPairType1");}
else { tr = (TTree*)refFile->Get("mcmatchanalysis/pnSimRecoTrkType1"); }
/*
//for pT-|y| weight
TFile *fWeight;
if (isPrompt){ fWeight = new TFile("./pTdist_diffY/pTdist_diffY_prompt.root");}
else {fWeight = new TFile("./pTdist_diffY/pTdist_diffY_nonprompt.root");}
const int nYBin = 4;
TH1D* hWeight[nYBin];
for (int i=0; i< nYBin; i++){
if (isPair) { hWeight[i] = (TH1D*)fWeight->Get(Form("hPairRatio_%d",i)); }
else { hWeight[i] = (TH1D*)fWeight->Get(Form("hTrkRatio_%d",i)); };
//cout << i << "th hWeight = " << hWeight[i] << endl;
cout << i << "th hWeight Name= " << hWeight[i]->GetName() << endl;
}
*/
///////////////////////////////////////
////// Pair //////
//gen
Float_t pt;
Float_t y;
Float_t pt1;
Float_t eta1;
Float_t npixelhits1;
Float_t nmuonhits1;
Float_t pt2;
Float_t eta2;
Float_t npixelhits2;
Float_t nmuonhits2;
//reco
Float_t ptreco;
Float_t yreco;
Float_t minvreco;
Float_t ptreco1;
Float_t etareco1;
Float_t nvalidpixelhitsreco1;
Float_t nvalidmuonhitsreco1;
Float_t nmatch1;
Float_t chi2ndofreco1;
Float_t ptreco2;
Float_t etareco2;
Float_t nvalidpixelhitsreco2;
Float_t nvalidmuonhitsreco2;
Float_t nmatch2;
Float_t chi2ndofreco2;
// for lxy
Float_t vtxz1;
Float_t vtxy1;
Float_t bx;
Float_t by;
////// Trk (additional)//////
//gen
Float_t eta;
Float_t idparent;
Float_t npixelhits;
Float_t nmuonhits;
//reco
Float_t etareco;
Float_t nvalidpixelhitsreco;
Float_t nvalidmuonhitsreco;
Float_t nmatch;
Float_t chi2ndofreco;
// for lxy
Float_t vtxz;
Float_t vtxy;
///////////////////////////////////////
//Branches
///////////////////////////////////////
TBranch *b_pt;
TBranch *b_y;
TBranch *b_pt1;
TBranch *b_eta1;
TBranch *b_npixelhits1;
TBranch *b_nmuonhits1;
TBranch *b_pt2;
TBranch *b_eta2;
TBranch *b_npixelhits2;
TBranch *b_nmuonhits2;
//reco
TBranch *b_ptreco;
TBranch *b_yreco;
TBranch *b_minvreco;
TBranch *b_ptreco1;
TBranch *b_etareco1;
TBranch *b_nvalidpixelhitsreco1;
TBranch *b_nvalidmuonhitsreco1;
TBranch *b_nmatch1;
TBranch *b_chi2ndofreco1;
TBranch *b_ptreco2;
TBranch *b_etareco2;
TBranch *b_nvalidpixelhitsreco2;
TBranch *b_nvalidmuonhitsreco2;
TBranch *b_nmatch2;
TBranch *b_chi2ndofreco2;
// for lxy
TBranch *b_vtxz1;
TBranch *b_vtxy1;
TBranch *b_bx;
TBranch *b_by;
////// Trk (additional)//////
//gen
TBranch *b_eta;
TBranch *b_idparent;
TBranch *b_npixelhits;
TBranch *b_nmuonhits;
//reco
TBranch *b_etareco;
TBranch *b_nvalidpixelhitsreco;
TBranch *b_nvalidmuonhitsreco;
TBranch *b_nmatch;
TBranch *b_chi2ndofreco;
// for lxy
TBranch *b_vtxz;
TBranch *b_vtxy;
///////////////////////////////////////
//BranchAddress
///////////////////////////////////////
tr->SetBranchAddress("pt",&pt,&b_pt);
tr->SetBranchAddress("ptreco",&ptreco,&b_ptreco);
tr->SetBranchAddress("bx",&bx,&b_bx);
tr->SetBranchAddress("by",&by,&b_by);
if (isPair) {
tr->SetBranchAddress("y",&y,&b_y);
tr->SetBranchAddress("pt1",&pt1,&b_pt1);
tr->SetBranchAddress("eta1",&eta1,&b_eta1);
tr->SetBranchAddress("npixelhits1",&npixelhits1,&b_npixelhits1);
tr->SetBranchAddress("nmuonhits1",&nmuonhits1,&b_nmuonhits1);
tr->SetBranchAddress("pt2",&pt2,&b_pt2);
tr->SetBranchAddress("eta2",&eta2,&b_eta2);
tr->SetBranchAddress("npixelhits2",&npixelhits2,&b_npixelhits2);
tr->SetBranchAddress("nmuonhits2",&nmuonhits2,&b_nmuonhits2);
tr->SetBranchAddress("yreco",&yreco,&b_yreco);
tr->SetBranchAddress("minvreco",&minvreco,&b_minvreco);
tr->SetBranchAddress("ptreco1",&ptreco1,&b_ptreco1);
tr->SetBranchAddress("etareco1",&etareco1,&b_etareco1);
tr->SetBranchAddress("nvalidpixelhitsreco1",&nvalidpixelhitsreco1,&b_nvalidpixelhitsreco1);
tr->SetBranchAddress("nvalidmuonhitsreco1",&nvalidmuonhitsreco1,&b_nvalidmuonhitsreco1);
tr->SetBranchAddress("nmatch1",&nmatch1,&b_nmatch1);
tr->SetBranchAddress("chi2ndofreco1",&chi2ndofreco1,&b_chi2ndofreco1);
tr->SetBranchAddress("ptreco2",&ptreco2,&b_ptreco2);
tr->SetBranchAddress("etareco2",&etareco2,&b_etareco2);
tr->SetBranchAddress("nvalidpixelhitsreco2",&nvalidpixelhitsreco2,&b_nvalidpixelhitsreco2);
tr->SetBranchAddress("nvalidmuonhitsreco2",&nvalidmuonhitsreco2,&b_nvalidmuonhitsreco2);
tr->SetBranchAddress("nmatch2",&nmatch2,&b_nmatch2);
tr->SetBranchAddress("chi2ndofreco2",&chi2ndofreco2,&b_chi2ndofreco2);
tr->SetBranchAddress("vtxz1",&vtxz1,&b_vtxz1);
tr->SetBranchAddress("vtxy1",&vtxy1,&b_vtxy1);
}
else {
tr->SetBranchAddress("eta",&eta,&b_eta);
tr->SetBranchAddress("etareco",&etareco,&b_etareco);
tr->SetBranchAddress("idparent",&idparent,&b_idparent);
tr->SetBranchAddress("npixelhits",&npixelhits,&b_npixelhits);
tr->SetBranchAddress("nmuonhits",&nmuonhits,&b_nmuonhits);
tr->SetBranchAddress("nvalidpixelhitsreco",&nvalidpixelhitsreco,&b_nvalidpixelhitsreco);
tr->SetBranchAddress("nvalidmuonhitsreco",&nvalidmuonhitsreco,&b_nvalidmuonhitsreco);
tr->SetBranchAddress("nmatch",&nmatch,&b_nmatch);
tr->SetBranchAddress("chi2ndofreco",&chi2ndofreco,&b_chi2ndofreco);
tr->SetBranchAddress("vtxz",&vtxz,&b_vtxz);
tr->SetBranchAddress("vtxy",&vtxy,&b_vtxy);
}
//2D hist. just check
TH2D* hGenPtY = new TH2D("hGenPtY","hGenPtY",50,rapmin,rapmax,50,ptmin,ptmax);
TH2D* hRecoPtY = new TH2D("hRecoPtY","hRecoPtY",50,rapmin,rapmax,50,ptmin,ptmax);
TH2D* hEffPtY = new TH2D("hEffPtY","hEffPtY",50,rapmin,rapmax,50,ptmin,ptmax);
TH1D* hGenPt = new TH1D("hGenPt","hGenPt",ptbin,ptmin,ptmax);
TH1D* hRecoPt = new TH1D("hRecoPt","hRecoPt",ptbin,ptmin,ptmax);
TH1D* hEffPt = new TH1D("hEffPt","hEffPt",ptbin,ptmin,ptmax);
TH1D* hGenRap = new TH1D("hGenRap","hGenRap",rapbin,rapmin,rapmax);
TH1D* hRecoRap = new TH1D("hRecoRap","hRecoRap",rapbin,rapmin,rapmax);
TH1D* hEffRap = new TH1D("hEffRap","hEffRap",rapbin,rapmin,rapmax);
TH1D* hGenLxy = new TH1D("hGenLxy","hGenLxy",lxybin,lxymin,lxymax);
TH1D* hRecoLxy = new TH1D("hRecoLxy","hRecoLxy",lxybin,lxymin,lxymax);
TH1D* hEffLxy = new TH1D("hEffLxy","hEffLxy",lxybin,lxymin,lxymax);
hGenPtY->Sumw2();
hRecoPtY->Sumw2();
hEffPtY->Sumw2();
hGenPt->Sumw2();
hRecoPt->Sumw2();
hEffPt->Sumw2();
hGenRap->Sumw2();
hRecoRap->Sumw2();
hEffRap->Sumw2();
hGenLxy->Sumw2();
hRecoLxy->Sumw2();
hEffLxy->Sumw2();
//event loop start
if(nevt == -1) nevt = tr->GetEntries();
for (int iev=initev; iev<nevt; iev++){
tr->GetEntry(iev);
bool yngen = false;
bool ynreco = false;
float weightF = 1.;
float lxy = -531.;
/// give a cut to Gen and Reco separately
if (isPair) {
if (isPtCut) { if ( !(pt<15.) ) continue; }
/// define IP
lxy = TMath::Sqrt((vtxz1-bx)*(vtxz1-bx)+(vtxy1-by)*(vtxy1-by));
if (kineCut(pt1,eta1) && kineCut(pt2,eta2)
&& idCut(npixelhits1,nmuonhits1)
&& idCut(npixelhits2,nmuonhits2) )
{ yngen=true; }
if (kineCut(ptreco1,etareco1) && kineCut(ptreco2,etareco2)
&& idCut(nvalidpixelhitsreco1,nvalidmuonhitsreco1)
&& idCut(nvalidpixelhitsreco2,nvalidmuonhitsreco2)
//&& idRecoCut(nmatch1, chi2ndofreco1)
//&& idRecoCut(nmatch2, chi2ndofreco2)
&& chi2ndofreco1 < 4.
&& chi2ndofreco2 < 4.
&& massCut(minvreco) )
{ ynreco=true;}
}
else {
if (isPtCut) { if (!(pt >1. && pt<15. ) ) continue; }
/// define IP
lxy = TMath::Sqrt((vtxz-bx)*(vtxz-bx)+(vtxy-by)*(vtxy-by));
if ( (!isEmbedded)
&& TMath::Abs(eta) < 2.4
&& TMath::Abs(idparent)>442
&& TMath::Abs(idparent)<550
&& idCut(npixelhits,nmuonhits) )
{ yngen=true; }
else if ( isEmbedded
&& TMath::Abs(eta) < 2.4
//&& TMath::Abs(idparent)>442
//&& TMath::Abs(idparent)<550
&& idCut(npixelhits,nmuonhits) )
{ yngen=true; }
if ( (!isEmbedded)
//TMath::Abs(etareco) < 2.4
&& TMath::Abs(eta) < 2.4
&& TMath::Abs(idparent)>442
&& TMath::Abs(idparent)<550
&& idCut(nvalidpixelhitsreco,nvalidmuonhitsreco)
&& idRecoCut(nmatch, chi2ndofreco) )
{ ynreco=true;}
else if ( isEmbedded
//TMath::Abs(etareco) < 2.4
&& TMath::Abs(eta) < 2.4
//&& TMath::Abs(idparent)>442
//&& TMath::Abs(idparent)<550
&& idCut(nvalidpixelhitsreco,nvalidmuonhitsreco)
&& idRecoCut(nmatch, chi2ndofreco) )
{ ynreco=true;}
}
/// weight if "doWeight" && fill the histogram
if (isPair){
if (doWeight) {weightF = getWeight(isPrompt, isPair, pt,y);}
// cout << "weightF = " <<weightF << endl;
if (yngen) {
hGenPtY->Fill(y,pt,weightF);
hGenPt->Fill(pt,weightF);
hGenRap->Fill(y,weightF);
hGenLxy->Fill(lxy,weightF);
}
if (ynreco) {
hRecoPtY->Fill(yreco,ptreco,weightF);
hRecoPt->Fill(ptreco, weightF);
hRecoRap->Fill(yreco, weightF);
hRecoLxy->Fill(lxy, weightF);
}
}else {
if (doWeight) {weightF = getWeight(isPrompt, isPair, pt,eta);}
// cout << "weightF = " <<weightF << endl;
if (yngen) {
hGenPtY->Fill(eta,pt,weightF);
hGenPt->Fill(pt,weightF);
hGenRap->Fill(eta,weightF);
hGenLxy->Fill(lxy,weightF);
}
if (ynreco) {
hRecoPtY->Fill(etareco,ptreco,weightF);
hRecoPt->Fill(ptreco,weightF);
hRecoRap->Fill(etareco,weightF);
hRecoLxy->Fill(lxy, weightF);
}
}
}// end of event loop
cout << "hGenPt integral = " << hGenPt->Integral() << endl;
cout << "hRecoPt integral = " << hRecoPt->Integral() << endl;
cout << "hGenRap integral = " << hGenRap->Integral() << endl;
cout << "hRecoRap integral = " << hRecoRap->Integral() << endl;
cout << "hGenLxy integral = " << hGenLxy->Integral() << endl;
cout << "hRecoLxy integral = " << hRecoLxy->Integral() << endl;
//calculate efficiency
hEffPtY->Divide(hRecoPtY,hGenPtY,1,1,"b");
hEffPt->Divide(hRecoPt,hGenPt,1,1,"b");
hEffRap->Divide(hRecoRap,hGenRap,1,1,"b");
hEffLxy->Divide(hRecoLxy,hGenLxy,1,1,"b");
//Legend
TLegend *legUR = new TLegend(0.56,0.68,0.90,0.90,NULL,"brNDC");
TLegend *legUL = new TLegend(0.17,0.68,0.51,0.90,NULL,"brNDC");
TLegend *legBM = new TLegend(0.40,0.20,0.75,0.35,NULL,"brNDC");
TLegend *legBR = new TLegend(0.56,0.20,0.90,0.42,NULL,"brNDC");
SetLegendStyle(legUR);
SetLegendStyle(legUL);
SetLegendStyle(legBM);
SetLegendStyle(legBR);
TCanvas *c1 = new TCanvas("c1","c1",600,600);
//draw 2D Pt-y
TPaletteAxis* pal;
hEffPtY->SetMinimum(0.0);
hEffPtY->SetMaximum(1.0);
if (isPair) hEffPtY->GetXaxis()->SetTitle("y");
else hEffPtY->GetXaxis()->SetTitle("#eta");
hEffPtY->GetXaxis()->CenterTitle();
hEffPtY->GetYaxis()->SetTitle("p_{T} (GeV)");
hEffPtY->Draw("colz");
c1->Update();
pal = (TPaletteAxis*)hEffPtY->GetListOfFunctions()->FindObject("palette");
pal->SetX2NDC(0.92);
c1->Modified();
c1->Update();
c1->SaveAs(Form("%s/EffPtY_isPtCut%d_doWeight%d_isEmbedded%d_%s_%s_%s.pdf",strDir.c_str(),(int)isPtCut,(int)doWeight,(int)isEmbedded,strPrompt.c_str(),strEmbd.c_str(),strPair.c_str()));
c1->Clear();
//draw EffPt
SetHistStyle(hEffPt,3,0);
hEffPt->SetMinimum(0.0);
hEffPt->SetMaximum(1.0);
if (isPair) hEffPt->GetXaxis()->SetTitle("Pair p_{T} (GeV)");
else hEffPt->GetXaxis()->SetTitle("Trk p_{T} (GeV)");
hEffPt->GetYaxis()->SetTitle("Efficiency");
hEffPt->Draw("pe");
c1->SaveAs(Form("%s/EffPt_isPtCut%d_doWeight%d_isEmbedded%d_%s_%s_%s.pdf",strDir.c_str(),(int)isPtCut,(int)doWeight,(int)isEmbedded,strPrompt.c_str(),strEmbd.c_str(),strPair.c_str()));
c1->Clear();
//draw EffRap
SetHistStyle(hEffRap,3,0);
hEffRap->SetMinimum(0.0);
hEffRap->SetMaximum(1.0);
if (isPair) hEffRap->GetXaxis()->SetTitle("y");
else hEffRap->GetXaxis()->SetTitle("#eta");
hEffRap->GetXaxis()->CenterTitle();
hEffRap->GetYaxis()->SetTitle("Efficiency");
hEffRap->Draw("pe");
c1->SaveAs(Form("%s/EffRap_isPtCut%d_doWeight%d_isEmbedded%d_%s_%s_%s.pdf",strDir.c_str(),(int)isPtCut,(int)doWeight,(int)isEmbedded,strPrompt.c_str(),strEmbd.c_str(),strPair.c_str()));
c1->Clear();
//draw EffLxy
SetHistStyle(hEffLxy,3,0);
hEffLxy->SetMinimum(0.0);
hEffLxy->SetMaximum(1.0);
hEffLxy->GetXaxis()->SetTitle("Lxy");
hEffLxy->GetYaxis()->SetTitle("Efficiency");
hEffLxy->Draw("pe");
c1->SaveAs(Form("%s/EffLxy_isPtCut%d_doWeight%d_isEmbedded%d_%s_%s_%s.pdf",strDir.c_str(),(int)isPtCut,(int)doWeight,(int)isEmbedded,strPrompt.c_str(),strEmbd.c_str(),strPair.c_str()));
c1->Clear();
//save as a root file
TFile* outFile = new TFile(Form("%s/Eff_isPtCut%d_doWeight%d_isEmbedded%d_%s_%s_%s.root",strDir.c_str(),(int)isPtCut,(int)doWeight,(int)isEmbedded,strPrompt.c_str(),strEmbd.c_str(),strPair.c_str()),"RECREATE");
outFile->cd();
hGenPtY->Write();
hRecoPtY->Write();
hEffPtY->Write();
hGenPt->Write();
hGenRap->Write();
hGenLxy->Write();
hRecoPt->Write();
hRecoRap->Write();
hRecoLxy->Write();
hEffPt->Write();
hEffRap->Write();
hEffLxy->Write();
outFile->Close();
return;
}
// input: - Input file (result from TMVA),
// - use of colors or grey scale
// - use of TMVA plotting TStyle
void correlations( TString fin = "TMVA.root",TString outputdir="plots", Bool_t isRegression = kFALSE,
Bool_t greyScale = kFALSE, Bool_t useTMVAStyle = kTRUE )
{
// set style and remove existing canvas'
TMVAGlob::Initialize( useTMVAStyle );
// checks if file with name "fin" is already open, and if not opens one
TFile* file = TMVAGlob::OpenFile( fin );
// signal and background or regression problem
Int_t ncls = (isRegression ? 1 : 2 );
TString hName[2] = { "CorrelationMatrixS", "CorrelationMatrixB" };
if (isRegression) hName[0]= "CorrelationMatrix";
const Int_t width = 600;
for (Int_t ic=0; ic<ncls; ic++) {
TH2* h2 = file->Get( hName[ic] );
if(!h2) {
cout << "Did not find histogram " << hName[ic] << " in " << fin << endl;
continue;
}
TCanvas* c = new TCanvas( hName[ic],
Form("Correlations between MVA input variables (%s)",
(isRegression ? "" : (ic==0 ? "signal" : "background"))),
ic*(width+5)+200, 0, width, width );
Float_t newMargin1 = 0.13;
Float_t newMargin2 = 0.15;
if (TMVAGlob::UsePaperStyle) newMargin2 = 0.13;
c->SetGrid();
c->SetTicks();
c->SetLeftMargin ( newMargin2 );
c->SetBottomMargin( newMargin2 );
c->SetRightMargin ( newMargin1 );
c->SetTopMargin ( newMargin1 );
gStyle->SetPalette( 1, 0 );
gStyle->SetPaintTextFormat( "3g" );
h2->SetMarkerSize( 1.5 );
h2->SetMarkerColor( 0 );
Float_t labelSize = 0.040;
h2->GetXaxis()->SetLabelSize( labelSize );
h2->GetYaxis()->SetLabelSize( labelSize );
h2->LabelsOption( "d" );
h2->SetLabelOffset( 0.011 );// label offset on x axis
h2->Draw("colz"); // color pads
c->Update();
// modify properties of paletteAxis
TPaletteAxis* paletteAxis = (TPaletteAxis*)h2->GetListOfFunctions()->FindObject( "palette" );
paletteAxis->SetLabelSize( 0.03 );
paletteAxis->SetX1NDC( paletteAxis->GetX1NDC() + 0.02 );
h2->Draw("textsame"); // add text
// add comment
TText* t = new TText( 0.53, 0.88, "Linear correlation coefficients in %" );
t->SetNDC();
t->SetTextSize( 0.026 );
t->AppendPad();
// TMVAGlob::plot_logo( );
c->Update();
TString fname = outputdir + TString("/");
fname += hName[ic];
TMVAGlob::imgconv( c, fname );
}
}
void BinCovarianceHggRazor()
{
//=========Macro generated from canvas: c1/c1
//========= (Thu Mar 16 13:20:44 2017) by ROOT version6.08/00
TCanvas *c1 = new TCanvas("c1", "c1",624,156,1045,740);
c1->Range(-2.904762,-4.218216,21.92857,21.55977);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetBorderSize(2);
c1->SetLeftMargin(0.1169703);
c1->SetRightMargin(0.117929);
c1->SetBottomMargin(0.1636364);
c1->SetFrameBorderMode(0);
c1->SetFrameBorderMode(0);
TH2F *corr = new TH2F("corr","Background Covariance Matrix",19,0,19,19,0,19);
corr->SetBinContent(22,7.200001);
corr->SetBinContent(23,0.2672915);
corr->SetBinContent(24,0.001625223);
corr->SetBinContent(25,3.449828);
corr->SetBinContent(26,2.003306);
corr->SetBinContent(27,-0.1299037);
corr->SetBinContent(28,1.094266);
corr->SetBinContent(29,0.6026603);
corr->SetBinContent(30,0.3772124);
corr->SetBinContent(31,4.398799);
corr->SetBinContent(32,0.5182461);
corr->SetBinContent(33,0.4639761);
corr->SetBinContent(34,-1.045344);
corr->SetBinContent(35,-0.1582571);
corr->SetBinContent(36,3.917425);
corr->SetBinContent(37,0.3293888);
corr->SetBinContent(38,0.5363065);
corr->SetBinContent(39,0.112652);
corr->SetBinContent(40,-0.4577291);
corr->SetBinContent(43,0.2672915);
corr->SetBinContent(44,7.06);
corr->SetBinContent(45,0.02738067);
corr->SetBinContent(46,10.20474);
corr->SetBinContent(47,1.258074);
corr->SetBinContent(48,0.2655874);
corr->SetBinContent(49,0.05856049);
corr->SetBinContent(50,0.1689017);
corr->SetBinContent(51,-0.203687);
corr->SetBinContent(52,-1.356623);
corr->SetBinContent(53,-0.1403674);
corr->SetBinContent(54,0.1150756);
corr->SetBinContent(55,-1.715165);
corr->SetBinContent(56,0.3716204);
corr->SetBinContent(57,1.576942);
corr->SetBinContent(58,0.4120814);
corr->SetBinContent(59,-0.5644981);
corr->SetBinContent(60,2.312829);
corr->SetBinContent(61,-0.1745173);
corr->SetBinContent(64,0.001625223);
corr->SetBinContent(65,0.02738067);
corr->SetBinContent(66,6.85);
corr->SetBinContent(67,2.261283);
corr->SetBinContent(68,1.963802);
corr->SetBinContent(69,0.0992774);
corr->SetBinContent(70,0.2134901);
corr->SetBinContent(71,0.4936861);
corr->SetBinContent(72,0.09001485);
corr->SetBinContent(73,3.081846);
corr->SetBinContent(74,-0.03320625);
corr->SetBinContent(75,0.02650541);
corr->SetBinContent(76,0.5989376);
corr->SetBinContent(77,0.2271089);
corr->SetBinContent(78,1.603218);
corr->SetBinContent(79,0.2573114);
corr->SetBinContent(80,-0.2396841);
corr->SetBinContent(81,-0.8127553);
corr->SetBinContent(82,0.8586979);
corr->SetBinContent(85,3.456811);
corr->SetBinContent(86,10.22542);
corr->SetBinContent(87,2.265859);
corr->SetBinContent(88,1809.14);
corr->SetBinContent(89,-1.012275);
corr->SetBinContent(90,6.697715);
corr->SetBinContent(91,9.605417);
corr->SetBinContent(92,-0.8592414);
corr->SetBinContent(93,4.409427);
corr->SetBinContent(94,54.40217);
corr->SetBinContent(95,-1.380551);
corr->SetBinContent(96,1.818917);
corr->SetBinContent(97,40.60707);
corr->SetBinContent(98,-3.56902);
corr->SetBinContent(99,106.0525);
corr->SetBinContent(100,-2.953686);
corr->SetBinContent(101,2.048589);
corr->SetBinContent(102,-36.2908);
corr->SetBinContent(103,4.93098);
corr->SetBinContent(106,2.007359);
corr->SetBinContent(107,1.260622);
corr->SetBinContent(108,1.967779);
corr->SetBinContent(109,-1.012275);
corr->SetBinContent(110,256.49);
corr->SetBinContent(111,1.281127);
corr->SetBinContent(112,2.073658);
corr->SetBinContent(113,2.264486);
corr->SetBinContent(114,-1.336645);
corr->SetBinContent(115,38.93255);
corr->SetBinContent(116,1.86029);
corr->SetBinContent(117,0.04544767);
corr->SetBinContent(118,28.44881);
corr->SetBinContent(119,-2.154541);
corr->SetBinContent(120,39.41811);
corr->SetBinContent(121,0.8762429);
corr->SetBinContent(122,5.192766);
corr->SetBinContent(123,6.060677);
corr->SetBinContent(124,2.462171);
corr->SetBinContent(127,-0.1299037);
corr->SetBinContent(128,0.2655874);
corr->SetBinContent(129,0.0992774);
corr->SetBinContent(130,6.68419);
corr->SetBinContent(131,1.278538);
corr->SetBinContent(132,7.25);
corr->SetBinContent(133,1.210454);
corr->SetBinContent(134,-0.2097035);
corr->SetBinContent(135,-8.765232e-05);
corr->SetBinContent(136,3.902545);
corr->SetBinContent(137,-0.3170787);
corr->SetBinContent(138,-0.5794553);
corr->SetBinContent(139,4.478106);
corr->SetBinContent(140,-0.4768105);
corr->SetBinContent(141,1.30636);
corr->SetBinContent(142,0.3664042);
corr->SetBinContent(143,-0.3664501);
corr->SetBinContent(144,1.077817);
corr->SetBinContent(145,-0.4731456);
corr->SetBinContent(148,1.073224);
corr->SetBinContent(149,0.05743426);
corr->SetBinContent(150,0.2093844);
corr->SetBinContent(151,9.40167);
corr->SetBinContent(152,2.029672);
corr->SetBinContent(153,1.187176);
corr->SetBinContent(154,24.93);
corr->SetBinContent(155,0.9106724);
corr->SetBinContent(156,0.005313865);
corr->SetBinContent(157,3.027986);
corr->SetBinContent(158,0.08652855);
corr->SetBinContent(159,0.1306128);
corr->SetBinContent(160,5.661592);
corr->SetBinContent(161,0.4646386);
corr->SetBinContent(162,-5.217519);
corr->SetBinContent(163,0.1571939);
corr->SetBinContent(164,1.094535);
corr->SetBinContent(165,2.11375);
corr->SetBinContent(166,0.776071);
corr->SetBinContent(169,0.6026603);
corr->SetBinContent(170,0.1689017);
corr->SetBinContent(171,0.4936861);
corr->SetBinContent(172,-0.8575042);
corr->SetBinContent(173,2.259912);
corr->SetBinContent(174,-0.2097035);
corr->SetBinContent(175,0.9285287);
corr->SetBinContent(176,12.01);
corr->SetBinContent(177,-0.4210026);
corr->SetBinContent(178,-7.775839);
corr->SetBinContent(179,-0.4606768);
corr->SetBinContent(180,0.2147063);
corr->SetBinContent(181,-1.253046);
corr->SetBinContent(182,0.3347198);
corr->SetBinContent(183,1.034227);
corr->SetBinContent(184,0.01147097);
corr->SetBinContent(185,0.09434997);
corr->SetBinContent(186,-0.4641604);
corr->SetBinContent(187,1.080481);
corr->SetBinContent(190,0.3772124);
corr->SetBinContent(191,-0.203687);
corr->SetBinContent(192,0.09001485);
corr->SetBinContent(193,4.40052);
corr->SetBinContent(194,-1.333945);
corr->SetBinContent(195,-8.765232e-05);
corr->SetBinContent(196,0.005417521);
corr->SetBinContent(197,-0.4210026);
corr->SetBinContent(198,9.769999);
corr->SetBinContent(199,-6.455331);
corr->SetBinContent(200,0.05779311);
corr->SetBinContent(201,-0.1471536);
corr->SetBinContent(202,-0.3639791);
corr->SetBinContent(203,-0.06047838);
corr->SetBinContent(204,-3.252086);
corr->SetBinContent(205,0.1885649);
corr->SetBinContent(206,0.6627039);
corr->SetBinContent(207,0.2928204);
corr->SetBinContent(208,-1.060261);
corr->SetBinContent(211,4.407704);
corr->SetBinContent(212,-1.35937);
corr->SetBinContent(213,3.088085);
corr->SetBinContent(214,54.40217);
corr->SetBinContent(215,38.93255);
corr->SetBinContent(216,3.910446);
corr->SetBinContent(217,3.093611);
corr->SetBinContent(218,-7.791583);
corr->SetBinContent(219,-6.468398);
corr->SetBinContent(220,857.89);
corr->SetBinContent(221,-0.5174752);
corr->SetBinContent(222,5.507917);
corr->SetBinContent(223,42.01412);
corr->SetBinContent(224,4.45688);
corr->SetBinContent(225,44.79397);
corr->SetBinContent(226,-4.060115);
corr->SetBinContent(227,-13.04204);
corr->SetBinContent(228,-29.73159);
corr->SetBinContent(229,-2.903305);
corr->SetBinContent(232,0.5182461);
corr->SetBinContent(233,-0.1403674);
corr->SetBinContent(234,-0.03320625);
corr->SetBinContent(235,-1.377762);
corr->SetBinContent(236,1.856531);
corr->SetBinContent(237,-0.3170787);
corr->SetBinContent(238,0.08822516);
corr->SetBinContent(239,-0.4606768);
corr->SetBinContent(240,0.05779311);
corr->SetBinContent(241,-0.5164298);
corr->SetBinContent(242,7.650001);
corr->SetBinContent(243,-0.1925722);
corr->SetBinContent(244,0.5093402);
corr->SetBinContent(245,-0.2442501);
corr->SetBinContent(246,-1.347253);
corr->SetBinContent(247,0.1364561);
corr->SetBinContent(248,-0.875925);
corr->SetBinContent(249,-2.778971);
corr->SetBinContent(250,-0.1065624);
corr->SetBinContent(253,0.4639761);
corr->SetBinContent(254,0.1150756);
corr->SetBinContent(255,0.02650541);
corr->SetBinContent(256,1.815242);
corr->SetBinContent(257,0.04535576);
corr->SetBinContent(258,-0.5794553);
corr->SetBinContent(259,0.1331737);
corr->SetBinContent(260,0.2147063);
corr->SetBinContent(261,-0.1471536);
corr->SetBinContent(262,5.496789);
corr->SetBinContent(263,-0.1925722);
corr->SetBinContent(264,21.32);
corr->SetBinContent(265,2.282518);
corr->SetBinContent(266,2.157221);
corr->SetBinContent(267,4.829895);
corr->SetBinContent(268,1.112747);
corr->SetBinContent(269,0.2784669);
corr->SetBinContent(270,3.753212);
corr->SetBinContent(271,1.591138);
corr->SetBinContent(274,-1.047459);
corr->SetBinContent(275,-1.718638);
corr->SetBinContent(276,0.6001508);
corr->SetBinContent(277,40.60707);
corr->SetBinContent(278,28.44881);
corr->SetBinContent(279,4.48717);
corr->SetBinContent(280,5.784283);
corr->SetBinContent(281,-1.255583);
corr->SetBinContent(282,-0.3647164);
corr->SetBinContent(283,42.01412);
corr->SetBinContent(284,0.510371);
corr->SetBinContent(285,2.287134);
corr->SetBinContent(286,641.45);
corr->SetBinContent(287,15.21948);
corr->SetBinContent(288,21.97221);
corr->SetBinContent(289,-1.498767);
corr->SetBinContent(290,-0.6768517);
corr->SetBinContent(291,20.97092);
corr->SetBinContent(292,-0.8102957);
corr->SetBinContent(295,-0.1582571);
corr->SetBinContent(296,0.3716204);
corr->SetBinContent(297,0.2271089);
corr->SetBinContent(298,-3.561811);
corr->SetBinContent(299,-2.150187);
corr->SetBinContent(300,-0.4768105);
corr->SetBinContent(301,0.473749);
corr->SetBinContent(302,0.3347198);
corr->SetBinContent(303,-0.06047838);
corr->SetBinContent(304,4.447877);
corr->SetBinContent(305,-0.2442501);
corr->SetBinContent(306,2.157221);
corr->SetBinContent(307,15.18873);
corr->SetBinContent(308,30.77);
corr->SetBinContent(309,2.766883);
corr->SetBinContent(310,-0.04555257);
corr->SetBinContent(311,-2.424916);
corr->SetBinContent(312,-3.012514);
corr->SetBinContent(313,2.505161);
corr->SetBinContent(316,3.925359);
corr->SetBinContent(317,1.580133);
corr->SetBinContent(318,1.606464);
corr->SetBinContent(319,106.0525);
corr->SetBinContent(320,39.41811);
corr->SetBinContent(321,1.309003);
corr->SetBinContent(322,-5.330599);
corr->SetBinContent(323,1.036319);
corr->SetBinContent(324,-3.25867);
corr->SetBinContent(325,44.79397);
corr->SetBinContent(326,-1.34998);
corr->SetBinContent(327,4.839672);
corr->SetBinContent(328,21.97221);
corr->SetBinContent(329,2.772484);
corr->SetBinContent(330,1073.14);
corr->SetBinContent(331,3.813272);
corr->SetBinContent(332,-6.864117);
corr->SetBinContent(333,25.17929);
corr->SetBinContent(334,8.678784);
corr->SetBinContent(337,0.3293888);
corr->SetBinContent(338,0.4120814);
corr->SetBinContent(339,0.2573114);
corr->SetBinContent(340,-2.947719);
corr->SetBinContent(341,0.8744726);
corr->SetBinContent(342,0.3664042);
corr->SetBinContent(343,0.1602762);
corr->SetBinContent(344,0.01147097);
corr->SetBinContent(345,0.1885649);
corr->SetBinContent(346,-4.051914);
corr->SetBinContent(347,0.1364561);
corr->SetBinContent(348,1.112747);
corr->SetBinContent(349,-1.495737);
corr->SetBinContent(350,-0.04555257);
corr->SetBinContent(351,3.805569);
corr->SetBinContent(352,9.09);
corr->SetBinContent(353,0.1903553);
corr->SetBinContent(354,0.5499064);
corr->SetBinContent(355,0.5727072);
corr->SetBinContent(358,0.5373924);
corr->SetBinContent(359,-0.5656406);
corr->SetBinContent(360,-0.2401691);
corr->SetBinContent(361,2.048589);
corr->SetBinContent(362,5.192766);
corr->SetBinContent(363,-0.367192);
corr->SetBinContent(364,1.118255);
corr->SetBinContent(365,0.09454096);
corr->SetBinContent(366,0.6640464);
corr->SetBinContent(367,-13.04204);
corr->SetBinContent(368,-0.8776976);
corr->SetBinContent(369,0.27903);
corr->SetBinContent(370,-0.6768517);
corr->SetBinContent(371,-2.429823);
corr->SetBinContent(372,-6.864117);
corr->SetBinContent(373,0.1907412);
corr->SetBinContent(374,109.6);
corr->SetBinContent(375,7.16569);
corr->SetBinContent(376,-1.180023);
corr->SetBinContent(379,0.1128808);
corr->SetBinContent(380,2.31751);
corr->SetBinContent(381,-0.814401);
corr->SetBinContent(382,-36.2908);
corr->SetBinContent(383,6.060677);
corr->SetBinContent(384,1.079998);
corr->SetBinContent(385,2.159559);
corr->SetBinContent(386,-0.4650993);
corr->SetBinContent(387,0.2934131);
corr->SetBinContent(388,-29.73159);
corr->SetBinContent(389,-2.784595);
corr->SetBinContent(390,3.760808);
corr->SetBinContent(391,20.97092);
corr->SetBinContent(392,-3.018612);
corr->SetBinContent(393,25.17929);
corr->SetBinContent(394,0.5510197);
corr->SetBinContent(395,7.16569);
corr->SetBinContent(396,254.5);
corr->SetBinContent(397,-1.087226);
corr->SetBinContent(400,-0.4577291);
corr->SetBinContent(401,-0.1745173);
corr->SetBinContent(402,0.8586979);
corr->SetBinContent(403,4.921021);
corr->SetBinContent(404,2.457195);
corr->SetBinContent(405,-0.4731456);
corr->SetBinContent(406,0.7912881);
corr->SetBinContent(407,1.080481);
corr->SetBinContent(408,-1.060261);
corr->SetBinContent(409,-2.89744);
corr->SetBinContent(410,-0.1065624);
corr->SetBinContent(411,1.591138);
corr->SetBinContent(412,-0.8086588);
corr->SetBinContent(413,2.505161);
corr->SetBinContent(414,8.661255);
corr->SetBinContent(415,0.5727072);
corr->SetBinContent(416,-1.17764);
corr->SetBinContent(417,-1.085029);
corr->SetBinContent(418,30.42);
corr->SetMinimum(-4000);
corr->SetMaximum(4000);
corr->SetEntries(361);
corr->SetStats(0);
corr->SetContour(20);
corr->SetContourLevel(0,-4000);
corr->SetContourLevel(1,-3600);
corr->SetContourLevel(2,-3200);
corr->SetContourLevel(3,-2800);
corr->SetContourLevel(4,-2400);
corr->SetContourLevel(5,-2000);
corr->SetContourLevel(6,-1600);
corr->SetContourLevel(7,-1200);
corr->SetContourLevel(8,-800);
corr->SetContourLevel(9,-400);
corr->SetContourLevel(10,0);
corr->SetContourLevel(11,400);
corr->SetContourLevel(12,800);
corr->SetContourLevel(13,1200);
corr->SetContourLevel(14,1600);
corr->SetContourLevel(15,2000);
corr->SetContourLevel(16,2400);
corr->SetContourLevel(17,2800);
corr->SetContourLevel(18,3200);
corr->SetContourLevel(19,3600);
TPaletteAxis *palette = new TPaletteAxis(19.11905,-0.7931685,20.2619,19.82922,corr);
palette->SetLabelColor(1);
palette->SetLabelFont(42);
palette->SetLabelOffset(0.005);
palette->SetLabelSize(0.035);
palette->SetTitleOffset(1);
palette->SetTitleSize(0.035);
Int_t ci; // for color index setting
TColor *color; // for color definition with alpha
ci = TColor::GetColor("#f9f90e");
palette->SetFillColor(ci);
palette->SetFillStyle(1001);
corr->GetListOfFunctions()->Add(palette,"br");
ci = TColor::GetColor("#000099");
corr->SetLineColor(ci);
corr->GetXaxis()->SetBinLabel(1,"Bin 0");
corr->GetXaxis()->SetBinLabel(2,"Bin 1");
corr->GetXaxis()->SetBinLabel(3,"Bin 2");
corr->GetXaxis()->SetBinLabel(4,"Bin 3");
corr->GetXaxis()->SetBinLabel(5,"Bin 4");
corr->GetXaxis()->SetBinLabel(6,"Bin 5");
corr->GetXaxis()->SetBinLabel(7,"Bin 6");
corr->GetXaxis()->SetBinLabel(8,"Bin 7");
corr->GetXaxis()->SetBinLabel(9,"Bin 8");
corr->GetXaxis()->SetBinLabel(10,"Bin 9 HighRes");
corr->GetXaxis()->SetBinLabel(11,"Bin 10 HighRes");
corr->GetXaxis()->SetBinLabel(12,"Bin 11 HighRes");
corr->GetXaxis()->SetBinLabel(13,"Bin 12 HighRes");
corr->GetXaxis()->SetBinLabel(14,"Bin 13 HighRes");
corr->GetXaxis()->SetBinLabel(15,"Bin 9 LowRes");
corr->GetXaxis()->SetBinLabel(16,"Bin 10 LowRes");
corr->GetXaxis()->SetBinLabel(17,"Bin 11 LowRes");
corr->GetXaxis()->SetBinLabel(18,"Bin 12 LowRes");
corr->GetXaxis()->SetBinLabel(19,"Bin 13 LowRes");
corr->GetXaxis()->SetBit(TAxis::kLabelsVert);
corr->GetXaxis()->SetLabelFont(42);
corr->GetXaxis()->SetLabelSize(0.035);
corr->GetXaxis()->SetTitleSize(0.035);
corr->GetXaxis()->SetTitleFont(42);
corr->GetYaxis()->SetBinLabel(1,"Bin 0");
corr->GetYaxis()->SetBinLabel(2,"Bin 1");
corr->GetYaxis()->SetBinLabel(3,"Bin 2");
corr->GetYaxis()->SetBinLabel(4,"Bin 3");
corr->GetYaxis()->SetBinLabel(5,"Bin 4");
corr->GetYaxis()->SetBinLabel(6,"Bin 5");
corr->GetYaxis()->SetBinLabel(7,"Bin 6");
corr->GetYaxis()->SetBinLabel(8,"Bin 7");
corr->GetYaxis()->SetBinLabel(9,"Bin 8");
corr->GetYaxis()->SetBinLabel(10,"Bin 9 HighRes");
corr->GetYaxis()->SetBinLabel(11,"Bin 10 HighRes");
corr->GetYaxis()->SetBinLabel(12,"Bin 11 HighRes");
corr->GetYaxis()->SetBinLabel(13,"Bin 12 HighRes");
corr->GetYaxis()->SetBinLabel(14,"Bin 13 HighRes");
corr->GetYaxis()->SetBinLabel(15,"Bin 9 LowRes");
corr->GetYaxis()->SetBinLabel(16,"Bin 10 LowRes");
corr->GetYaxis()->SetBinLabel(17,"Bin 11 LowRes");
corr->GetYaxis()->SetBinLabel(18,"Bin 12 LowRes");
corr->GetYaxis()->SetBinLabel(19,"Bin 13 LowRes");
corr->GetYaxis()->SetLabelFont(42);
corr->GetYaxis()->SetLabelSize(0.035);
corr->GetYaxis()->SetTitleSize(0.035);
corr->GetYaxis()->SetTitleFont(42);
corr->GetZaxis()->SetLabelFont(42);
corr->GetZaxis()->SetLabelSize(0.035);
corr->GetZaxis()->SetTitleSize(0.035);
corr->GetZaxis()->SetTitleFont(42);
corr->Draw("colz+text");
TPaveText *pt = new TPaveText(0.2371347,0.9343684,0.7628653,0.995,"blNDC");
pt->SetName("title");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextFont(42);
TText *AText = pt->AddText("Background Covariance Matrix");
pt->Draw();
c1->Modified();
c1->cd();
c1->SetSelected(c1);
}
void PlotEvolutionsWIII(const TString &sim, UInt_t mask = 3, const TString &options="png") {
#ifdef __CINT__
gSystem->Load("libptools.so");
#endif
string imask = DecToBin(mask);
cout << Form("\n Plotting Evolultion with mask: %s",imask.c_str()) << endl;
PGlobals::Initialize();
// Palettes!
gROOT->Macro("PPalettes.C");
TString opt = options;
// More makeup
Float_t margins[4] = {0.15,0.15,0.20,0.10};
gStyle->SetPadLeftMargin(margins[0]); // Margin left axis
gStyle->SetPadRightMargin(margins[2]);
gStyle->SetPadTopMargin(margins[3]); // Margin left axis
gStyle->SetPadBottomMargin(margins[1]);
gStyle->SetPadTickX(0);
gStyle->SetPadTickY(0);
if(opt.Contains("grid")) {
gStyle->SetPadGridX(1);
gStyle->SetPadGridY(1);
}
// Load first simulation data (for instance)
PData *pData = PData::Get(sim.Data());
Double_t E0 = pData->GetPlasmaE0();
Float_t maxEcross = -999.;
Float_t minEcross = 999.;
Float_t maxEextr = -999.;
Float_t minEextr = 999.;
Float_t maxEdephas = -999.;
Float_t minEdephas = 999.;
const Int_t Nfields = 2; // E_z, E_x
TH2F *hEvsTime[Nfields];
Int_t NCross[Nfields];
TGraph **gEcross[Nfields];
TGraph **gEextr[Nfields];
TGraph **gEdephas[Nfields];
TGraph *gTRatio;
TH2F *hFvsTime;
TGraph **gFcross = NULL;
TGraph **gFextr = NULL;
TH2F *hETvsTime;
TGraph **gETcross = NULL;
TGraph **gETextr = NULL;
TH2F *hVvsTime;
TGraph **gVcross = NULL;
TGraph **gVextr = NULL;
const Int_t NAtoms = 3;
char atNames[NAtoms][4] = {"H","He","He2"};
TH2F *hIonProbvsTime[NAtoms]; // For H, He and He+.
TGraph *gIonProb10[NAtoms];
TGraph *gIonProb100[NAtoms];
Float_t IonTh[NAtoms] = {33.8,92.75,234.96} ; // GV/m
// if(!opt.Contains("units"))
// for(Int_t i=0;i<NAtoms;i++) IonTh[i] /= ( E0 / (PUnits::GV/PUnits::m));
char hName[24];
char gName[24];
TString filename;
filename = Form("./%s/Plots/Evolutions/Evolutions-%s.root",sim.Data(),sim.Data());
TFile *ifile = (TFile*) gROOT->GetListOfFiles()->FindObject(filename.Data());
if (!ifile) ifile = new TFile(filename,"READ");
TH2F *hDen1DvsTime = NULL;
sprintf(hName,"hDenvsTime_1");
hDen1DvsTime = (TH2F*) ifile->Get(hName);
TH2F *hRmsvsTime = NULL;
sprintf(hName,"hRmsvsTime_1");
hRmsvsTime = (TH2F*) ifile->Get(hName);
for(Int_t i=0;i<Nfields;i++) {
sprintf(hName,"hEvsTime_%i",i);
hEvsTime[i] = (TH2F*) ifile->Get(hName);
if(!hEvsTime[i]) continue;
cout << Form("ANALYZING FIELD %i ...",i) << endl;
Int_t NTBins = hEvsTime[i]->GetNbinsX();
for(Int_t it=NTBins;it>0;it--) {
// 1D field at certain timestep "it".
TH1F *hE1D = (TH1F*) hEvsTime[i]->ProjectionY("_py",it,it);
Int_t MAXCROSS = 2;
Float_t *Cross = new Float_t[MAXCROSS];
Float_t *Extr = new Float_t[MAXCROSS];
memset(Cross,0,sizeof(Float_t)*MAXCROSS);
memset(Extr,0,sizeof(Float_t)*MAXCROSS);
Int_t auxNcross = PGlobals::HCrossings(hE1D,Cross,Extr,MAXCROSS,0.,0.);
// cout << Form(" -> Number of crossings for histogram \"%s\" : %i ",hE1D->GetName(),auxNcross) << endl;
// for(Int_t ic=0;ic<auxNcross;ic++) {
// cout << Form(" %2i: cross = %6.4f extreme = %6.4f", ic, Cross[ic], Extr[ic]) << endl;
// }
if(it==NTBins) {
NCross[i] = auxNcross;
gEcross[i] = new TGraph*[NCross[i]];
gEextr[i] = new TGraph*[NCross[i]];
for(Int_t ic = 0;ic<NCross[i];ic++) {
gEcross[i][ic] = new TGraph(NTBins);
sprintf(gName,"gEcross_%i_%i",i,ic);
gEcross[i][ic]->SetName(gName);
gEextr[i][ic] = new TGraph(NTBins);
sprintf(gName,"gEextr_%i_%i",i,ic);
gEextr[i][ic]->SetName(gName);
}
}
Float_t time = hEvsTime[i]->GetXaxis()->GetBinCenter(it);
// cout << Form("Time step %i (%.2f): %i crossings",it,time,NCross[i]) << endl;
for(Int_t ic=0;ic<NCross[i];ic++) {
// cout << Form(" - Adding %i crossing: cross = %6.4f extreme = %6.4f",ic,Cross[ic],Extr[ic]) << endl;
gEcross[i][ic]->SetPoint(it-1,time,Cross[ic]);
gEextr[i][ic]->SetPoint(it-1,time,Extr[ic]);
}
}
// Calculate the max and min of every crossing.
// Also calculates dephasing:
gEdephas[i] = new TGraph*[NCross[i]];
for(Int_t ic = 0;ic<NCross[i];ic++) {
Int_t Npoints = gEcross[i][ic]->GetN();
Double_t *yEcross = gEcross[i][ic]->GetY();
Double_t *yEextr = gEextr[i][ic]->GetY();
Double_t *xEextr = gEextr[i][ic]->GetX();
Double_t *yEdephas = new Double_t[Npoints];
for(Int_t j=0;j<Npoints;j++) {
yEdephas[j] = yEcross[j] - yEcross[0];
}
gEdephas[i][ic] = new TGraph(Npoints,xEextr,yEdephas);
sprintf(gName,"gEdephas_%i_%i",i,ic);
gEdephas[i][ic]->SetName(gName);
for(Int_t j=0;j<Npoints;j++) {
if(yEcross[j]>maxEcross)
maxEcross = yEcross[j];
if(yEcross[j]<minEcross)
minEcross = yEcross[j];
if(yEextr[j]>maxEextr)
maxEextr = yEextr[j];
if(yEextr[j]<minEextr)
minEextr = yEextr[j];
// Only takes into account the minimums of the accelerating field:
if(ic%2 || i!=0) continue;
if(yEdephas[j]>maxEdephas)
maxEdephas = yEdephas[j];
if(yEdephas[j]<minEdephas)
minEdephas = yEdephas[j];
}
}
}
// Transformer ratio vs time:
// Take the ratio of the minimum over the maximum of the first oscillation of the Ez.
{
Int_t Npoints = gEextr[0][1]->GetN();
Double_t *TR = new Double_t[Npoints];
Double_t *yExtrPrev = gEextr[0][0]->GetY();
Double_t *yExtr = gEextr[0][1]->GetY();
Double_t *xExtr = gEextr[0][1]->GetX();
for(Int_t j=0;j<Npoints;j++) {
TR[j] = TMath::Abs(yExtr[j]/yExtrPrev[j]);
}
gTRatio = new TGraph(Npoints,xExtr,TR);
sprintf(gName,"gTRatio");
gTRatio->SetName(gName);
}
sprintf(hName,"hVvsTime");
hVvsTime = (TH2F*) ifile->Get(hName);
Int_t NVCross = 0;
cout << Form("ANALYZING POTENTIAL") << endl;
Int_t NTBins = hVvsTime->GetNbinsX();
for(Int_t it=NTBins;it>0;it--) {
// 1D field at certain timestep "it".
TH1F *hV1D = (TH1F*) hVvsTime->ProjectionY("_py",it,it);
Int_t MAXCROSS = 2;
Float_t *Cross = new Float_t[MAXCROSS];
Float_t *Extr = new Float_t[MAXCROSS];
memset(Cross,0,sizeof(Float_t)*MAXCROSS);
memset(Extr,0,sizeof(Float_t)*MAXCROSS);
Int_t auxNcross = PGlobals::HCrossings(hV1D,Cross,Extr,MAXCROSS,0.,20.);
// cout << Form(" -> Number of crossings for histogram \"%s\" : %i ",hV1D->GetName(),auxNcross) << endl;
// for(Int_t ic=0;ic<auxNcross;ic++) {
// cout << Form(" %2i: cross = %6.4f extreme = %6.4f", ic, Cross[ic], Extr[ic]) << endl;
// }
if(it==NTBins) {
NVCross = auxNcross;
gVcross = new TGraph*[NVCross];
gVextr = new TGraph*[NVCross];
for(Int_t ic = 0;ic<NVCross;ic++) {
gVcross[ic] = new TGraph(NTBins);
sprintf(gName,"gVcross_%i",ic);
gVcross[ic]->SetName(gName);
gVextr[ic] = new TGraph(NTBins);
sprintf(gName,"gVextr_%i",ic);
gVextr[ic]->SetName(gName);
}
}
Float_t time = hVvsTime->GetXaxis()->GetBinCenter(it);
// cout << Form("Time step %i (%.2f): %i crossings",it,time,NVCross) << endl;
for(Int_t ic=0;ic<NVCross;ic++) {
// cout << Form(" - Adding %i crossing: cross = %6.4f extreme = %6.4f",ic,Cross[ic],Extr[ic]) << endl;
gVcross[ic]->SetPoint(it-1,time,Cross[ic]);
gVextr[ic]->SetPoint(it-1,time,Extr[ic]);
}
}
sprintf(hName,"hETotalvsTime");
hETvsTime = (TH2F*) ifile->Get(hName);
Int_t NETCross = 0;
cout << Form("ANALYZING TOTAL ELECTRIC FIELD") << endl;
NTBins = hETvsTime->GetNbinsX();
for(Int_t it=NTBins;it>0;it--) {
// 1D field at certain timestep "it".
TH1F *hET1D = (TH1F*) hETvsTime->ProjectionY("_py",it,it);
Int_t MAXCROSS = 2;
Float_t *Cross = new Float_t[MAXCROSS];
Float_t *Extr = new Float_t[MAXCROSS];
memset(Cross,0,sizeof(Float_t)*MAXCROSS);
memset(Extr,0,sizeof(Float_t)*MAXCROSS);
Float_t baseline = 0.5;
if(opt.Contains("units"))
baseline *= E0 / (PUnits::GV/PUnits::m);
Int_t auxNcross = PGlobals::HCrossings(hET1D,Cross,Extr,MAXCROSS,baseline,-999,-999,"cum");
// cout << Form(" -> Number of crossings for histogram \"%s\" : %i ",hET1D->GetName(),auxNcross) << endl;
// for(Int_t ic=0;ic<auxNcross;ic++) {
// cout << Form(" %2i: cross = %6.4f extreme = %6.4f", ic, Cross[ic], Extr[ic]) << endl;
// }
if(it==NTBins) {
NETCross = auxNcross;
gETcross = new TGraph*[NETCross];
gETextr = new TGraph*[NETCross];
for(Int_t ic = 0;ic<NETCross;ic++) {
gETcross[ic] = new TGraph(NTBins);
sprintf(gName,"gETcross_%i",ic);
gETcross[ic]->SetName(gName);
gETextr[ic] = new TGraph(NTBins);
sprintf(gName,"gETextr_%i",ic);
gETextr[ic]->SetName(gName);
}
}
Float_t time = hETvsTime->GetXaxis()->GetBinCenter(it);
// if(it==1)
// cout << Form("Time step %i (%.2f): %i crossings",it,time,NETCross) << endl;
for(Int_t ic=0;ic<NETCross;ic++) {
//if(it==1)
// cout << Form(" - Adding %i crossing: cross = %6.4f extreme = %6.4f",ic,Cross[ic],Extr[ic]) << endl;
gETcross[ic]->SetPoint(it-1,time,Cross[ic]);
gETextr[ic]->SetPoint(it-1,time,Extr[ic]);
}
}
sprintf(hName,"hFocusvsTime");
hFvsTime = (TH2F*) ifile->Get(hName);
Int_t NFCross = 0;
cout << Form("ANALYZING FOCUSING") << endl;
NTBins = hFvsTime->GetNbinsX();
for(Int_t it=NTBins;it>0;it--) {
// 1D field at certain timestep "it".
TH1F *hF1D = (TH1F*) hFvsTime->ProjectionY("_py",it,it);
Int_t MAXCROSS = 2;
Float_t *Cross = new Float_t[MAXCROSS];
Float_t *Extr = new Float_t[MAXCROSS];
memset(Cross,0,sizeof(Float_t)*MAXCROSS);
memset(Extr,0,sizeof(Float_t)*MAXCROSS);
Int_t auxNcross = PGlobals::HCrossings(hF1D,Cross,Extr,MAXCROSS,0.,0.);
// cout << Form(" -> Number of crossings for histogram \"%s\" : %i ",hF1D->GetName(),auxNcross) << endl;
// for(Int_t ic=0;ic<auxNcross;ic++) {
// cout << Form(" %2i: cross = %6.4f extreme = %6.4f", ic, Cross[ic], Extr[ic]) << endl;
// }
if(it==NTBins) {
NFCross = auxNcross;
gFcross = new TGraph*[NFCross];
gFextr = new TGraph*[NFCross];
for(Int_t ic = 0;ic<NFCross;ic++) {
gFcross[ic] = new TGraph(NTBins);
sprintf(gName,"gFcross_%i",ic);
gFcross[ic]->SetName(gName);
gFextr[ic] = new TGraph(NTBins);
sprintf(gName,"gFextr_%i",ic);
gFextr[ic]->SetName(gName);
}
}
Float_t time = hFvsTime->GetXaxis()->GetBinCenter(it);
// cout << Form("Time step %i (%.2f): %i crossings",it,time,NFCross) << endl;
for(Int_t ic=0;ic<NFCross;ic++) {
// cout << Form(" - Adding %i crossing: cross = %6.4f extreme = %6.4f",ic,Cross[ic],Extr[ic]) << endl;
gFcross[ic]->SetPoint(it-1,time,Cross[ic]);
gFextr[ic]->SetPoint(it-1,time,Extr[ic]);
}
}
for(Int_t i=0;i<NAtoms;i++) {
sprintf(hName,"hIonProbvsTime_%s",atNames[i]);
hIonProbvsTime[i] = (TH2F*) ifile->Get(hName);
if(!hIonProbvsTime[i]) continue;
cout << Form("ANALYZING Ionization probability %i ...",i) << endl;
Int_t NTBins = hIonProbvsTime[i]->GetNbinsX();
for(Int_t it=NTBins;it>0;it--) {
// 1D field at certain timestep "it".
TH1F *hIonProb1D = (TH1F*) hIonProbvsTime[i]->ProjectionY("_py",it,it);
Int_t MAXCROSS = 2;
Float_t *Cross = new Float_t[MAXCROSS];
Float_t *Extr = new Float_t[MAXCROSS];
memset(Cross,0,sizeof(Float_t)*MAXCROSS);
memset(Extr,0,sizeof(Float_t)*MAXCROSS);
Int_t auxNcross = PGlobals::HCrossings(hIonProb1D,Cross,Extr,MAXCROSS,10.0);
if(it==NTBins) {
gIonProb10[i] = new TGraph(NTBins);
sprintf(gName,"gIonProb10_%i",i);
gIonProb10[i]->SetName(gName);
}
Float_t time = hIonProbvsTime[i]->GetXaxis()->GetBinCenter(it);
gIonProb10[i]->SetPoint(it-1,time,Cross[0]);
memset(Cross,0,sizeof(Float_t)*MAXCROSS);
memset(Extr,0,sizeof(Float_t)*MAXCROSS);
auxNcross = PGlobals::HCrossings(hIonProb1D,Cross,Extr,MAXCROSS,99.0);
if(it==NTBins) {
gIonProb100[i] = new TGraph(NTBins);
sprintf(gName,"gIonProb100_%i",i);
gIonProb100[i]->SetName(gName);
}
gIonProb100[i]->SetPoint(it-1,time,Cross[0]);
}
}
// Set the color of the different evolutions according to a palette
// UInt_t np = 50;
// PPalette * colorPalette = (PPalette*) gROOT->FindObject("colorPalette");
// if(!colorPalette) {
// const UInt_t Number = 3;
// Double_t Red[Number] = { 1.00, 0.00, 0.00};
// Double_t Green[Number] = { 0.00, 1.00, 0.00};
// Double_t Blue[Number] = { 1.00, 0.00, 1.00};
// Double_t Length[Number] = { 0.00, 0.50, 1.00 };
// colorPalette = new PPalette("colorPalette");
// colorPalette->CreateGradientColorTable(Number,Length,Red,Green,Blue,np);
// }
// for(Int_t i=0;i<Nfields;i++) {
// for(Int_t ic=0;ic<Ncross;ic++) {
// Float_t step = (np/Nosc);
// Int_t icolor = TMath::Nint( ((ic+1)/2) * step - 1 );
// gEextr[i][ic]->SetLineColor(colorPalette->GetColor(icolor));
// gEextr[i][ic]->SetLineWidth(2);
// gEdephas[i][ic]->SetLineColor(colorPalette->GetColor(icolor));
// gEdephas[i][ic]->SetLineWidth(2);
// }
// }
// --------------------------------------------------------------------------
// Manual coloring:
const Int_t NCOLORS = 5;
// Int_t colors[NCOLORS] = {kMagenta+2,kRed,kBlue,kYellow+2,kCyan+2};
Int_t colors[NCOLORS] = {kGray+3,kGray+2,kGray+1,kGray};
for(Int_t i=0;i<Nfields;i++) {
for(Int_t ic=0;ic<NCross[i];ic++) {
if( !gEcross[i][ic] || !gEextr[i][ic] ) continue;
Int_t index = ic/2;
if(index>=NCOLORS) index = NCOLORS-1;
gEcross[i][ic]->SetLineColor(colors[index]);
gEextr[i][ic]->SetLineColor(colors[index]);
gEextr[i][ic]->SetLineWidth(1);
gEdephas[i][ic]->SetLineColor(colors[index]);
gEdephas[i][ic]->SetLineWidth(1);
// cout << "EEEOOO" << endl;
// if(ic%2) {
// gEcross[i][ic]->SetLineStyle(2);
// gEextr[i][ic]->SetLineStyle(2);
// gEdephas[i][ic]->SetLineStyle(2);
// } else {
// gEcross[i][ic]->SetLineStyle(1);
// gEextr[i][ic]->SetLineStyle(1);
// gEdephas[i][ic]->SetLineStyle(1);
// }
}
}
for(Int_t ic = 0;ic<NFCross;ic++) {
// Graph's attributes
Int_t index = ic/2;
if(index>=NCOLORS) index = NCOLORS-1;
gFcross[ic]->SetLineColor(colors[index]);
if(ic%2-1) {
gFcross[ic]->SetLineStyle(2);
gFextr[ic]->SetLineStyle(2);
} else {
gFcross[ic]->SetLineStyle(1);
gFextr[ic]->SetLineStyle(1);
}
}
for(Int_t ic = 0;ic<NVCross;ic++) {
// Graph's attributes
Int_t index = ic/2;
if(index>=NCOLORS) index = NCOLORS-1;
gVcross[ic]->SetLineColor(colors[index]);
gVcross[ic]->SetLineStyle(3);
gVextr[ic]->SetLineStyle(1);
}
for(Int_t ic = 0;ic<NETCross;ic++) {
// Graph's attributes
Int_t index = ic/2;
if(index>=NCOLORS) index = NCOLORS-1;
gETcross[ic]->SetLineColor(colors[index]);
if(ic%2-1) {
gETcross[ic]->SetLineStyle(2);
gETextr[ic]->SetLineStyle(2);
} else {
gETcross[ic]->SetLineStyle(1);
gETextr[ic]->SetLineStyle(1);
}
}
for(Int_t i=0;i<NAtoms;i++) {
gIonProb10[i]->SetLineStyle(2);
gIonProb10[i]->SetLineColor(kGray+2);
gIonProb100[i]->SetLineStyle(1);
gIonProb100[i]->SetLineColor(kGray+2);
}
// Plotting
// ------------------------------------------------------------
// Canvas setup
UInt_t NPad = BitCounter(mask);
if(NPad==0) NPad = 1;
Float_t ypadsize = 250;
Float_t ymarginsize = 200;
if(NPad==1) ypadsize = 300;
Float_t ysize = ypadsize * NPad + ymarginsize;
Float_t boom = 1.2;
if(opt.Contains("boom"))
ysize *= boom;
TCanvas *C = new TCanvas("C","Snapshot",1050,ysize);
C->SetFillStyle(4000);
UInt_t lineColor = kOrange+10;
//UInt_t lineColor = TColor::GetColor(196,30,78);
// Setup Pad layout:
TPad **pad = new TPad*[NPad];
TH2F **hFrame = new TH2F*[NPad];
Float_t bMargin = 0.12 * (950/ysize);
Float_t tMargin = 0.04 * (950/ysize);
Float_t lMargin = 0.14;
Float_t rMargin = 0.18;
Float_t mMargin = 0.015 * (950/ysize);
Float_t pfactor = 1.0;
if(opt.Contains("nomar"))
bMargin = tMargin = lMargin = rMargin = mMargin = 0.0;
if(NPad==1)
PGlobals::CanvasPartition(C,NPad,lMargin,rMargin,bMargin,tMargin,mMargin);
else
PGlobals::CanvasAsymPartition(C,NPad,lMargin,rMargin,bMargin,tMargin,pfactor,mMargin);
// Define the frames for plotting
Int_t fonttype = 43;
Int_t fontsize = 32;
Int_t tfontsize = 38;
Int_t txsize = tfontsize+6;
Int_t lxsize = fontsize;
Int_t tysize = tfontsize;
Int_t lysize = fontsize-2;
Int_t tzsize = tfontsize-4;
Int_t lzsize = fontsize-2;
Float_t txoffset = (250/ypadsize) * 2.4 / (950/ysize);
Float_t lxoffset = 0.015;
Float_t tyoffset = 1.2 / (950/ysize);
Float_t lyoffset = 0.01;
Float_t tzoffset = 1.4 / (950/ysize);
Float_t lzoffset = 0.01;
Float_t tylength = 0.015;
Float_t txlength = 0.04;
for(Int_t i=NPad-1;i>=0;i--) {
char name[16];
sprintf(name,"pad_%i",i);
pad[i] = (TPad*) gROOT->FindObject(name);
pad[i]->SetFrameLineWidth(2);
pad[i]->SetTickx(1);
pad[i]->SetTicky(1);
if(opt.Contains("trans"))
pad[i]->SetFillStyle(4000);
pad[i]->SetFrameFillStyle(4000);
sprintf(name,"hFrame_%i",i);
hFrame[i] = (TH2F*) gROOT->FindObject(name);
if(hFrame[i]) delete hFrame[i];
hFrame[i] = (TH2F*) hEvsTime[0]->Clone(name);
hFrame[i]->Reset();
Float_t xFactor = pad[NPad-1]->GetAbsWNDC()/pad[i]->GetAbsWNDC();
Float_t yFactor = pad[NPad-1]->GetAbsHNDC()/pad[i]->GetAbsHNDC();
// Format for y axis
hFrame[i]->GetYaxis()->SetLabelFont(fonttype);
hFrame[i]->GetYaxis()->SetLabelSize(lysize);
hFrame[i]->GetYaxis()->SetLabelOffset(lyoffset);
hFrame[i]->GetYaxis()->SetTitleFont(fonttype);
hFrame[i]->GetYaxis()->SetTitleSize(tysize);
hFrame[i]->GetYaxis()->SetTitleOffset(tyoffset);
hFrame[i]->GetYaxis()->SetTickLength(xFactor*tylength/yFactor);
// Format for x axis
hFrame[i]->GetXaxis()->SetLabelFont(fonttype);
hFrame[i]->GetXaxis()->SetLabelSize(lxsize);
hFrame[i]->GetXaxis()->SetLabelOffset(lxoffset);
hFrame[i]->GetXaxis()->SetTitleFont(fonttype);
hFrame[i]->GetXaxis()->SetTitleSize(txsize);
hFrame[i]->GetXaxis()->SetTitleOffset(txoffset);
hFrame[i]->GetXaxis()->SetTickLength(yFactor*txlength/xFactor);
if(i>0) { // skip x axis labels except for the lowest one
hFrame[i]->GetXaxis()->SetLabelSize(0.0);
hFrame[i]->GetXaxis()->SetTitleSize(0.0);
}
if(opt.Contains("nomar")) {
hFrame[i]->GetYaxis()->SetTickLength(0.0);
hFrame[i]->GetXaxis()->SetTickLength(0.0);
}
// Labels for the frames
}
// Access to color Palettes
TExec *exPlasma = new TExec("exPlasma","plasmaPalette->cd();");
TExec *exElec = new TExec("exElec","electron0Palette->cd();");
TExec *exHot = new TExec("exHot","hotPalette->cd();");
TExec *exField = new TExec("exField","rbowwhitePalette->cd();");
TExec *exFieldT = new TExec("exFieldT","red0Palette->cd();");
TExec *exIonP = new TExec("exIonP","redelectron0Palette->cd();");
TExec *exPot = new TExec("exPot","rbowinvPalette->cd();");
// Actual Plotting!
// ------------------------------------------------------------
C->cd(0);
Float_t x1,x2,y1,y2;
Float_t gap = 0.01;
TPaletteAxis *palette = NULL;
UInt_t ip = NPad-1;
if(mask & 0x1) {
pad[ip]->Draw();
pad[ip]->cd();
if(opt.Contains("logz")) {
pad[ip]->SetLogz(1);
} else {
pad[ip]->SetLogz(0);
}
hFrame[ip]->Draw("col");
// hDen1DvsTime->GetZaxis()->SetNdivisions(503);
hDen1DvsTime->GetZaxis()->SetTitleFont(fonttype);
Float_t xFactor = pad[0]->GetAbsWNDC()/pad[ip]->GetAbsWNDC();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[ip]->GetAbsHNDC();
hDen1DvsTime->GetZaxis()->SetTickLength(xFactor*tylength/yFactor);
exElec->Draw();
hDen1DvsTime->Draw("colz same");
pad[ip]->Update();
y1 = pad[ip]->GetBottomMargin();
y2 = 1 - pad[ip]->GetTopMargin();
x1 = pad[ip]->GetLeftMargin();
x2 = 1 - pad[ip]->GetRightMargin();
palette = (TPaletteAxis*) hDen1DvsTime->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tzoffset);
palette->SetTitleSize(tzsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(lzsize);
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
pad[ip]->RedrawAxis();
ip--;
C->cd(0);
}
if(mask & 0x2) {
pad[ip]->Draw();
pad[ip]->cd();
if(opt.Contains("logz")) {
pad[ip]->SetLogz(1);
} else {
pad[ip]->SetLogz(0);
}
hFrame[ip]->Draw("col");
// hRmsvsTime->GetZaxis()->SetNdivisions(503);
hRmsvsTime->GetZaxis()->SetTitleFont(fonttype);
Float_t xFactor = pad[0]->GetAbsWNDC()/pad[ip]->GetAbsWNDC();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[ip]->GetAbsHNDC();
hRmsvsTime->GetZaxis()->SetTickLength(xFactor*tylength/yFactor);
exElec->Draw();
hRmsvsTime->Draw("colz same");
pad[ip]->Update();
y1 = pad[ip]->GetBottomMargin();
y2 = 1 - pad[ip]->GetTopMargin();
x1 = pad[ip]->GetLeftMargin();
x2 = 1 - pad[ip]->GetRightMargin();
palette = (TPaletteAxis*) hRmsvsTime->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tzoffset);
palette->SetTitleSize(tzsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(lzsize);
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
pad[ip]->RedrawAxis();
ip--;
C->cd(0);
}
if(mask & 0x4) {
pad[ip]->Draw();
pad[ip]->cd();
if(opt.Contains("logz")) {
pad[ip]->SetLogz(1);
} else {
pad[ip]->SetLogz(0);
}
hFrame[ip]->Draw("col");
// hEvsTime[0]->GetZaxis()->SetNdivisions(503);
hEvsTime[0]->GetZaxis()->SetTitleFont(fonttype);
Float_t xFactor = pad[0]->GetAbsWNDC()/pad[ip]->GetAbsWNDC();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[ip]->GetAbsHNDC();
hEvsTime[0]->GetZaxis()->SetTickLength(xFactor*tylength/yFactor);
exField->Draw();
hEvsTime[0]->Draw("colz same");
pad[ip]->Update();
y1 = pad[ip]->GetBottomMargin();
y2 = 1 - pad[ip]->GetTopMargin();
x1 = pad[ip]->GetLeftMargin();
x2 = 1 - pad[ip]->GetRightMargin();
palette = (TPaletteAxis*) hEvsTime[0]->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tzoffset);
palette->SetTitleSize(tzsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(lzsize);
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
if(!opt.Contains("nocross")) {
for(Int_t ic=0;ic<NVCross;ic++) {
if( gVcross[ic] )
gVcross[ic]->Draw("L");
}
if(gEcross[1][0]) {
gEcross[1][0]->SetLineStyle(4);
gEcross[1][0]->Draw("L");
}
}
pad[ip]->RedrawAxis();
ip--;
C->cd(0);
}
if(mask & 0x8) {
pad[ip]->Draw();
pad[ip]->cd();
if(opt.Contains("logz")) {
pad[ip]->SetLogz(1);
} else {
pad[ip]->SetLogz(0);
}
hFrame[ip]->Draw("col");
// hEvsTime[1]->GetZaxis()->SetNdivisions(503);
hEvsTime[1]->GetZaxis()->SetTitleFont(fonttype);
Float_t xFactor = pad[0]->GetAbsWNDC()/pad[ip]->GetAbsWNDC();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[ip]->GetAbsHNDC();
hEvsTime[1]->GetZaxis()->SetTickLength(xFactor*tylength/yFactor);
exField->Draw();
hEvsTime[1]->Draw("colz same");
pad[ip]->Update();
y1 = pad[ip]->GetBottomMargin();
y2 = 1 - pad[ip]->GetTopMargin();
x1 = pad[ip]->GetLeftMargin();
x2 = 1 - pad[ip]->GetRightMargin();
palette = (TPaletteAxis*) hEvsTime[1]->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tzoffset);
palette->SetTitleSize(tzsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(lzsize);
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
pad[ip]->RedrawAxis();
ip--;
C->cd(0);
}
if(mask & 0x10) {
pad[ip]->Draw();
pad[ip]->cd();
if(opt.Contains("logz")) {
pad[ip]->SetLogz(1);
} else {
pad[ip]->SetLogz(0);
}
hFrame[ip]->Draw("col");
// hETvsTime->GetZaxis()->SetNdivisions(503);
hETvsTime->GetZaxis()->SetTitleFont(fonttype);
Float_t xFactor = pad[0]->GetAbsWNDC()/pad[ip]->GetAbsWNDC();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[ip]->GetAbsHNDC();
hETvsTime->GetZaxis()->SetTickLength(xFactor*tylength/yFactor);
exFieldT->Draw();
hETvsTime->Draw("colz same");
pad[ip]->Update();
y1 = pad[ip]->GetBottomMargin();
y2 = 1 - pad[ip]->GetTopMargin();
x1 = pad[ip]->GetLeftMargin();
x2 = 1 - pad[ip]->GetRightMargin();
palette = (TPaletteAxis*) hETvsTime->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tzoffset);
palette->SetTitleSize(tzsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(lzsize);
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
if(!opt.Contains("nocross")) {
for(Int_t ic=0;ic<NVCross;ic++) {
if( gVcross[ic] )
gVcross[ic]->Draw("L");
}
if(gEcross[1][0]) {
gEcross[1][0]->SetLineStyle(4);
gEcross[1][0]->Draw("L");
}
}
pad[ip]->RedrawAxis();
ip--;
C->cd(0);
}
if(mask & 0x20) {
pad[ip]->Draw();
pad[ip]->cd();
if(opt.Contains("logz")) {
pad[ip]->SetLogz(1);
} else {
pad[ip]->SetLogz(0);
}
hFrame[ip]->Draw("col");
// hVvsTime->GetZaxis()->SetNdivisions(503);
hVvsTime->GetZaxis()->SetTitleFont(fonttype);
Float_t xFactor = pad[0]->GetAbsWNDC()/pad[ip]->GetAbsWNDC();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[ip]->GetAbsHNDC();
hVvsTime->GetZaxis()->SetTickLength(xFactor*tylength/yFactor);
exPot->Draw();
hVvsTime->Draw("colz same");
pad[ip]->Update();
y1 = pad[ip]->GetBottomMargin();
y2 = 1 - pad[ip]->GetTopMargin();
x1 = pad[ip]->GetLeftMargin();
x2 = 1 - pad[ip]->GetRightMargin();
palette = (TPaletteAxis*) hVvsTime->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tzoffset);
palette->SetTitleSize(tzsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(lzsize);
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
pad[ip]->RedrawAxis();
ip--;
C->cd(0);
}
if(mask & 0x40) {
pad[ip]->Draw();
pad[ip]->cd();
if(opt.Contains("logz")) {
pad[ip]->SetLogz(1);
} else {
pad[ip]->SetLogz(0);
}
hFrame[ip]->Draw("col");
hIonProbvsTime[1]->GetZaxis()->SetNdivisions(503);
hIonProbvsTime[1]->GetZaxis()->SetTitleFont(fonttype);
Float_t xFactor = pad[0]->GetAbsWNDC()/pad[ip]->GetAbsWNDC();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[ip]->GetAbsHNDC();
hIonProbvsTime[1]->GetZaxis()->SetTickLength(xFactor*tylength/yFactor);
hIonProbvsTime[1]->GetZaxis()->SetRangeUser(0.,0.12);
// exFieldT->Draw();
// exPlasma->Draw();
exIonP->Draw();
hIonProbvsTime[1]->Draw("colz same");
pad[ip]->Update();
y1 = pad[ip]->GetBottomMargin();
y2 = 1 - pad[ip]->GetTopMargin();
x1 = pad[ip]->GetLeftMargin();
x2 = 1 - pad[ip]->GetRightMargin();
palette = (TPaletteAxis*) hIonProbvsTime[1]->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tzoffset);
palette->SetTitleSize(tzsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(lzsize);
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
if(!opt.Contains("nocross")) {
for(Int_t ic=0;ic<NVCross;ic++) {
if( gVcross[ic] )
gVcross[ic]->Draw("L");
}
if(gEcross[1][0]) {
gEcross[1][0]->SetLineStyle(4);
gEcross[1][0]->Draw("L");
}
}
pad[ip]->RedrawAxis();
ip--;
C->cd(0);
}
// Print to a file
// Output file
TString fOutName = Form("./%s/Plots/Evolutions/Evolutions%s-WII-%s",sim.Data(),imask.c_str(),sim.Data());
PGlobals::imgconv(C,fOutName,opt);
// ---------------------------------------------------------
ifile->Close();
cout << endl;
}
void PlotRakeInjection( const TString &sim, Int_t zoom=2, Int_t Nbins=2, const TString &options="") {
#ifdef __CINT__
gSystem->Load("libplasma.so");
#endif
PlasmaGlob::Initialize();
// Palettes!
gROOT->Macro("PlasmaPalettes.C");
// Init Units table
PUnits::UnitsTable::Get();
TString opt = options;
// More makeup
gStyle->SetPadGridY(0);
if(opt.Contains("grid")) {
gStyle->SetPadGridX(1);
gStyle->SetPadGridY(1);
}
Bool_t CYL = kFALSE;
if(sim.Contains("cyl")) { CYL = kTRUE; opt += "cyl"; }
Bool_t ThreeD = kFALSE;
if(sim.Contains("3D")) ThreeD = kTRUE;
// Load PData
PData *pData = PData::Get(sim.Data());
// Create the canvas and the pads before the Frame loop
// Resolution:
Int_t sizex = 600;
Int_t sizey = 640;
if(opt.Contains("hres")) {
Int_t sizex = 1200;
Int_t sizey = 1280;
}
TCanvas *C1 = new TCanvas("C1","Evolution of Injection",sizex,sizey);
C1->cd();
// Palettes
TExec *exPlasma = new TExec("exPlasma","plasmaPalette->cd();");
TExec *exElec = new TExec("exElec","electronPalette->cd();");
TExec *exHot = new TExec("exHot","hotPalette->cd();");
const Int_t NFrames = 4;
// Int_t timestep[NFrames] = {18,22,26,34};
// TString sLabels[NFrames] = {"(a)","(b)","(c)","(d)"};
// Int_t timestep[NFrames] = {34,26,22,18};
Int_t timestep[NFrames] = {500,60,36,31};
TString sLabels[NFrames] = {"(d)","(c)","(b)","(a)"};
Float_t Time[NFrames] = {0.0};
TH2F ***hDen2D = new TH2F**[NFrames];
Float_t **zDenMax = new Float_t*[NFrames];
Float_t *zDenMaxTotal = NULL;
// Text objects
TPaveText **textTime = new TPaveText*[NFrames];
TPaveText **textLabel = new TPaveText*[NFrames];
TPad **pad = new TPad*[NFrames];
TH2F *hFrame[NFrames];
// C1->Divide(1,NFrames);
// Setup Pad layout:
Double_t lMargin = 0.15;
Double_t rMargin = 0.18;
Double_t bMargin = 0.10;
Double_t tMargin = 0.04;
Double_t vSpacing = 0.00;
Double_t hStep = (1.-lMargin-rMargin);
Double_t vStep = (1.- bMargin - tMargin - (NFrames-1) * vSpacing) / NFrames;
Float_t vposd = 0.0;
Float_t vposu = 0.0;
Float_t vmard = 0.0;
Float_t vmaru = 0.0;
Float_t vfactor = 0.0;
Float_t hposl = 0.0;
Float_t hposr = 1.0;
Float_t hmarl = lMargin;
Float_t hmarr = rMargin;
Float_t hfactor = 1.0;
Double_t n0,kp,skindepth,E0;
Int_t Nspecies;
for(Int_t k=0;k<NFrames;k++) {
pData->LoadFileNames(timestep[k]);
if(!pData->IsInit()) continue;
// Some plasma constants
n0 = pData->GetPlasmaDensity();
kp = pData->GetPlasmaK();
skindepth = 1.;
if(kp!=0.0) skindepth = 1/kp;
E0 = pData->GetPlasmaE0();
// Time in OU
Time[k] = 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[k] -= zStartPlasma;
if(opt.Contains("comov")) // Centers on the head of the beam.
Time[k] += zStartBeam;
}
// Get charge density histos
Nspecies = pData->NSpecies();
hDen2D[k] = new TH2F*[Nspecies];
zDenMax[k] = new Float_t[Nspecies];
if(k==0) zDenMaxTotal = new Float_t[Nspecies];
for(Int_t i=0;i<Nspecies;i++) {
hDen2D[k][i] = NULL;
if(k==0) zDenMaxTotal[i] = -999.;
if(!pData->GetChargeFileName(i))
continue;
char hName[24];
sprintf(hName,"hDen_%i_%i",k,i);
hDen2D[k][i] = (TH2F*) gROOT->FindObject(hName);
if(hDen2D[k][i]) delete hDen2D[k][i];
if(!ThreeD)
hDen2D[k][i] = pData->GetCharge(i,opt);
else
hDen2D[k][i] = pData->GetCharge2DSliceZY(i,-1,Nbins,opt+"avg");
hDen2D[k][i]->SetName(hName);
hDen2D[k][i]->GetXaxis()->CenterTitle();
hDen2D[k][i]->GetYaxis()->CenterTitle();
hDen2D[k][i]->GetZaxis()->CenterTitle();
zDenMax[k][i] = hDen2D[k][i]->GetMaximum();
if(zDenMax[k][i]>zDenMaxTotal[i])
zDenMaxTotal[i] = zDenMax[k][i];
// Changing to user units:
// --------------------------
if(opt.Contains("units") && n0) {
Int_t NbinsX = hDen2D[k][i]->GetNbinsX();
Float_t xMin = skindepth * hDen2D[k][i]->GetXaxis()->GetXmin() / PUnits::um;
Float_t xMax = skindepth * hDen2D[k][i]->GetXaxis()->GetXmax() / PUnits::um;
Int_t NbinsY = hDen2D[k][i]->GetNbinsY();
Float_t yMin = skindepth * hDen2D[k][i]->GetYaxis()->GetXmin() / PUnits::um;
Float_t yMax = skindepth * hDen2D[k][i]->GetYaxis()->GetXmax() / PUnits::um;
hDen2D[k][i]->SetBins(NbinsX,xMin,xMax,NbinsY,yMin,yMax);
hDen2D[k][i]->GetXaxis()->SetTitle("#zeta [#mum]");
} else {
hDen2D[k][i]->GetXaxis()->SetTitle("k_{p} #zeta");
}
// Zoom
Float_t range = (hDen2D[k][i]->GetYaxis()->GetXmax() - hDen2D[k][i]->GetYaxis()->GetXmin())/zoom;
Float_t midPoint = (hDen2D[k][i]->GetYaxis()->GetXmax() + hDen2D[k][i]->GetYaxis()->GetXmin())/2.;
Float_t yMin,yMax;
if(!CYL) {
yMin = midPoint-range/2;
yMax = midPoint+range/2;
} else {
yMin = 0.;
yMax = range;
}
hDen2D[k][i]->GetYaxis()->SetRangeUser(yMin,yMax);
}
}
Float_t density = 1;
Float_t Base = density;
Float_t *Max = new Float_t[Nspecies];
Float_t *Min = new Float_t[Nspecies];
for(Int_t k=0;k<NFrames;k++) {
// Set Z ranges:
for(Int_t i=0;i<Nspecies;i++) {
Max[i] = zDenMaxTotal[i];
Min[i] = 1.01E-1 * Base;
if(i==2) {
Min[i] = 1.01E-3 * Base;
Max[i] = zDenMax[k][i];
}
hDen2D[k][i]->GetZaxis()->SetRangeUser(Min[i],Max[i]);
if(i==0 && k==0) {
// Dynamic plasma palette
const Int_t plasmaDNRGBs = 3;
const Int_t plasmaDNCont = 128;
Double_t basePos = 0.5;
if(Max[i]!=Min[i]) {
if(opt.Contains("logz")) {
Float_t a = 1.0/(TMath::Log10(Max[i])-TMath::Log10(Min[i]));
Float_t b = TMath::Log10(Min[i]);
basePos = a*(TMath::Log10(Base) - b);
// cout << Form("Min = %f Base = %f Max = %f",a*(TMath::Log10(Min) - b),basePos,a*(TMath::Log10(Max) - b)) << endl;
} else {
basePos = (1.0/(Max[i]-Min[i]))*(Base - Min[i]);
}
}
Double_t plasmaDStops[plasmaDNRGBs] = { 0.00, basePos, 1.00 };
Double_t plasmaDRed[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
Double_t plasmaDGreen[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
Double_t plasmaDBlue[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
PPalette * plasmaPalette = (PPalette*) gROOT->FindObject("plasma");
plasmaPalette->CreateGradientColorTable(plasmaDNRGBs, plasmaDStops,
plasmaDRed, plasmaDGreen, plasmaDBlue, plasmaDNCont);
}
}
// PLOTTING!
if(k==0) {
vposd = 0.0;
vposu = bMargin + vStep;
vfactor = vposu-vposd;
vmard = bMargin / vfactor;
vmaru = 0.0;
} else if(k == NFrames-1) {
vposd = vposu + vSpacing;
vposu = vposd + vStep + tMargin;
vfactor = vposu-vposd;
vmard = 0.0;
vmaru = tMargin / (vposu-vposd);
} else {
vposd = vposu + vSpacing;
vposu = vposd + vStep;
vfactor = vposu-vposd;
vmard = 0.0;
vmaru = 0.0;
}
hfactor = hposl-hposr;
C1->cd();
char name[16];
sprintf(name,"pad_%i",k);
pad[k] = new TPad(name,"",hposl,vposd,hposr,vposu);
// // cout << Form("%f %f %f %f",hposl,vposd,hposr,vposu) << endl;
// // cout << Form("%f %f %f %f",hmarl,vmard,hmarr,vmaru) << endl;
pad[k]->SetLeftMargin(hmarl);
pad[k]->SetRightMargin(hmarr);
pad[k]->SetBottomMargin(vmard);
pad[k]->SetTopMargin(vmaru);
pad[k]->SetFrameLineWidth(3);
if(opt.Contains("logz")) {
pad[k]->SetLogz(1);
} else {
pad[k]->SetLogz(0);
}
pad[k]->Draw();
pad[k]->cd();
sprintf(name,"hFrame_%i",k);
hFrame[k] = (TH2F*) gROOT->FindObject(name);
if(hFrame[k]) delete hFrame[k];
hFrame[k] = (TH2F*) hDen2D[k][0]->Clone(name);
hFrame[k]->Reset();
hFrame[k]->GetXaxis()->CenterTitle();
hFrame[k]->GetYaxis()->CenterTitle();
hFrame[k]->GetZaxis()->CenterTitle();
hFrame[k]->SetLabelFont(42,"xyz");
hFrame[k]->SetTitleFont(42,"xyz");
hFrame[k]->SetNdivisions(505,"xyz");
hFrame[k]->SetTickLength(0.04,"xyz");
hFrame[k]->SetTickLength(0.04*vfactor,"y");
hFrame[k]->GetYaxis()->SetLabelSize(0.03/vfactor);
hFrame[k]->GetYaxis()->SetLabelOffset(0.02);
hFrame[k]->GetYaxis()->SetTitleSize(0.03/vfactor);
hFrame[k]->GetYaxis()->SetTitleOffset(999.0*vfactor);
if(k==0) {
hFrame[k]->GetXaxis()->SetLabelSize(0.10);
hFrame[k]->GetXaxis()->SetLabelOffset(0.02);
hFrame[k]->GetXaxis()->SetTitleSize(0.14);
hFrame[k]->GetXaxis()->SetTitleOffset(1.0);
} else {
hFrame[k]->GetXaxis()->SetLabelSize(0.0);
hFrame[k]->GetXaxis()->SetTitleSize(0.0);
}
hFrame[k]->Draw("axis");
exPlasma->Draw();
// Sum of histograms!
hDen2D[k][0]->Add(hDen2D[k][1]);
// hDen2D[k][0]->GetZaxis()->SetRangeUser(Min[1],Max[1]);
hDen2D[k][0]->Draw("colz same");
pad[k]->Update();
TPaletteAxis *palette = (TPaletteAxis*)hDen2D[k][0]->GetListOfFunctions()->FindObject("palette");
Float_t y1 = pad[k]->GetBottomMargin();
Float_t y2 = 1 - pad[k]->GetTopMargin();
Float_t x1 = pad[k]->GetLeftMargin();
Float_t x2 = 1 - pad[k]->GetRightMargin();
palette->SetY2NDC(y2 - 1*(y2-y1)/2.0 - 0.00);
palette->SetY1NDC(y1 + 0*(y2-y1)/2.0 + 0.00);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetLabelFont(42);
palette->SetLabelSize(0.03/vfactor);
palette->SetLabelOffset(-0.004);
palette->SetTitleSize(0.03/vfactor);
palette->SetTitleOffset(9999.0*vfactor);
palette->SetBorderSize(2);
palette->SetLineColor(1);
exHot->Draw();
hDen2D[k][2]->Draw("colz same");
pad[k]->Update();
palette = (TPaletteAxis*)hDen2D[k][2]->GetListOfFunctions()->FindObject("palette");
palette->SetY2NDC(y2 - 0*(y2-y1)/2.0 - 0.00);
palette->SetY1NDC(y1 + 1*(y2-y1)/2.0 + 0.00);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetLabelFont(42);
palette->SetLabelSize(0.03/vfactor);
palette->SetLabelOffset(-0.004);
palette->SetTitleSize(0.03/vfactor);
palette->SetTitleOffset(9999.0*vfactor);
palette->SetBorderSize(2);
palette->SetLineColor(1);
textTime[k] = new TPaveText(x2-0.17,y2-(0.05/vfactor),x2-0.02,y2-0.04,"NDC");
PlasmaGlob::SetPaveTextStyle(textTime[k],32);
char ctext[128];
if(opt.Contains("units"))
sprintf(ctext,"z = %5.0f #mum", skindepth * Time[k] / PUnits::um);
else
sprintf(ctext,"z = %5.1f #omega_{p}^{-1}",Time[k]);
textTime[k]->AddText(ctext);
textTime[k]->Draw();
textLabel[k] = new TPaveText(x1+0.02,y1+(0.02/vfactor),x1+0.07,y1+(0.06/vfactor),"NDC");
PlasmaGlob::SetPaveTextStyle(textLabel[k],32);
textLabel[k]->SetTextFont(42);
textLabel[k]->AddText(sLabels[k]);
textLabel[k]->Draw();
pad[k]->RedrawAxis();
}
C1->cd();
// PlasmaGlob::SetPaveTextStyle(textYaxis,11);
char ctext[128];
if(opt.Contains("units"))
sprintf(ctext,"y [#mum]");
else
sprintf(ctext,"k_{p} y");
TLatex *textYaxis = new TLatex(0.05,0.6,ctext);
textYaxis->SetTextAlign(22);
textYaxis->SetTextFont(42);
textYaxis->SetTextAngle(90);
textYaxis->Draw();
sprintf(ctext,"n [n_{0}]");
TLatex *textZaxis = new TLatex(0.95,0.6,ctext);
textZaxis->SetTextAlign(22);
textZaxis->SetTextFont(42);
textZaxis->SetTextAngle(90);
textZaxis->Draw();
// Output file
TString fOutName = Form("./%s/Plots/RakeInjection/RakeInjection",pData->GetPath().c_str());
fOutName += Form("-%s",pData->GetName());
// Print to a file
PlasmaGlob::imgconv(C1,fOutName,opt);
// ---------------------------------------------------------
}
//------------------------------------------------------------------------------
// DrawIt
//------------------------------------------------------------------------------
void DrawIt(TString filename,
TString hname,
TString cname,
TString title)
{
TFile* inputfile = TFile::Open("../AuxiliaryFilesWZXS8TeV/" + filename + ".root");
TH2F* h = (TH2F*)inputfile->Get(hname)->Clone(cname);
h->SetDirectory(0);
inputfile->Close();
TString name = h->GetName();
TCanvas* canvas = new TCanvas(name, name, 600, 600);
if (name.Contains("PR")) canvas->SetLogx();
if (name.Contains("SF")) canvas->SetLogx();
canvas->SetLeftMargin (0.9 * canvas->GetLeftMargin());
canvas->SetRightMargin(3.5 * canvas->GetRightMargin());
canvas->SetTopMargin (1.2 * canvas->GetTopMargin());
TH2FAxisFonts(h, "x", "p_{T} [GeV]");
TH2FAxisFonts(h, "y", "#eta");
h->Draw("colz");
h->SetTitle("");
DrawTLatex(42, 0.940, 0.976, _bigLabelSize, 33, title);
if (!title.Contains("trigger")) {
Double_t hmin = h->GetMinimum();
Double_t hmax = h->GetMaximum();
for (Int_t i=1; i<=h->GetNbinsX(); i++) {
for (Int_t j=1; j<=h->GetNbinsY(); j++) {
Double_t value = h->GetBinContent(i,j);
Double_t ypos = h->GetYaxis()->GetBinCenter(j);
Double_t xpos = h->GetXaxis()->GetBinCenter(i);
if (gPad->GetLogx()) xpos = h->GetXaxis()->GetBinCenterLog(i);
TLatex* latex = new TLatex(xpos, ypos, Form("%.2f", value));
latex->SetTextAlign( 22);
latex->SetTextFont ( 42);
latex->SetTextSize (0.027);
if (value < hmin + 0.3*(hmax - hmin)) latex->SetTextColor(kWhite);
latex->Draw();
}
}
}
// Set the palette font
//----------------------------------------------------------------------------
canvas->Update();
TPaletteAxis* palette = (TPaletteAxis*)h->GetListOfFunctions()->FindObject("palette");
palette->SetLabelFont(42);
// Save the plot
//----------------------------------------------------------------------------
canvas->Update();
canvas->Modified();
canvas->GetFrame()->DrawClone();
canvas->SaveAs("pdf/scale_factors/" + name + ".pdf");
canvas->SaveAs("png/scale_factors/" + name + ".png");
}
void macro_2Dhisto(TString channel, TString njmt, TString syst, TString region, TString BDT1_name, TString BDT2_name, TString lep){
if((lep=="electron"||lep=="electronantiiso")&& channel=="QCDMuPt20toInf") return;
if((lep=="muonantiiso"||lep=="electronantiiso") && channel=="TT_sd") return;
if((channel.Contains("hdamp")||channel.Contains("psq2"))&&((lep=="muonantiiso"||lep=="electronantiiso")||(syst!=""))) return;
TFile * f=TFile::Open("trees_lumi/"+lep+"/trees_"+channel+"_"+lep+".root");
TString treename, histoname;
TH2F * h2 = new TH2F("h2", "h2",10,-1,1,10,-1,1);
// Float_t BDT1, BDT2, etajprime, mtw, w, w_nominal, var_syst;
gStyle->SetOptStat(0);
TString outfilename, taglio, selection;
selection = "BDT_"+BDT1_name+":BDT_"+BDT2_name;
if(syst.EqualTo("jesUp")||syst.EqualTo("jesDown")||syst.EqualTo("jerUp")||syst.EqualTo("jerDown")) treename = "events_"+njmt+"_"+syst;
else treename = "events_"+njmt;
TTree * t =(TTree*)f->Get(treename);
if(region=="cr") taglio = "(mtw>50 && etajprime<2.4";
else taglio = "(mtw>50 && etajprime>2.4";
if(lep=="electronantiiso") taglio += " &&mlb>30";
if(syst.EqualTo("")){
histoname = "h2D_"+njmt+"_"+channel+"_"+region;
t->Project("h2",selection,taglio+")*w*w_nominal");
}
else{
if(syst.EqualTo("jesUp")||syst.EqualTo("jesDown")||syst.EqualTo("jerUp")||syst.EqualTo("jerDown")){
histoname = "h2D_"+njmt+"_"+channel+"_"+region+"_"+syst;
t->Project("h2",selection,taglio+")*w*w_nominal");
}
else{
histoname = "h2D_"+njmt+"_"+channel+"_"+region+"_"+syst;
t->Project("h2",selection,taglio+")*w*"+syst);
}
}
h2->SetName(histoname);
TCanvas * c = new TCanvas( "c1"," ");
Float_t newMargin1 = 0.13;
Float_t newMargin2 = 0.15;
c->SetGrid();
c->SetTicks();
c->SetLeftMargin ( newMargin2 );
c->SetBottomMargin( newMargin2 );
c->SetRightMargin ( newMargin1 );
c->SetTopMargin ( newMargin1 );
gStyle->SetPalette( 1, 0 );
gStyle->SetPaintTextFormat( "3g" );
h2->SetMarkerSize( 1.5 );
h2->SetMarkerColor( 0 );
Float_t labelSize = 0.040;
h2->GetXaxis()->SetLabelSize( labelSize );
h2->GetYaxis()->SetLabelSize( labelSize );
h2->GetXaxis()->SetTitle( "BDT_"+BDT1_name );
h2->GetYaxis()->SetTitle( "BDT_"+BDT2_name );
// h2->LabelsOption( "d" );
h2->SetLabelOffset( 0.011 );// label offset on x axis
h2->Draw("colz"); // color pads
c->Update();
// modify properties of paletteAxis
TPaletteAxis * paletteAxis = (TPaletteAxis*)h2->GetListOfFunctions()->FindObject( "palette" );
paletteAxis->SetLabelSize( 0.03 );
paletteAxis->SetX1NDC( paletteAxis->GetX1NDC() + 0.02 );
h2->Draw("textsame"); // add text
// TMVAGlob::plot_logo( );
c->Update();
outfilename = "Plot/histo2D_"+lep+".root";
TFile * fout = TFile::Open(outfilename, "UPDATE");
h2->Write();
c->SaveAs("Plot2D/"+histoname+"_"+lep+".pdf");
}
void PlotPotential2D( const TString &sim, Int_t time, Int_t zoom=2, Int_t Nbins=2, const TString &options="") {
#ifdef __CINT__
gSystem->Load("libplasma.so");
#endif
PlasmaGlob::Initialize();
// Palettes!
gROOT->Macro("PlasmaPalettes.C");
// Init Units table
PUnits::UnitsTable::Get();
// Load PData
PData *pData = PData::Get(sim.Data());
pData->LoadFileNames(time);
if(!pData->IsInit()) return;
TString opt = options;
// More makeup
gStyle->SetPadGridY(0);
if(opt.Contains("gridx")) {
gStyle->SetPadGridX(1);
}
if(opt.Contains("gridy")) {
gStyle->SetPadGridY(1);
}
// Some plasma constants
Double_t n0 = pData->GetPlasmaDensity();
Double_t omegap = pData->GetPlasmaFrequency();
Double_t timedepth = 1.;
if(omegap!=0.0) timedepth = 1/omegap;
Double_t kp = pData->GetPlasmaK();
Double_t skindepth = 1.;
if(kp!=0.0) skindepth = 1/kp;
Double_t E0 = pData->GetPlasmaE0();
// Some beam properties:
Double_t Ebeam = pData->GetBeamEnergy();
Double_t gamma = pData->GetBeamGamma();
Double_t vbeam = pData->GetBeamVelocity();
cout << Form(" - Bunch gamma = %8.4f", gamma ) << endl;
cout << Form(" - Bunch velocity = %8.4f c", vbeam ) << endl;
// Other parameters
Float_t trapPotential = 1.0 - (1.0/gamma);
cout << Form(" - Trap. potential = %8.4f mc2/e",trapPotential) << endl;
cout << endl;
// 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;
// z start of the neutral in normalized units.
Float_t zStartNeutral = pData->GetNeutralStart()*kp;
// z end of the neutral in normalized units.
Float_t zEndNeutral = pData->GetNeutralEnd()*kp;
if(opt.Contains("center")) {
Time -= zStartPlasma;
if(opt.Contains("comov")) // Centers on the head of the beam.
Time += zStartBeam;
}
Float_t shiftz = pData->Shift(opt);
// cout << "Shift = " << shiftz << endl;
// Calculate the "axis range" in number of bins. If Nbins==0 a RMS width is taken.
Double_t rms0 = pData->GetBeamRmsY() * kp;
if(pData->IsCyl()) rms0 = pData->GetBeamRmsR() * kp;
Int_t FirstyBin = 0;
Int_t LastyBin = 0;
if(Nbins==0) {
if(rms0>0.0)
Nbins = TMath::Nint(rms0 / pData->GetDX(1));
else
Nbins = 1;
}
// Slice width limits.
if(!pData->IsCyl()) {
FirstyBin = pData->GetNX(1)/2 + 1 - Nbins;
LastyBin = pData->GetNX(1)/2 + Nbins;
} else {
FirstyBin = 1;
LastyBin = Nbins;
}
// ----------------------------------------------------------------------------------
// Get charge density histos
Int_t Nspecies = pData->NSpecies();
TH2F **hDen2D = new TH2F*[Nspecies];
// Get charge density on-axis
TH1F **hDen1D = new TH1F*[Nspecies];
// And electric current (integrated)
TH1F **hCur1D = new TH1F*[Nspecies];
for(Int_t i=0; i<Nspecies; i++) {
hDen2D[i] = NULL;
if(!pData->GetChargeFileName(i))
continue;
cout << Form(" Getting charge density of specie: ") << i << endl;
char hName[24];
sprintf(hName,"hDen2D_%i",i);
hDen2D[i] = (TH2F*) gROOT->FindObject(hName);
if(hDen2D[i]) delete hDen2D[i];
if(!pData->Is3D())
hDen2D[i] = pData->GetCharge(i,opt);
else
hDen2D[i] = pData->GetCharge2DSliceZY(i,-1,Nbins,opt+"avg");
hDen2D[i]->SetName(hName);
hDen2D[i]->GetXaxis()->CenterTitle();
hDen2D[i]->GetYaxis()->CenterTitle();
hDen2D[i]->GetZaxis()->CenterTitle();
if(opt.Contains("comov"))
hDen2D[i]->GetXaxis()->SetTitle("k_{p} #zeta");
else
hDen2D[i]->GetXaxis()->SetTitle("k_{p} z");
if(pData->IsCyl())
hDen2D[i]->GetYaxis()->SetTitle("k_{p} r");
else
hDen2D[i]->GetYaxis()->SetTitle("k_{p} y");
hDen2D[i]->GetZaxis()->SetTitle("n [n_{0}]");
hDen1D[i] = NULL;
hCur1D[i] = NULL;
if(!pData->GetEfieldFileName(i))
continue;
sprintf(hName,"hDen1D_%i",i);
hDen1D[i] = (TH1F*) gROOT->FindObject(hName);
if(hDen1D[i]) delete hDen1D[i];
// 1D histograms
if(pData->Is3D()) {
hDen1D[i] = pData->GetH1SliceZ3D(pData->GetChargeFileName(i)->c_str(),"charge",-1,Nbins,-1,Nbins,opt+"avg");
} else if(pData->IsCyl()) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0).
hDen1D[i] = pData->GetH1SliceZ(pData->GetChargeFileName(i)->c_str(),"charge",1,Nbins,opt+"avg");
} else { // 2D cartesian
hDen1D[i] = pData->GetH1SliceZ(pData->GetChargeFileName(i)->c_str(),"charge",-1,Nbins,opt+"avg");
}
hDen1D[i]->SetName(hName);
// if(hDen1D[i]) delete hDen1D[i];
// hDen1D[i] = (TH1F*) hE2D[i]->ProjectionX(hName,FirstyBin,LastyBin);
// hDen1D[i]->Scale(1.0/(LastyBin-FirstyBin+1));
if(opt.Contains("comov"))
hDen1D[i]->GetXaxis()->SetTitle("#zeta [c/#omega_{p}]");
else
hDen1D[i]->GetXaxis()->SetTitle("z [c/#omega_{p}]");
if(i==0)
hDen1D[i]->GetYaxis()->SetTitle("n/n_{0}");
else if(i==1)
hDen1D[i]->GetYaxis()->SetTitle("n_{b}/n_{0}");
else
hDen1D[i]->GetYaxis()->SetTitle("n_{i}/n_{0}");
// Get the current:
if(i==0) continue;
sprintf(hName,"hCur1D_%i",i);
hCur1D[i] = (TH1F*) gROOT->FindObject(hName);
if(hCur1D[i]) delete hCur1D[i];
if(opt.Contains("curr")) {
// To get the current is needed to read in a wider transverse range which includes all the charge.
Int_t NbinsT = 100;
if(pData->Is3D()) {
hCur1D[i] = pData->GetH1SliceZ3D(pData->GetChargeFileName(i)->c_str(),"charge",-1,NbinsT,-1,NbinsT,opt+"int");
} else if(pData->IsCyl()) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0).
hCur1D[i] = pData->GetH1SliceZ(pData->GetChargeFileName(i)->c_str(),"charge",1,NbinsT,opt+"int");
} else { // 2D cartesian
hCur1D[i] = pData->GetH1SliceZ(pData->GetChargeFileName(i)->c_str(),"charge",-1,NbinsT,opt+"int");
}
hCur1D[i]->SetName(hName);
if(opt.Contains("comov")) {
hCur1D[i]->GetXaxis()->SetTitle("#zeta [c/#omega_{p}]");
hCur1D[i]->GetYaxis()->SetTitle("dn/d#zeta [(n_{0}/k_{p}^{3}) (#omega_{p}/c)]");
} else {
hCur1D[i]->GetXaxis()->SetTitle("z [c/#omega_{p}]");
hCur1D[i]->GetYaxis()->SetTitle("dn/dz [(n_{0}/k_{p}^{3}) (#omega_{p}/c)]");
}
Int_t NB = hCur1D[i]->GetNbinsX();
Float_t dx = (hCur1D[i]->GetBinLowEdge(1)-hCur1D[i]->GetBinLowEdge(NB+1))/NB;
// hCur1D[i]->Scale(dx);
Float_t Charge = hCur1D[i]->Integral() * dx;
cout << Form(" Integrated charge of specie %3i = %8.4f n0 * kp^-3",i,Charge) << endl;
}
}
// Get electric fields 2D
const Int_t Nfields = 3;
TH2F **hE2D = new TH2F*[Nfields];
TH1F **hE1D = new TH1F*[Nfields];
TH2F *hV2D = NULL;
TH1F *hV1D = NULL;
for(Int_t i=0; i<Nfields; i++) {
hE2D[i] = NULL;
hE1D[i] = NULL;
if(!pData->GetEfieldFileName(i))
continue;
cout << Form(" Getting electric field number ") << i+1 << endl;
char hName[24];
sprintf(hName,"hE2D_%i",i);
hE2D[i] = (TH2F*) gROOT->FindObject(hName);
if(hE2D[i]) delete hE2D[i];
if(!pData->Is3D())
hE2D[i] = pData->GetEField(i,opt);
else
hE2D[i] = pData->GetEField2DSliceZY(i,-1,Nbins,opt+"avg");
hE2D[i]->SetName(hName);
hE2D[i]->GetXaxis()->CenterTitle();
hE2D[i]->GetYaxis()->CenterTitle();
hE2D[i]->GetZaxis()->CenterTitle();
if(opt.Contains("comov"))
hE2D[i]->GetXaxis()->SetTitle("k_{p} #zeta");
else
hE2D[i]->GetXaxis()->SetTitle("k_{p} z");
if(pData->IsCyl())
hE2D[i]->GetYaxis()->SetTitle("k_{p} r");
else
hE2D[i]->GetYaxis()->SetTitle("k_{p} y");
if(i==0)
hE2D[i]->GetZaxis()->SetTitle("E_{z}/E_{0}");
else if(i==1)
hE2D[i]->GetZaxis()->SetTitle("E_{y}/E_{0}");
else if(i==2)
hE2D[i]->GetZaxis()->SetTitle("E_{x}/E_{0}");
sprintf(hName,"hE1D_%i",i);
hE1D[i] = (TH1F*) gROOT->FindObject(hName);
if(hE1D[i]) delete hE1D[i];
// 1D histograms
char nam[3];
sprintf(nam,"e%i",i+1);
if(pData->Is3D()) {
if(i==0)
hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,-1,Nbins,opt+"avg");
else
hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,-Nbins,Nbins,opt+"avg");
} else if(pData->IsCyl()) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0).
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,1,Nbins,opt+"avg");
} else { // 2D cartesian
if(i==0)
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,opt+"avg");
else
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,opt+"avg");
}
hE1D[i]->SetName(hName);
if(opt.Contains("comov"))
hE1D[i]->GetXaxis()->SetTitle("#zeta [c/#omega_{p}]");
else
hE1D[i]->GetXaxis()->SetTitle("z [c/#omega_{p}]");
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}]");
// Alternative
// if(hE1D[i]) delete hE1D[i];
// hE1D[i] = (TH1F*) hE2D[i]->ProjectionX(hName,FirstyBin,LastyBin);
// hE1D[i]->Scale(1.0/(LastyBin-FirstyBin+1));
if(i==0) {
Int_t NbinsX = hE2D[i]->GetNbinsX();
Int_t NbinsY = hE2D[i]->GetNbinsY();
Float_t dx = pData->GetDX(0);
sprintf(hName,"hV2D");
hV2D = (TH2F*) hE2D[i]->Clone(hName);
hV2D->Reset();
sprintf(hName,"hV1D");
hV1D = (TH1F*) hE1D[i]->Clone(hName);
hV1D->Reset();
for(Int_t j=NbinsY; j>0; j--) {
Double_t integral = 0.0;
for(Int_t k=NbinsX; k>0; k--) {
integral += hE2D[i]->GetBinContent(k,j) * dx;
hV2D->SetBinContent(k,j,integral);
}
}
Double_t integral = 0.0;
for(Int_t k=NbinsX; k>0; k--) {
integral += hE1D[i]->GetBinContent(k) * dx;
hV1D->SetBinContent(k,integral);
}
}
}
// Now, combine the electric field components into the total |E|
// and calculate ionization probability for He:
// Outter Helium electron
Double_t Eion0 = 24.59 * PUnits::eV;
Double_t Z = 1;
TH2F *hETotal2D = (TH2F*) hE2D[0]->Clone("hETotal2D");
hETotal2D->Reset();
TH2F *hIonProb2D = (TH2F*) hE2D[0]->Clone("hIonProb2D");
hIonProb2D->Reset();
TH1F *hETotal1D = (TH1F*) hE1D[0]->Clone("hETotal1D");
hETotal1D->Reset();
TH1F *hIonProb1D = (TH1F*) hE1D[0]->Clone("hIonProb1D");
hIonProb1D->Reset();
{
Int_t NbinsX = hE2D[0]->GetNbinsX();
Int_t NbinsY = hE2D[0]->GetNbinsY();
for(Int_t j=0; j<NbinsX; j++) {
for(Int_t k=0; k<NbinsY; k++) {
Double_t E1 = hE2D[0]->GetBinContent(j,k);
Double_t E2 = hE2D[1]->GetBinContent(j,k);
Double_t E3 = hE2D[2]->GetBinContent(j,k);
Double_t E = TMath::Sqrt(E1*E1+E2*E2+E3*E3);
hETotal2D->SetBinContent(j,k,E);
E *= E0;
// Double_t IonProb = (PFunc::ADK(E,Eion0,Z,l,m)/PUnits::atomictime)*PUnits::femtosecond;
Double_t IonProb = PFunc::ADK_ENG(E,Eion0,Z) * PUnits::femtosecond;
// if(IonProb>1) IonProb = 1.0;
// cout << "Ion prob = " << IonProb << endl;
hIonProb2D->SetBinContent(j,k,IonProb);
}
Double_t E1 = hE1D[0]->GetBinContent(j);
Double_t E2 = hE1D[1]->GetBinContent(j);
Double_t E3 = hE1D[2]->GetBinContent(j);
Double_t E = TMath::Sqrt(E1*E1+E2*E2+E3*E3);
hETotal1D->SetBinContent(j,E);
E *= E0;
// Double_t IonProb = (PFunc::ADK(E,Eion0,Z,l,m)/PUnits::atomictime)*PUnits::femtosecond;
Double_t IonProb = PFunc::ADK_ENG(E,Eion0,Z) * PUnits::femtosecond;
// cout << "Ion prob = " << IonProb << endl;
hIonProb1D->SetBinContent(j,IonProb);
}
}
hETotal2D->GetZaxis()->SetTitle("E [E_{0}]");
hIonProb2D->GetZaxis()->SetTitle("W_{ADK} [fs^{-1}]");
hETotal1D->GetYaxis()->SetTitle("E [E_{0}]");
hIonProb1D->GetYaxis()->SetTitle("W_{ADK} [fs^{-1}]");
// Tunning the Histograms
// ---------------------
// Chaning to user units:
// --------------------------
if(opt.Contains("units") && n0) {
for(Int_t i=0; i<Nspecies; i++) {
if(!hDen2D[i]) continue;
Int_t NbinsX = hDen2D[i]->GetNbinsX();
Float_t xMin = skindepth * hDen2D[i]->GetXaxis()->GetXmin() / PUnits::um;
Float_t xMax = skindepth * hDen2D[i]->GetXaxis()->GetXmax() / PUnits::um;
Int_t NbinsY = hDen2D[i]->GetNbinsY();
Float_t ymin = skindepth * hDen2D[i]->GetYaxis()->GetXmin() / PUnits::um;
Float_t ymax = skindepth * hDen2D[i]->GetYaxis()->GetXmax() / PUnits::um;
hDen2D[i]->SetBins(NbinsX,xMin,xMax,NbinsY,ymin,ymax);
// for(Int_t j=0;j<hDen2D[i]->GetNbinsX();j++) {
// for(Int_t k=0;k<hDen2D[i]->GetNbinsY();k++) {
// hDen2D[i]->SetBinContent(j,k, hDen2D[i]->GetBinContent(j,k) * n0 / (1e17/PUnits::cm3) );
// }
// }
if(pData->IsCyl())
hDen2D[i]->GetYaxis()->SetTitle("r [#mum]");
else
hDen2D[i]->GetYaxis()->SetTitle("y [#mum]");
if(opt.Contains("comov"))
hDen2D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hDen2D[i]->GetXaxis()->SetTitle("z [#mum]");
// if(i==0)
// hDen2D[i]->GetZaxis()->SetTitle("n_{e} [10^{17}/cm^{3}]");
// else if(i==1)
// hDen2D[i]->GetZaxis()->SetTitle("n_{b} [10^{17}/cm^{3}]");
// else
// hDen2D[i]->GetZaxis()->SetTitle("n_{i} [10^{17}/cm^{3}]");
hDen1D[i]->SetBins(NbinsX,xMin,xMax);
// for(Int_t j=0;j<hDen1D[i]->GetNbinsX();j++) {
// hDen1D[i]->SetBinContent(j, hDen1D[i]->GetBinContent(j) * n0 / (1e17/PUnits::cm3) );
// }
if(opt.Contains("comov"))
hDen1D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hDen1D[i]->GetXaxis()->SetTitle("z [#mum]");
if(hCur1D[i]) {
hCur1D[i]->SetBins(NbinsX,xMin,xMax);
Double_t binSize = (xMax - xMin)/NbinsX; // bin size in um.
Double_t dV = skindepth * skindepth * skindepth;
Double_t lightspeed = PConst::c_light / (PUnits::um/PUnits::femtosecond);
hCur1D[i]->Scale(TMath::Abs(n0 * dV * (PConst::ElectronCharge/PUnits::picocoulomb) * (kp * PConst::c_light * PUnits::femtosecond)));
hCur1D[i]->GetYaxis()->SetTitle("I[kA]");
hCur1D[i]->GetYaxis()->SetTitle("");
if(opt.Contains("comov"))
hCur1D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hCur1D[i]->GetXaxis()->SetTitle("z [#mum]");
Float_t Charge = hCur1D[i]->Integral() * (binSize / lightspeed);
cout << Form(" Integrated charge of specie %3i = %8f pC",i,Charge) << endl;
}
}
for(Int_t i=0; i<Nfields; i++) {
Int_t NbinsX = hE2D[i]->GetNbinsX();
Float_t xMin = skindepth * hE2D[i]->GetXaxis()->GetXmin() / PUnits::um;
Float_t xMax = skindepth * hE2D[i]->GetXaxis()->GetXmax() / PUnits::um;
Int_t NbinsY = hE2D[i]->GetNbinsY();
Float_t ymin = skindepth * hE2D[i]->GetYaxis()->GetXmin() / PUnits::um;
Float_t ymax = skindepth * hE2D[i]->GetYaxis()->GetXmax() / PUnits::um;
hE2D[i]->SetBins(NbinsX,xMin,xMax,NbinsY,ymin,ymax);
hE1D[i]->SetBins(NbinsX,xMin,xMax);
for(Int_t j=0; j<hE2D[i]->GetNbinsX(); j++) {
for(Int_t k=0; k<hE2D[i]->GetNbinsY(); k++) {
hE2D[i]->SetBinContent(j,k, hE2D[i]->GetBinContent(j,k) * ( E0 / (PUnits::GV/PUnits::m) ) );
}
hE1D[i]->SetBinContent(j, hE1D[i]->GetBinContent(j) * ( E0 / (PUnits::GV/PUnits::m) ) );
}
if(pData->IsCyl())
hE2D[i]->GetYaxis()->SetTitle("r [#mum]");
else
hE2D[i]->GetYaxis()->SetTitle("y [#mum]");
if(opt.Contains("comov"))
hE2D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hE2D[i]->GetXaxis()->SetTitle("z [#mum]");
if(i==0)
hE2D[i]->GetZaxis()->SetTitle("E_{z} [GV/m]");
else if(i==1)
hE2D[i]->GetZaxis()->SetTitle("E_{y} [GV/m]");
else if(i==2)
hE2D[i]->GetZaxis()->SetTitle("E_{x} [GV/m]");
if(opt.Contains("comov"))
hE1D[i]->GetXaxis()->SetTitle("#zeta [mm]");
else
hE1D[i]->GetXaxis()->SetTitle("z [mm]");
if(i==0)
hE1D[i]->GetYaxis()->SetTitle("E_{z} [GV/m]");
else if(i==1)
hE1D[i]->GetYaxis()->SetTitle("E_{y} [GV/m]");
else if(i==2)
hE1D[i]->GetYaxis()->SetTitle("E_{x} [GV/m]");
if(i==0) {
hV2D->SetBins(NbinsX,xMin,xMax,NbinsY,ymin,ymax);
hETotal2D->SetBins(NbinsX,xMin,xMax,NbinsY,ymin,ymax);
hIonProb2D->SetBins(NbinsX,xMin,xMax,NbinsY,ymin,ymax);
hV1D->SetBins(NbinsX,xMin,xMax);
hETotal1D->SetBins(NbinsX,xMin,xMax);
hIonProb1D->SetBins(NbinsX,xMin,xMax);
for(Int_t j=0; j<NbinsX; j++) {
for(Int_t k=0; k<NbinsY; k++) {
hV2D->SetBinContent(j,k, hV2D->GetBinContent(j,k) * E0 * skindepth / (PUnits::MV));
hETotal2D->SetBinContent(j,k, hETotal2D->GetBinContent(j,k) * ( E0 / (PUnits::GV/PUnits::m) ) );
}
hV1D->SetBinContent(j, hV1D->GetBinContent(j) * ( E0 * skindepth / (PUnits::MV) ) );
hETotal1D->SetBinContent(j, hETotal1D->GetBinContent(j) * ( E0 / (PUnits::GV/PUnits::m) ) );
}
if(pData->IsCyl()) {
hV2D->GetYaxis()->SetTitle("r [#mum]");
hETotal2D->GetYaxis()->SetTitle("r [#mum]");
} else {
hV2D->GetYaxis()->SetTitle("y [#mum]");
hETotal2D->GetYaxis()->SetTitle("y [#mum]");
}
if(opt.Contains("comov")) {
hV2D->GetXaxis()->SetTitle("#zeta [#mum]");
hV1D->GetXaxis()->SetTitle("#zeta [#mum]");
hETotal2D->GetXaxis()->SetTitle("#zeta [#mum]");
hETotal1D->GetXaxis()->SetTitle("#zeta [#mum]");
} else {
hV2D->GetXaxis()->SetTitle("z [#mum]");
hV2D->GetXaxis()->SetTitle("z [#mum]");
hETotal2D->GetXaxis()->SetTitle("z [#mum]");
hETotal1D->GetXaxis()->SetTitle("z [#mum]");
}
hV2D->GetZaxis()->SetTitle("#Psi-#Psi_{t} [MV]");
hV1D->GetYaxis()->SetTitle("#Psi-#Psi_{t} [MV]");
hETotal2D->GetZaxis()->SetTitle("E [GV/m]");
hETotal1D->GetYaxis()->SetTitle("E [GV/m]");
}
}
}
// --------------------------------------------------- Vertical Zoom ------------
Float_t yRange = (hDen2D[0]->GetYaxis()->GetXmax() - hDen2D[0]->GetYaxis()->GetXmin())/zoom;
Float_t midPoint = (hDen2D[0]->GetYaxis()->GetXmax() + hDen2D[0]->GetYaxis()->GetXmin())/2.;
Float_t yMin = midPoint-yRange/2;
Float_t yMax = midPoint+yRange/2;
if(pData->IsCyl()) {
yMin = pData->GetXMin(1);
yMax = yRange;
}
for(Int_t i=0; i<Nspecies; i++) {
if(!hDen2D[i]) continue;
hDen2D[i]->GetYaxis()->SetRangeUser(yMin,yMax);
}
for(Int_t i=0; i<Nfields; i++) {
if(!hE2D[i]) continue;
hE2D[i]->GetYaxis()->SetRangeUser(yMin,yMax);
}
hETotal2D->GetYaxis()->SetRangeUser(yMin,yMax);
Float_t xMin = hDen2D[0]->GetXaxis()->GetXmin();
Float_t xMax = hDen2D[0]->GetXaxis()->GetXmax();
Float_t xRange = xMax - xMin;
// ------------- z Zoom --------------------------------- Plasma palette -----------
// Set the range of the plasma charge density histogram for maximum constrast
// using a dynamic palette wich adjust the nominal value to a certain color.
Float_t density = 1;
Float_t Base = density;
Float_t *Max = new Float_t[Nspecies];
Float_t *Min = new Float_t[Nspecies];
for(Int_t i=0; i<Nspecies; i++) {
if(!hDen2D[i]) continue;
Max[i] = hDen2D[i]->GetMaximum();
Min[i] = 1.01E-1 * Base;
if(i==1) Min[i] = 1.01E-1 * Base;
if(i==2) Min[i] = 1.01E-4 * Base;
hDen2D[i]->GetZaxis()->SetRangeUser(Min[i],Max[i]);
}
// Dynamic plasma palette
const Int_t plasmaDNRGBs = 3;
const Int_t plasmaDNCont = 64;
Float_t basePos = 0.5;
if(Max[0]!=Min[0]) {
if(opt.Contains("logz")) {
Float_t a = 1.0/(TMath::Log10(Max[0])-TMath::Log10(Min[0]));
Float_t b = TMath::Log10(Min[0]);
basePos = a*(TMath::Log10(Base) - b);
} else {
basePos = (1.0/(Max[0]-Min[0]))*(Base - Min[0]);
}
}
Double_t plasmaDStops[plasmaDNRGBs] = { 0.00, basePos, 1.00 };
Double_t plasmaDRed[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
Double_t plasmaDGreen[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
Double_t plasmaDBlue[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
PPalette * plasmaPalette = (PPalette*) gROOT->FindObject("plasma");
plasmaPalette->CreateGradientColorTable(plasmaDNRGBs, plasmaDStops,
plasmaDRed, plasmaDGreen, plasmaDBlue, plasmaDNCont);
// Change the range of z axis for the fields to be symmetric.
Float_t *Emax = new Float_t[Nfields];
Float_t *Emin = new Float_t[Nfields];
for(Int_t i=0; i<Nfields; i++) {
Emax[i] = hE2D[i]->GetMaximum();
Emin[i] = hE2D[i]->GetMinimum();
if(Emax[i] > TMath::Abs(Emin[i]))
Emin[i] = -Emax[i];
else
Emax[i] = -Emin[i];
hE2D[i]->GetZaxis()->SetRangeUser(Emin[i],Emax[i]);
}
// Potential
if(opt.Contains("units")) {
trapPotential *= ( E0 * skindepth / (PUnits::MV) );
}
Float_t Vmin = hV1D->GetMinimum();
{ // Shift potential
Int_t NbinsX = hV2D->GetNbinsX();
Int_t NbinsY = hV2D->GetNbinsY();
for(Int_t j=0; j<NbinsX; j++) {
for(Int_t k=0; k<NbinsY; k++) {
hV2D->SetBinContent(j,k, hV2D->GetBinContent(j,k) - Vmin -trapPotential);
}
hV1D->SetBinContent(j, hV1D->GetBinContent(j) - Vmin -trapPotential);
}
}
Vmin = hV1D->GetMinimum();
Float_t Vmax = hV1D->GetMaximum();
// Dynamic potential palette
const Int_t potPNRGBs = 5;
const Int_t potPNCont = 64;
Float_t zeroPos = -Vmin/(Vmax-Vmin);
Double_t potPStops[potPNRGBs] = { 0.00, zeroPos-3.0/potPNCont,zeroPos, zeroPos+3.0/potPNCont, 1.00 };
Double_t potPRed[potPNRGBs] = { 0.518, 0.965, 0.90, 0.498, 0.106 };
Double_t potPGreen[potPNRGBs] = { 0.078, 0.925, 0.90, 0.718, 0.078 };
Double_t potPBlue[potPNRGBs] = { 0.106, 0.353, 0.90, 0.780, 0.518 };
PPalette * potentialPalette = (PPalette*) gROOT->FindObject("rbow2inv");
potentialPalette->CreateGradientColorTable(potPNRGBs, potPStops,
potPRed, potPGreen, potPBlue, potPNCont);
// Extract contours
TCanvas* c = new TCanvas("c","Contour List",0,0,600,600);
c->cd();
// Potential
TH2F *hV2Dc = (TH2F*) hV2D->Clone("hV2Dc");
const Int_t Ncontours = 25;
Double_t contours[Ncontours];
for(Int_t i=0; i<Ncontours; i++) {
contours[i] = i*(trapPotential/5.0) - trapPotential;
}
hV2Dc->SetContour(Ncontours, contours);
hV2Dc->Draw("cont list");
c->Update();
TObjArray *contsV2D = (TObjArray*) gROOT->GetListOfSpecials()->FindObject("contours");
TClonesArray graphsV2D("TGraph",Ncontours);
{
Int_t ncontours = contsV2D->GetSize();
TList* clist = NULL;
Int_t nGraphs = 0;
TGraph *gr = NULL;
for(Int_t i = 0; i < ncontours; i++) {
if(i==0) continue;
clist = (TList*) contsV2D->At(i);
for(Int_t j = 0 ; j < clist->GetSize(); j++) {
gr = (TGraph*) clist->At(j);
if(!gr) continue;
gr->SetLineWidth(1);
gr->SetLineColor(kGray+1);
if( !((i)%5) ) {
gr->SetLineWidth(2);
gr->SetLineColor(kGray+2);
}
new(graphsV2D[nGraphs]) TGraph(*gr) ;
nGraphs++;
}
}
}
// Ion probability
hIonProb2D->GetZaxis()->SetRangeUser(0.00501,80);
TH2F *hIonProb2Dc = (TH2F*) hIonProb2D->Clone("hIonProb2Dc");
const Int_t NcontI = 4;
Double_t contI[NcontI] = {0.01,0.1,1.0,10.0};
hIonProb2Dc->SetContour(NcontI, contI);
hIonProb2Dc->Draw("cont list");
c->Update();
TObjArray *contsI2D = (TObjArray*) gROOT->GetListOfSpecials()->FindObject("contours");
TClonesArray graphsI2D("TGraph",NcontI);
{
Int_t ncontours = contsI2D->GetSize();
TList* clist = NULL;
Int_t nGraphs = 0;
TGraph *gr = NULL;
for(Int_t i = 0; i < ncontours; i++) {
clist = (TList*) contsI2D->At(i);
for(Int_t j = 0 ; j < clist->GetSize(); j++) {
gr = (TGraph*) clist->At(j);
if(!gr) continue;
if( !(i%2) ) {
gr->SetLineWidth(1);
gr->SetLineStyle(2);
gr->SetLineColor(kOrange-3);
} else {
gr->SetLineWidth(1);
gr->SetLineStyle(1);
gr->SetLineColor(kOrange-3);
}
new(graphsI2D[nGraphs]) TGraph(*gr) ;
nGraphs++;
}
}
}
// "Axis range" in Osiris units:
Double_t ylow = hDen2D[0]->GetYaxis()->GetBinLowEdge(FirstyBin);
Double_t yup = hDen2D[0]->GetYaxis()->GetBinUpEdge(LastyBin);
Double_t xmin = hDen2D[0]->GetXaxis()->GetXmin();
Double_t xmax = hDen2D[0]->GetXaxis()->GetXmax();
TLine *lineYzero = new TLine(xmin,0.0,xmax,0.0);
lineYzero->SetLineColor(kGray+2);
lineYzero->SetLineStyle(2);
TLine *lineYup = new TLine(xmin,yup,xmax,yup);
lineYup->SetLineColor(kGray+1);
lineYup->SetLineStyle(2);
TLine *lineYdown = new TLine(xmin,ylow,xmax,ylow);
lineYdown->SetLineColor(kGray+1);
lineYdown->SetLineStyle(2);
zStartPlasma -= shiftz;
zStartNeutral -= shiftz;
zEndNeutral -= shiftz;
if(opt.Contains("units")) {
zStartPlasma *= skindepth / PUnits::um;
zStartNeutral *= skindepth / PUnits::um;
zEndNeutral *= skindepth / PUnits::um;
}
// cout << "Start plasma = " << zStartPlasma << endl;
TLine *lineStartPlasma = new TLine(zStartPlasma,yMin,zStartPlasma,yMax);
lineStartPlasma->SetLineColor(kGray+2);
lineStartPlasma->SetLineStyle(2);
lineStartPlasma->SetLineWidth(3);
// cout << "Start plasma = " << zStartNeutral << endl;
TLine *lineStartNeutral = new TLine(zStartNeutral,yMin,zStartNeutral,yMax);
lineStartNeutral->SetLineColor(kGray+1);
lineStartNeutral->SetLineStyle(2);
lineStartNeutral->SetLineWidth(3);
// cout << "End plasma = " << zEndNeutral << endl;
TLine *lineEndNeutral = new TLine(zEndNeutral,yMin,zEndNeutral,yMax);
lineEndNeutral->SetLineColor(kGray+1);
lineEndNeutral->SetLineStyle(2);
lineEndNeutral->SetLineWidth(3);
// Plotting
// -----------------------------------------------
// Canvas setup
TCanvas *C = new TCanvas("C","2D Charge density and Electric field",750,666);
// Palettes setup
TExec *exPlasma = new TExec("exPlasma","plasmaPalette->cd();");
TExec *exElec = new TExec("exElec","redelectronPalette->cd();");
TExec *exHot = new TExec("exHot","hotPalette->cd();");
TExec *exField = new TExec("exField","rbow2Palette->cd();");
TExec *exFieldT = new TExec("exFieldT","redPalette->cd();");
TExec *exIonP = new TExec("exIonP","redPalette->cd();");
TExec *exPot = new TExec("exPot","rbow2invPalette->cd();");
// Actual Plotting!
// ------------------------------------------------------------
// Output file
TString fOutName = Form("./%s/Plots/Potential2D/Potential2D",pData->GetPath().c_str());
fOutName += Form("-%s_%i",pData->GetName(),time);
// Setup Pad layout:
Float_t lMargin = 0.15;
Float_t rMargin = 0.18;
Float_t bMargin = 0.15;
Float_t tMargin = 0.04;
Float_t factor = 1.0;
PlasmaGlob::CanvasAsymPartition(C,2,lMargin,rMargin,bMargin,tMargin,factor);
TPad *pad[2];
TString sLabels[] = {"(a)","(b)"};
// Text objects
TPaveText **textLabel = new TPaveText*[2];
C->cd(0);
char pname[16];
sprintf(pname,"pad_%i",1);
pad[0] = (TPad*) gROOT->FindObject(pname);
pad[0]->Draw();
pad[0]->cd(); // <---------------------------------------------- Top Plot ---------
if(opt.Contains("logz")) {
pad[0]->SetLogz(1);
} else {
pad[0]->SetLogz(0);
}
pad[0]->SetFrameLineWidth(3);
pad[0]->SetTickx(1);
// Re-range:
for(Int_t i=0; i<Nspecies; i++) {
if(!hDen2D[i]) continue;
hDen2D[i]->GetYaxis()->SetRangeUser(yMin -(factor-1)*yRange, yMax);
}
TH2F *hFrame = (TH2F*) gROOT->FindObject("hFrame1");
if(hFrame) delete hFrame;
hFrame = (TH2F*) hDen2D[0]->Clone("hFrame1");
hFrame->Reset();
hFrame->SetLabelFont(42,"xyz");
hFrame->SetTitleFont(42,"xyz");
hFrame->GetYaxis()->SetNdivisions(505);
hFrame->GetYaxis()->SetLabelSize(0.085);
hFrame->GetYaxis()->SetTitleSize(0.09);
hFrame->GetYaxis()->SetTitleOffset(0.7);
hFrame->GetYaxis()->SetTickLength(0.02);
hFrame->GetXaxis()->SetLabelOffset(999.);
hFrame->GetXaxis()->SetTitleOffset(999.);
hFrame->GetXaxis()->SetTickLength(0.04);
// Frame asymmetry:
hFrame->Draw("col");
// hDen2D[0]->GetZaxis()->SetNdivisions(505);
// Injected electrons if any
if(Nspecies>=3) {
if(hDen2D[2]) {
exHot->Draw();
hDen2D[2]->Draw("colz same");
}
}
// Plasma
hDen2D[0]->GetZaxis()->SetTitleFont(42);
exPlasma->Draw();
hDen2D[0]->Draw("colz same");
// Beam driver.
if(hDen2D[1]) {
// hDen2D[1]->GetZaxis()->SetNdivisions(505);
exElec->Draw();
hDen2D[1]->Draw("colz same");
}
{
TGraph *gr = (TGraph*) graphsV2D.At(4);
gr->Draw("C");
}
{
TGraph *gr = (TGraph*) graphsI2D.At(1);
gr->Draw("C");
}
if(opt.Contains("1dline")) {
lineYzero->Draw();
lineYdown->Draw();
lineYup->Draw();
}
if(opt.Contains("sline")) {
if(zStartPlasma>xmin && zStartPlasma<xmax)
lineStartPlasma->Draw();
if(zStartNeutral>xmin && zStartNeutral<xmax)
lineStartNeutral->Draw();
if(zEndNeutral>xmin && zEndNeutral<xmax)
lineEndNeutral->Draw();
}
// lineYdown->Draw();
// lineYup->Draw();
// Palettes re-arrangement
pad[0]->Update();
Float_t y1 = pad[0]->GetBottomMargin();
Float_t y2 = 1 - pad[0]->GetTopMargin();
Float_t x1 = pad[0]->GetLeftMargin();
Float_t x2 = 1 - pad[0]->GetRightMargin();
TPaletteAxis *palette = NULL;
if(Nspecies>=3) {
if(hDen2D[2]) {
palette = (TPaletteAxis*)hDen2D[2]->GetListOfFunctions()->FindObject("palette");
}
}
if(palette) {
palette->SetY2NDC(y2 - 0.00);
palette->SetY1NDC(0.66*(y1+y2) + 0.00);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
// palette->SetTitleFont(42);
// palette->SetTitleOffset(0.85);
palette->SetTitleOffset(999.9);
palette->SetTitleSize(0.075);
palette->SetLabelFont(42);
palette->SetLabelSize(0.075);
palette->SetLabelOffset(0.001);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
palette = (TPaletteAxis*)hDen2D[0]->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(0.66*(y1+y2) - 0.00);
palette->SetY1NDC(0.33*(y1+y2) + 0.00);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
// palette->SetTitleFont(42);
palette->SetTitleOffset(0.80);
palette->SetTitleSize(0.075);
palette->SetLabelFont(42);
palette->SetLabelSize(0.075);
palette->SetLabelOffset(0.001);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
palette = (TPaletteAxis*)hDen2D[1]->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(0.33*(y1+y2) - 0.00);
palette->SetY1NDC(y1 + 0.00);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
//palette->SetTitleFont(42);
//palette->SetTitleOffset(0.85);
palette->SetTitleOffset(999.9);
palette->SetTitleSize(0.075);
palette->SetLabelFont(42);
palette->SetLabelSize(0.075);
palette->SetLabelOffset(0.001);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
// 1D charge density plots:
Float_t yaxismin = pad[0]->GetUymin();
Float_t yaxismax = pad[0]->GetUymin() + 0.33*(pad[0]->GetUymax() - pad[0]->GetUymin()) - 0.00;
Float_t denmin = Min[1];
Float_t denmax = Max[1];
if(opt.Contains("logz")) {
denmin = TMath::Log10(denmin);
denmax = TMath::Log10(denmax);
}
Float_t curmin = 0.0;
Float_t curmax = 0.0;
if(opt.Contains("curr")) {
curmin = 0.0;
curmax = hCur1D[1]->GetMaximum();
cout << Form(" Maximum driver current = %6.2f kA ", curmax) << endl ;
if(Nspecies>=3)
if(hCur1D[2])
cout << Form(" Maximum witness current = %6.2f kA ", hCur1D[2]->GetMaximum()) << endl ;
// Round for better plotting
curmax = 0.1*TMath::Nint(curmax*10);
}
for(Int_t i=0; i<Nspecies; i++) {
if(!hDen1D[i]) continue;
Float_t slope = (yaxismax - yaxismin)/(denmax - denmin);
for(Int_t j=0; j<hDen1D[i]->GetNbinsX(); j++) {
Float_t content = hDen1D[i]->GetBinContent(j+1);
if(opt.Contains("logz")) content = TMath::Log10(content);
if(content<denmin)
hDen1D[i]->SetBinContent(j+1,yaxismin);
else
hDen1D[i]->SetBinContent(j+1,(content - denmin) * slope + yaxismin);
}
if(hCur1D[i]) {
slope = (yaxismax - yaxismin)/(curmax - curmin);
for(Int_t j=0; j<hCur1D[i]->GetNbinsX(); j++) {
Float_t content = hCur1D[i]->GetBinContent(j+1);
if(content<curmin)
hCur1D[i]->SetBinContent(j+1,yaxismin);
else
hCur1D[i]->SetBinContent(j+1,(content - curmin) * slope + yaxismin);
}
}
}
// Plasma on-axis density:
// hDen1D[0]->SetLineWidth(2);
// hDen1D[0]->SetLineColor(kGray+1);
// // // PlasmaGlob::SetH1Style(hDen1D[0],1);
// hDen1D[0]->Draw("same C");
if(opt.Contains("curr")) {
hCur1D[1]->SetLineWidth(2);
hCur1D[1]->SetLineColor(PlasmaGlob::elecLine);
hCur1D[1]->Draw("same C");
} else {
hDen1D[1]->SetLineWidth(2);
hDen1D[1]->SetLineColor(PlasmaGlob::elecLine);
// hDen1D[1]->Draw("same C");
}
if(Nspecies>=3) {
if(hDen1D[2]) {
if(opt.Contains("curr")) {
hCur1D[2]->SetLineWidth(2);
hCur1D[2]->SetLineColor(kOrange+8);
hCur1D[2]->Draw("same C");
} else {
hDen1D[2]->SetLineWidth(2);
hDen1D[2]->SetLineColor(kOrange+8);
// hDen1D[2]->Draw("same C");
}
}
}
// Current axis
TGaxis *axis = NULL;
if(opt.Contains("curr")) {
axis = new TGaxis(xMax-xRange/6.0,yMin - (factor-1)*yRange,
xMax-xRange/6.0,yaxismax,
0.001,curmax,503,"+LS");
axis->SetLineWidth(1);
axis->SetLineColor(kGray+3);//PlasmaGlob::elecLine);
axis->SetLabelColor(kGray+3);//PlasmaGlob::elecLine);
axis->SetLabelSize(0.06);
axis->SetLabelOffset(0.01);
axis->SetLabelFont(42);
axis->SetTitleColor(kGray+3);//PlasmaGlob::elecLine);
axis->SetTitleSize(0.06);
axis->SetTitleOffset(0.6);
axis->SetTitleFont(42);
axis->SetTickSize(0.03);
axis->SetTitle("I [kA]");
axis->CenterTitle();
axis->SetNdivisions(505);
axis->Draw();
}
TPaveText *textTime = new TPaveText(xMax - 0.3*xRange, yMax-0.15*yRange, xMax-0.1, yMax-0.05*yRange);
//x2-0.17,y2-0.12,x2-0.02,y2-0.02,"NDC");
PlasmaGlob::SetPaveTextStyle(textTime,32);
char ctext[128];
if(opt.Contains("units") && n0)
sprintf(ctext,"z = %5.1f #mum", Time * skindepth / PUnits::um);
else
sprintf(ctext,"t = %5.1f #omega_{p}^{-1}",Time);
textTime->SetTextFont(42);
textTime->AddText(ctext);
textTime->Draw();
// textDen->Draw();
// if(opt.Contains("units"))
// textWav->Draw();
textLabel[0] = new TPaveText(xMin + 0.02*xRange, yMax-0.2*yRange, xMin+0.30*xRange, yMax-0.05*yRange);
PlasmaGlob::SetPaveTextStyle(textLabel[0],12);
textLabel[0]->SetTextFont(42);
textLabel[0]->AddText(sLabels[0]);
textLabel[0]->Draw();
pad[0]->RedrawAxis();
C->cd(0);
sprintf(pname,"pad_%i",0);
pad[1] = (TPad*) gROOT->FindObject(pname);
pad[1]->Draw();
pad[1]->cd(); // <--------------------------------------------------------- Bottom Plot
pad[1]->SetFrameLineWidth(3);
pad[1]->SetTickx(1);
hFrame = (TH2F*) gROOT->FindObject("hFrame2");
if(hFrame) delete hFrame;
hFrame = (TH2F*) hDen2D[0]->Clone("hFrame2");
hFrame->Reset();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[1]->GetAbsHNDC();
hFrame->GetYaxis()->SetLabelSize(yFactor*0.085);
hFrame->GetYaxis()->SetTitleSize(yFactor*0.09);
hFrame->GetYaxis()->SetTitleOffset(0.7/yFactor);
hFrame->GetYaxis()->SetTickLength(0.02/yFactor);
hFrame->GetXaxis()->SetTitleSize(0.10);
hFrame->GetXaxis()->SetLabelSize(0.08);
hFrame->GetXaxis()->SetLabelOffset(0.02);
hFrame->GetXaxis()->SetTitleOffset(1.0);
hFrame->GetXaxis()->SetTickLength(0.04*yFactor);
hFrame->SetLabelFont(42,"xyz");
hFrame->SetTitleFont(42,"xyz");
hFrame->Draw("col");
// hE2D[0]->GetZaxis()->SetNdivisions(505);
hV2D->GetZaxis()->SetTitleFont(42);
hV2D->GetZaxis()->SetTickLength(0.02/yFactor);
exPot->Draw();
hV2D->Draw("col z same");
for(Int_t i=0; i<graphsV2D.GetEntriesFast(); i++) {
TGraph *gr = (TGraph*) graphsV2D.At(i);
if(!gr) continue;
gr->Draw("C");
}
for(Int_t i=0; i<graphsI2D.GetEntriesFast(); i++) {
//if(i!=2) continue;
TGraph *gr = (TGraph*) graphsI2D.At(i);
if(!gr) continue;
gr->Draw("C");
}
if(opt.Contains("1dline")) {
lineYzero->Draw();
lineYdown->Draw();
lineYup->Draw();
}
if(opt.Contains("sline")) {
if(zStartPlasma>xmin && zStartPlasma<xmax)
lineStartPlasma->Draw();
if(zStartNeutral>xmin && zStartNeutral<xmax)
lineStartNeutral->Draw();
if(zEndNeutral>xmin && zEndNeutral<xmax)
lineEndNeutral->Draw();
}
pad[1]->Update();
y1 = pad[1]->GetBottomMargin();
y2 = 1 - pad[1]->GetTopMargin();
x1 = pad[1]->GetLeftMargin();
x2 = 1 - pad[1]->GetRightMargin();
palette = (TPaletteAxis*)hV2D->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - 0.00);
palette->SetY1NDC(y1 + 0.00);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
// palette->SetTitleFont(42);
palette->SetTitleSize(yFactor*0.075);
palette->SetTitleOffset(0.80/yFactor);
palette->SetLabelSize(yFactor*0.075);
palette->SetLabelFont(42);
palette->SetLabelOffset(0.01/yFactor);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
pad[1]->RedrawAxis();
textLabel[1] = new TPaveText(xMin + 0.02*xRange, yMax-0.2*yRange, xMin+0.30*xRange, yMax-0.05*yRange);
PlasmaGlob::SetPaveTextStyle(textLabel[1],12);
textLabel[1]->SetTextFont(42);
textLabel[1]->AddText(sLabels[1]);
textLabel[1]->Draw();
C->cd();
// Print to a file
PlasmaGlob::imgconv(C,fOutName,opt);
// ---------------------------------------------------------
PlasmaGlob::DestroyCanvases();
}
void draw_2D(bool isPrompt = true, bool is8rap9pt2gev = true)
{
gROOT->Macro("./JpsiStyle2D.C");
gStyle->SetPaintTextFormat(".3f");
// --- read-in file
TFile * f2D;
char* sampleName;
char* strPrompt;
char* strBin;
if (isPrompt) { strPrompt = "PRMC";}
else { strPrompt = "NPMC";}
if (is8rap9pt2gev) { strBin = "8rap9pt2gev";}
else { strBin = "6rap3pt";}
// f2D = new TFile(Form("./EffCounting_%s_%spythia_Pbp_useCtErr_1_useDataDriven_1_useZvtxStep1_0_Step2_1.root",strBin,strPrompt));
f2D = new TFile(Form("./EffCounting_%s_%spythia_Pbp_useCtErr_1_useDataDriven_0_useZvtxStep1_0_Step2_1.root",strBin,strPrompt));
sampleName = Form("%s_%s",strBin,strPrompt);
cout << "sampleName = " << sampleName << endl;
// --- read-in 2D hist
TH2D* h2D_Den = (TH2D*)f2D->Get("h2D_Den_pt_y");
TH2D* h2D_Num = (TH2D*)f2D->Get("h2D_Num_pt_y");
TH2D* h2D_Eff = (TH2D*)f2D->Get("h2D_Eff_pt_y");
//latex box for beam, rapidity, pT info
TLatex* latex = new TLatex();
latex->SetNDC();
latex->SetTextAlign(12);
latex->SetTextSize(0.04);
//////////////////////////////////////////////////////////////////
// --- Draw histograms
TCanvas* c1 = new TCanvas("c1","c1",700,600);
TPaletteAxis* pal;
c1->cd();
/*
h2D_Den->GetXaxis()->SetTitle("y_{lab}");
h2D_Den->GetXaxis()->CenterTitle();
h2D_Den->GetYaxis()->SetTitle("p_{T} (GeV/c)");
h2D_Den->Draw("colz");
c1->Update();
pal = (TPaletteAxis*)h2D_Den->GetListOfFunctions()->FindObject("palette");
pal->SetX2NDC(0.92);
c1->Modified();
c1->Update();
c1->SaveAs(Form("acc2Dplots/h2D_Den_isPrompt%d.pdf",(int)isPrompt));
h2D_Num->GetXaxis()->SetTitle("y_{lab}");
h2D_Num->GetXaxis()->CenterTitle();
h2D_Num->GetYaxis()->SetTitle("p_{T} (GeV/c)");
h2D_Num->Draw("colz");
c1->Update();
pal = (TPaletteAxis*)h2D_Num->GetListOfFunctions()->FindObject("palette");
pal->SetX2NDC(0.92);
c1->Modified();
c1->Update();
c1->SaveAs(Form("acc2Dplots/h2D_Num_isPrompt%d.pdf",(int)isPrompt));
*/
h2D_Eff->GetXaxis()->SetTitle("y_{lab}");
h2D_Eff->GetXaxis()->CenterTitle();
h2D_Eff->GetYaxis()->SetTitle("p_{T} (GeV/c)");
h2D_Eff->SetMaximum(1.);
h2D_Eff->Draw("colz");
//h2D_Eff->SetMarkerSize(0.8);
//h2D_Eff->Draw("text e colz");
c1->Update();
pal = (TPaletteAxis*)h2D_Eff->GetListOfFunctions()->FindObject("palette");
pal->SetX2NDC(0.92);
c1->Modified();
c1->Update();
if (is8rap9pt2gev) {
dashedLine(-2.4,2.0,-1.97,2.0,1,4);
dashedLine(-1.97,2.0,-1.97,3.0,1,4);
dashedLine(-1.97,3.0,-1.37,3.0,1,4);
dashedLine(-1.37,3.0,-1.37,6.5,1,4);
dashedLine(-1.37,6.5,1.03,6.5,1,4);
dashedLine(1.03,5.0,1.03,6.5,1,4);
dashedLine(1.03,5.0,1.46,5.0,1,4);
dashedLine(1.46,3.0,1.46,5.0,1,4);
dashedLine(1.46,3.0,1.93,3.0,1,4);
dashedLine(1.93,2.0,1.93,3.0,1,4);
dashedLine(1.93,2.0,2.4,2.0,1,4);
dashedLine(2.4,2.0,2.4,30.0,1,4);
dashedLine(-2.4,30.0,2.4,30.0,1,4);
dashedLine(-2.4,2.0,-2.4,30.0,1,4);
}
else {
dashedLine(-2.4,5.0,-1.97,5.0,1,4);
dashedLine(-1.97,5.0,-1.97,6.5,1,4);
dashedLine(-1.97,6.5,1.03,6.5,1,4);
dashedLine(1.03,5.0,1.03,6.5,1,4);
dashedLine(1.03,5.0,1.46,5.0,1,4);
dashedLine(1.46,5.0,1.46,30.0,1,4);
dashedLine(-2.4,30.0,1.46,30.0,1,4);
dashedLine(-2.4,5.0,-2.4,30.0,1,4);
}
c1->SaveAs(Form("eff2Dplots/h2D_Eff_%s.pdf",sampleName));
return;
}
void EventDisplayForBaby(bool sig=false, bool truth=true, bool fatjet=true, int event=-1)
{
gInterpreter->ExecuteMacro("~/macros/rootlogon.C");
// chain
TChain *ch = new TChain("tree");
if(!sig) ch->Add("babies/small_quick_cfA_746p1_nleps1_trig0ON.root");
if(sig) ch->Add("~/scratch/plots/1d_2015d_13Jan2016/2d/48ipb/*.root");
InitBaby(ch);
Int_t nentries = (Int_t)ch->GetEntries();
for(int i = 0; i<nentries; i++)
{
ch->GetEntry(i);
// apply selections (event==-1 && mj_>xxx && ht_>yyy && ...)
// or
// select an event (event!=-1 && event_=xxxxxx)
// "event" is one of the arguments
if(event>0 && event_!=event) continue;
//
// Event Display
//
float start=0.62;
float nextline = start;
float increment = 0.04;
float offset=0.02;
int npert;
int LSPcol[2] = {kCyan+1,kOrange-4};
if(!sig) npert = 5;
else npert=3;
float xalign = 0.82;
vector<TMarker> constituents, genpart;
TEllipse *cone[fjets_pt_->size()];
TH2F *h_fatjets = new TH2F("h_fatjets","h_fatjets", 230, -5.0, 5.0, 144, -3.141592, 3.141592);
cout << event_ << endl;
for(int ifj = 0; ifj< (int)fjets_pt_->size(); ifj++)
{ if(ifj==0) cout << "... Fatjets info(pT, eta, phi, mj)" << endl;
h_fatjets->Fill(fjets_eta_->at(ifj),fjets_phi_->at(ifj), fjets_m_->at(ifj));
cout << fjets_pt_->at(ifj) << " " << fjets_eta_->at(ifj) << " "
<< fjets_phi_->at(ifj) << " " << fjets_m_->at(ifj) << endl;
}
TString cname = Form("Event_%lli_",event_);
TCanvas *c = new TCanvas(cname,cname,1640,760);
gPad->SetRightMargin(0.35);
h_fatjets->SetZTitle("m_{j} [GeV]");
h_fatjets->GetZaxis()->SetTitleSize(0.05);
h_fatjets->GetZaxis()->SetTitleOffset(0.55);
h_fatjets->GetYaxis()->SetTitleOffset(0.6);
h_fatjets->Draw("colz");
h_fatjets->GetZaxis()->SetRangeUser(0,1.1*h_fatjets->GetMaximum());
h_fatjets->Draw("colz");
gPad->Update();
TPaletteAxis *palette = (TPaletteAxis*)h_fatjets->GetListOfFunctions()->FindObject("palette");
for(int ifj = 0; ifj< (int)fjets_pt_->size(); ifj++)
{
cone[ifj] = new TEllipse(fjets_eta_->at(ifj),fjets_phi_->at(ifj), 1.2, 1.2);
// cone[ifj]->SetFillStyle(3003);
cone[ifj]->SetFillStyle(0);
Int_t binx,biny,binz;
h_fatjets->GetBinXYZ(h_fatjets->FindBin(fjets_eta_->at(ifj),fjets_phi_->at(ifj)),binx,biny,binz);
//cout<<"bin x bin y "<<binx<<" "<<biny<<endl;
//cout<<"content "<<h_fatjets->GetBinContent(binx,biny)<<endl;
//cout<<palette<<endl;
Int_t ci = palette->GetBinColor(binx,biny);
if(ifj==0) ci = palette->GetBinColor(binx,biny);
//cout<<"color"<<ci<<endl;
cone[ifj]->SetFillColor(kGray);
cone[ifj]->SetLineColor(ci);
}
float lepPt, lepEta, lepPhi;
if(nels_==1)
{
for(int i=0; i<(int)els_pt_->size(); i++)
{
if(els_miniso_->at(i)>0.1) continue;
if(els_sigid_->at(i)!=1) continue;
if(els_pt_->at(i)<20) continue;
lepPt =els_pt_->at(i);
lepEta =els_eta_->at(i);
lepPhi =els_phi_->at(i);
}
}
if(nmus_==1)
{
for(int i=0; i<(int)mus_pt_->size(); i++)
{
if(mus_miniso_->at(i)>0.2) continue;
if(mus_sigid_->at(i)!=1) continue;
if(mus_pt_->at(i)<20) continue;
lepPt =mus_pt_->at(i);
lepEta =mus_eta_->at(i);
lepPhi =mus_phi_->at(i);
}
}
myText(xalign+0.01,0.96,Form("H_{T} = %.0f GeV",ht_),1,0.04);
myText(xalign+0.01,0.91,Form("M_{J} = %.0f GeV",mj_),1,0.04);
myText(xalign+0.01,0.86,Form("#slash{E}_{T} = %.0f GeV",met_),1,0.04);
myText(xalign+0.01,0.81,Form("m_{T} = %.0f GeV",mt_),1,0.04);
myText(xalign+0.01,0.76,Form("reco %s p_{T} = %.0f GeV", nmus_==1?"#mu":"e", lepPt), kBlack, 0.04);
nextline=0.76;
TMarker recolep = TMarker(lepEta, lepPhi, 27);
recolep.SetMarkerSize(4);
recolep.SetMarkerColor(kRed);
genpart.push_back(recolep);
TMarker mumark = TMarker(xalign,nextline,27);
mumark.SetNDC();
mumark.SetX(xalign);
mumark.SetY(nextline+0.01);
mumark.SetMarkerSize(2);
mumark.SetMarkerColor(kRed);
genpart.push_back(mumark);
myText(xalign+0.01,0.71,Form("-- large-R jets --"),1,0.04);
myText(xalign+0.01,0.67,Form("(pT, eta, phi, mass)"),1,0.03);
nextline=0.635;
for(int ifj = 0; ifj< (int)fjets_pt_->size(); ifj++)
{
myText(xalign+0.01,nextline,Form("%3.0f, %2.1f, %2.1f, %3.0f",
fjets_pt_->at(ifj),fjets_eta_->at(ifj),fjets_phi_->at(ifj),fjets_m_->at(ifj)),1,0.03);
nextline=nextline-0.035;
}
nextline=nextline-0.015;
myText(xalign+0.01,nextline,Form("-- AK4 jets --"),1,0.04);
nextline=nextline-0.04;
myText(xalign+0.01,nextline,Form("(pT, eta, phi)"),1,0.03);
nextline=nextline-0.035;
for(int ij = 0; ij< (int)jets_pt_->size(); ij++)
{
if(jets_islep_->at(ij)==1) continue;
myText(xalign+0.01,nextline,Form("%3.0f, %2.1f, %2.1f",
jets_pt_->at(ij),jets_eta_->at(ij),jets_phi_->at(ij)),1,0.03);
nextline=nextline-0.035;
}
if(truth) myText(xalign,0.68,"Gen p_{T} [GeV]",1,0.04);
if(truth) myText(xalign,0.68,"Gen p_{T} [GeV]",1,0.04);
TArrow line1 = TArrow();
if(truth)line1.DrawLineNDC(xalign-0.02,start+0.035,xalign+0.14,start+0.035);
TMarker met = TMarker(0, met_phi_, 27);
met.SetMarkerSize(4);
met.SetMarkerColor(kMagenta);
genpart.push_back(met);
TMarker metmark = TMarker(0.81,0.86,27);
metmark.SetNDC();
metmark.SetX(xalign);
metmark.SetY(0.87);
metmark.SetMarkerSize(2);
metmark.SetMarkerColor(kMagenta);
genpart.push_back(metmark);
TMarker jetmark = TMarker(0.5,0.5,20);
jetmark.SetNDC();
jetmark.SetMarkerSize(1.2);
jetmark.SetX(0.12);
jetmark.SetY(0.2);
genpart.push_back(jetmark);
myText(0.13,0.19,"AK4 Jets",kBlack,0.04);
TMarker bjetmark = TMarker(0.5,0.5,20);
bjetmark.SetNDC();
bjetmark.SetMarkerSize(1.2);
bjetmark.SetMarkerColor(8);
bjetmark.SetX(0.12);
bjetmark.SetY(0.16);
genpart.push_back(bjetmark);
myText(0.13,0.15,"CSVM AK4",kBlack,0.04);
myText(0.08,0.94,"Ring color indicates FJ mass",kBlack,0.04);
// if(sig) nextline = start - (4*npert+2)*increment-0.02-offset;
//else nextline = start - 2*npert*increment-offset;
for(int ij=0;ij<(int)jets_pt_->size();ij++)
{
if(jets_islep_->at(ij)==1) continue;
if(ij==0) cout << "... skinny jet info (pT eta phi)" << endl;
cout << jets_pt_->at(ij) << " " << jets_eta_->at(ij) << " " << jets_phi_->at(ij) << endl;
TMarker jet = TMarker(jets_eta_->at(ij),jets_phi_->at(ij),20);
jet.SetMarkerSize(1.2);
if(jets_csv_->at(ij)>0.890) jet.SetMarkerColor(8);
constituents.push_back(jet);
}
/*
bool drawn=false;
for(int ifj = 0; ifj< (int)fjets.size(); ifj++){
vector<fastjet::PseudoJet> cons = fjets[ifj].constituents();
for(int ics = 0; ics<(int)cons.size();ics++){
for(int ifj2=0; ifj2<(int)fjets.size(); ifj2++){
if(ifj2==ifj) continue;
TArrow first = TArrow(cons[ics].eta(),cons[ics].phi_std(), fjets[ifj].eta(),fjets[ifj].phi_std(),0.04,">");
if(deltaR(cons[ics].eta(),cons[ics].phi_std(), fjets[ifj2].eta(),fjets[ifj2].phi_std()) < 1.25){
//cout<<"type 1 line: con eta phi FJ eta phi"<<cons[ics].eta()<<" "<<cons[ics].phi_std()<<" "<<fjets[ifj2].eta()<<" "<<fjets[ifj2].phi_std()<<endl;
first.DrawArrow(cons[ics].eta(),cons[ics].phi_std(), fjets[ifj].eta(),fjets[ifj].phi_std(),0.0045,"|>");
drawn=true;
break;
}
else if(deltaR(cons[ics].eta(),cons[ics].phi_std(), fjets[ifj].eta(),fjets[ifj].phi_std()) > 1.15){
//cout<<"type 2 line: con eta phi FJ eta phi"<<cons[ics].eta()<<" "<<cons[ics].phi_std()<<" "<<fjets[ifj].eta()<<" "<<fjets[ifj].phi_std()<<endl;
first.DrawArrow(cons[ics].eta(),cons[ics].phi_std(), fjets[ifj].eta(),fjets[ifj].phi_std(),0.0045,"|>");
drawn=true;
break;}
}
}
cons.clear();
}
if(drawn) myText(0.12,0.04,"Arrows indicate ambiguous clustering ownership",kBlack,0.03);
*/
if(truth)
{
int col[4] = {30,38,44,46};
if(!sig) col[1]=46;
int LSP,top,b,W,Wda,gl;
LSP=0;top=0;b=0;W=0;Wda=0;gl=0;
TLorentzVector vgl[2];
TLorentzVector vt[4];
TLorentzVector vLSP[2];
for(unsigned int imc = 0; imc < mc_id_->size(); imc++)
{
int id= (int)mc_id_->at(imc);
int absid = abs(id);
int mid = (int)mc_mom_->at(imc);
int absmid= abs(mid);
if(id!=mid)
{
int marknum=0;
TString partname;
int color=0;
bool flag=false;
if(id==1000021){
if(gl<2) vgl[gl].SetPtEtaPhiM(mc_pt_->at(imc), mc_eta_->at(imc), mc_phi_->at(imc), 1500);
gl++;
}
if(id==1000022)
{
color = LSPcol[LSP];
partname = "#tilde{#chi}^{0}_{1}";
if(LSP==0) nextline=start-2*npert*increment;
else nextline = start - (4*npert+1)*increment-offset;
LSP++;
flag=true;
marknum=25;//27;
}
if(absid == 6)
{
//top
marknum=22;
partname = "t";
flag =true;
nextline = start - npert*top*increment;
color = col[top];
if(!sig) {}
if(sig) {if(top>1){ nextline-=(increment+offset);}}
if(top<4)vt[top].SetPtEtaPhiM(mc_pt_->at(imc), mc_eta_->at(imc), mc_phi_->at(imc), 172.5);
top++;
}
if(absid==5 && (mid==6 || mid==(-6)))
{
//b from top
marknum=23;
partname="b";
flag=true;
color = col[b];
nextline = start - npert*b*increment - 2*increment;
// if(!sig){}
if(sig) {if(b>1){ nextline-=(increment+offset);}}
b++;
}
if(absid==24 && (mid==6 || mid==(-6)))
{
//W
marknum=34;
partname = "W";
flag=true;
color = col[W];
nextline = start - npert*W*increment - increment;
// if(!sig){}
if(sig){if(W>1){ nextline-=(increment+offset);}}
W++;
}
if((absid==13 || absid== 11 || absid==15) && absmid==24)
{
marknum=29;
if(absid==13) partname = "#mu";
else if(absid==11) partname = "e";
else partname = "#tau";
if(!sig) flag =true;
color = col[TMath::FloorNint(Wda/2)];
nextline = start - npert*increment*TMath::FloorNint(Wda/2)-3*increment;
if(TMath::FloorNint(Wda/2) != Wda/2) nextline-=increment;
Wda++;
}
if((absid==12 || absid== 14 || absid==16) && absmid==24)
{
marknum=30;
partname = "#nu";
if(!sig) flag =true;
color = col[TMath::FloorNint(Wda/2)];
nextline = start - npert*increment*TMath::FloorNint(Wda/2)-4*increment;
//if(TMath::FloorNint(Wda/2) != Wda/2) nextline-=increment;
Wda++;
}
if((absid>0 && absid<5) && absmid==24)
{
marknum=3;
if(absid==1) partname="d";
if(absid==2) partname="u";
if(absid==3) partname="s";
if(absid==4) partname="c";
if(!sig) flag =true;
color = col[TMath::FloorNint(Wda/2)];
nextline = start - npert*increment*TMath::FloorNint(Wda/2)-3*increment;
// if(TMath::FloorNint(Wda/2) != Wda/2) nextline-=increment;
if(absid % 2 ==1) nextline-=increment;
Wda++;
}
if(flag)
{
TMarker temp = TMarker(mc_eta_->at(imc),mc_phi_->at(imc), marknum);
TMarker legmark = TMarker(0.81,nextline,marknum);
legmark.SetNDC();
legmark.SetX(xalign+0.01);
legmark.SetY(nextline+0.011);
TString label = partname + " " + Form("%.0f",mc_pt_->at(imc));
myText(xalign+0.03,nextline,partname,color,0.04);
myText(xalign+0.07,nextline,Form("%.0f",mc_pt_->at(imc)),color,0.04);
temp.SetMarkerColor(color);
legmark.SetMarkerColor(color);
temp.SetMarkerSize(2);
legmark.SetMarkerSize(2);
if(absid==6 || absid==13 || absid==1000022){ temp.SetMarkerSize(3);}
genpart.push_back(temp);
genpart.push_back(legmark);
flag=false;
}
}
}
if(sig && LSP==0){
int color = LSPcol[LSP];
TString partname = "#tilde{#chi}^{0}_{1}";
if(LSP==0) nextline=start-2*npert*increment;
else nextline = start - (4*npert+1)*increment-offset;
LSP++;
int marknum=25;//27;
// TMarker temp = TMarker(mc_doc_eta->at(imc),mc_doc_phi->at(imc), marknum);
vLSP[0]= vgl[0]-vt[0]-vt[1];
TMarker temp = TMarker(vLSP[0].Eta(),vLSP[0].Phi(), marknum);
TMarker legmark = TMarker(0.81,nextline,marknum);
legmark.SetNDC();
legmark.SetX(xalign+0.01);
legmark.SetY(nextline+0.011);
TString label = partname + " " + Form("%.0f",vLSP[0].Pt());
myText(xalign+0.03,nextline,partname,color,0.04);
myText(xalign+0.07,nextline,Form("%.0f",vLSP[0].Pt()),color,0.04);
temp.SetMarkerColor(color);
legmark.SetMarkerColor(color);
temp.SetMarkerSize(3);
legmark.SetMarkerSize(2);
genpart.push_back(temp);
genpart.push_back(legmark);
}
if(sig && LSP==1){
int color = LSPcol[LSP];
TString partname = "#tilde{#chi}^{0}_{1}";
if(LSP==0) nextline=start-2*npert*increment;
else nextline = start - (4*npert+1)*increment-offset;
LSP++;
int marknum=25;//27;
// TMarker temp = TMarker(mc_doc_eta->at(imc),mc_doc_phi->at(imc), marknum);
vLSP[1]= vgl[1]-vt[2]-vt[3];
TMarker temp = TMarker(vLSP[1].Eta(),vLSP[1].Phi(), marknum);
TMarker legmark = TMarker(0.81,nextline,marknum);
legmark.SetNDC();
legmark.SetX(xalign+0.01);
legmark.SetY(nextline+0.011);
TString label = partname + " " + Form("%.0f",vLSP[1].Pt());
myText(xalign+0.03,nextline,partname,color,0.04);
myText(xalign+0.07,nextline,Form("%.0f",vLSP[1].Pt()),color,0.04);
temp.SetMarkerColor(color);
legmark.SetMarkerColor(color);
temp.SetMarkerSize(3);
legmark.SetMarkerSize(2);
genpart.push_back(temp);
genpart.push_back(legmark);
}
}
for(int ix=0;ix<(int)genpart.size();ix++)
{
genpart[ix].Draw("same");
}
for(int iy=0;iy<(int)constituents.size();iy++)
{
constituents[iy].Draw("same");
}
for(int ifj = 0; ifj< (int)fjets_pt_->size(); ifj++)
{
if(fatjet) cone[ifj]->Draw();
}
h_fatjets->Draw("colz same");
h_fatjets->SetTitle(Form("Event %lli",event_));
h_fatjets->SetStats(0);
h_fatjets->SetXTitle("#eta");
h_fatjets->SetYTitle("#phi");
TString savename;
if(!sig) savename = "fig/EventDisplay_"+cname+Form("%i_FJ",nfjets_);
else savename = "fig/EventDisplay_"+cname+Form("%i_FJ",nfjets_);
if(truth) savename+="_truth";
else savename+="_notruth";
if(fatjet) savename+="_fatjet";
else savename+="_nofatjet";
c->Print(savename+".pdf");
//c->Print(savename+".C");
c->Close();
h_fatjets->Delete();
}
}
void printEff(TTree* HltTree,const char *cut,const char *title, char *projectTitle)
{
cout <<" * "<<title<<":"<<endl;
cout <<" * Efficiencies:"<<endl;
double nEvt = HltTree->GetEntries(cut);
cout <<" | "<<setw(20)<<"HLT Path";
cout <<" | "<<setw(25)<<"Efficiency";
cout <<" | "<<endl;
triggers->clear();
triggerCuts->clear();
vector <double*> effs;
// calculate the efficiency //
effs.push_back(calcEff(HltTree,"L1Tech_BSC_OR",nEvt,Form("(%s)&&L1Tech_BSC_minBias_OR.v0==1",cut)));
effs.push_back(calcEff(HltTree,"L1Tech_BSC_thr1",nEvt,Form("(%s)&&L1Tech_BSC_minBias_threshold1.v0==1",cut)));
effs.push_back(calcEff(HltTree,"L1Tech_BSC_thr2",nEvt,Form("(%s)&&L1Tech_BSC_minBias_threshold2.v0==1",cut)));
effs.push_back(calcEff(HltTree,"L1Tech_BSC_inner_thr1",nEvt,Form("(%s)&&L1Tech_BSC_minBias_inner_threshold1.v0==1",cut)));
effs.push_back(calcEff(HltTree,"L1Tech_BSC_inner_thr2",nEvt,Form("(%s)&&L1Tech_BSC_minBias_inner_threshold2.v0==1",cut)));
effs.push_back(calcEff(HltTree,"L1Tech_HF_coinc_PM",nEvt,Form("(%s)&&L1Tech_HCAL_HF_coincidence_PM.v0==1",cut)));
effs.push_back(calcEff(HltTree,"HLT_MBPixel_1Track",nEvt,Form("(%s)&&HLT_MinBiasPixel_SingleTrack==1",cut)));
//effs.push_back(calcEff(HltTree,"L1Tech_BSC_splash_beam1.v0",nEvt,Form("(%s)&&L1Tech_BSC_splash_beam1.v0==1",cut)));
//effs.push_back(calcEff(HltTree,"L1Tech_BSC_splash_beam2.v0",nEvt,Form("(%s)&&L1Tech_BSC_splash_beam2.v0==1",cut)));
//effs.push_back(calcEff(HltTree,"All",nEvt,Form("(%s)&&(L1Tech_BSC_minBias_threshold1.v0||L1Tech_BSC_minBias_threshold2.v0||L1Tech_BSC_minBias_OR.v0||L1Tech_BSC_minBias_inner_threshold1.v0||L1Tech_BSC_minBias_inner_threshold2.v0||L1Tech_BSC_splash_beam1.v0||L1Tech_BSC_splash_beam2.v0)",cut)));
results->push_back(effs);
cout <<" * Correlation Matrix:"<<endl;
int tsize = (int)triggers->size();
TH2D *h = new TH2D(Form("h%s",title),"",tsize,0,tsize,tsize,0,tsize);
TH2D *hct = new TH2D(Form("h%s_ct",title),"",tsize,0,tsize,tsize,0,tsize);
for (int i=tsize-1;i>=0;i--){
int nEvtAfterCut = HltTree->GetEntries((*triggerCuts)[i].c_str());
h->GetXaxis()->SetBinLabel(i+1,(*triggers)[i].c_str());
h->GetYaxis()->SetBinLabel(i+1,(*triggers)[i].c_str());
hct->GetXaxis()->SetBinLabel(i+1,(*triggers)[i].c_str());
hct->GetYaxis()->SetBinLabel(i+1,(*triggers)[i].c_str());
for (int j=0;j<tsize;j++){
string cut ="("+(*triggerCuts)[i]+")&&("+(*triggerCuts)[j]+")";
double* eff = calcEff(HltTree,"",nEvtAfterCut,Form("%s",cut.c_str()),0);
if (nEvtAfterCut==0) eff[0]=0;
h->SetBinContent(i+1,j+1,int(eff[0]*100000)/1000.);
hct->SetBinContent(i+1,j+1,HltTree->GetEntries(cut.c_str()));
}
}
h->GetXaxis()->LabelsOption("v");
hct->GetXaxis()->LabelsOption("v");
TCanvas *c1 = new TCanvas(Form("c%s",title), Form("c_%s",title),800,600);
c1->Range(-3.609756,-1.910995,12.7561,10.60209);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetBorderSize(0);
c1->SetTickx();
c1->SetTicky();
c1->SetLeftMargin(0.25);
c1->SetRightMargin(0.1684054);
c1->SetTopMargin(0.02);
c1->SetBottomMargin(0.3);
c1->SetFrameLineColor(0);
c1->SetFrameBorderMode(0);
c1->SetFrameLineColor(0);
c1->SetFrameBorderMode(0);
h->Draw("col text");
TPaletteAxis *palette = new TPaletteAxis(tsize*1.02,0,tsize*1.1,tsize,h);
palette->SetLabelColor(1);
palette->SetLabelFont(42);
palette->SetLabelOffset(0.005);
palette->SetLabelSize(0.045);
palette->SetTitleOffset(1);
palette->SetTitleSize(0.04);
palette->SetFillColor(100);
palette->SetFillStyle(1001);
h->GetListOfFunctions()->Add(palette,"br");
h->Draw("col text z");
string fname(Form("plot_%s_%s.gif",projectTitle,title));
c1->SaveAs(fname.c_str());
c1->SaveAs(Form("plot_%s_%s.C",projectTitle,title));
cout <<"<img src=\"%ATTACHURLPATH%/"<<fname<<"\" alt=\""<<fname<<"\" width='671' height='478' />"<<endl;
}
void drawICmap(const string& wwwPath = "",
const string& eosPath = "",
const string& dirName = "",
const string& iterNumber = "",
const string& tagName = "") {
gStyle->SetPalette(1, 0); // raibow palette
gStyle->SetNumberContours(50); // default is 20
string filename = "root://eoscms//eos/cms" + eosPath + dirName + "/" + iterNumber + "/" + tagName + "calibMap.root";
TFile* f = TFile::Open(filename.c_str(),"READ");
if (!f || !f->IsOpen()) {
cout<<"*******************************"<<endl;
cout<<"Error opening file \""<<filename<<"\".\nApplication will be terminated."<<endl;
cout<<"*******************************"<<endl;
exit(EXIT_FAILURE);
}
TH2F *mapEB = (TH2F*) f->Get("calibMap_EB");
TH2F *h = NULL;
h = (TH2F*) f->Get("calibMap_EEp");
TH2F *mapEEp = (TH2F*) h->Clone();
h = (TH2F*) f->Get("calibMap_EEm");
TH2F *mapEEm = (TH2F*) h->Clone();
if (!mapEB || !mapEEp || !mapEEm) {
cout << "Error: could not get one or more histograms. End of programme" << endl;
exit(EXIT_FAILURE);
}
TH2F *mapEB_new = new TH2F("mapEB_new","EB calib coefficients", 360, 0.5, 360.5, 171,-85.5,85.5 );
// profile along ieta. ieta goea from -85 to 85, exluding 0, for a total of 170 non empty bins (they are 171 including ieta = 0 which is actually empty)
// in the profile, ieta = 30 is the bin with x from 29.5 to 30.5
// simila logic for profile along iphi
TProfile * EB_ieta_profile = new TProfile("EB_ieta_profile","EB calib coefficients - i#eta profile",171,-85.5,85.5);
TProfile * EB_iphi_profile = new TProfile("EB_iphi_profile","EB calib coefficients - i#phi profile",360,0.5,360.5);
Int_t nbinsX = mapEB->GetNbinsX(); // ieta
Int_t nbinsY = mapEB->GetNbinsY(); // iphi
for (Int_t i = 1; i <= nbinsX; i++) {
for (Int_t j = 1; j <= nbinsY; j++) {
mapEB_new->Fill(j,(i-86.0),mapEB->GetBinContent(i,j));
EB_ieta_profile->Fill((i-86.0),mapEB->GetBinContent(i,j));
EB_iphi_profile->Fill(j,mapEB->GetBinContent(i,j));
}
}
string wwwAllPath = wwwPath + dirName + "/" + iterNumber + "/2DMaps/";
string name = "";
TPaletteAxis *palette = NULL;
//EB
TCanvas *cEB = new TCanvas("cEB","IC map EB");
mapEB_new->Draw("COLZ");
mapEB_new->GetXaxis()->SetTitle("i #phi");
mapEB_new->GetXaxis()->SetTitleSize(0.06);
mapEB_new->GetXaxis()->SetTitleOffset(0.7);
mapEB_new->GetYaxis()->SetTitle("i #eta");
mapEB_new->GetYaxis()->SetTitleSize(0.06);
mapEB_new->GetYaxis()->SetTitleOffset(0.8);
mapEB_new->GetZaxis()->SetRangeUser(0.9,1.1);
mapEB_new->SetStats(0);
gPad->Update();
palette = (TPaletteAxis*)mapEB_new->GetListOfFunctions()->FindObject("palette");
// the following lines move the palette. Choose the values you need for the position.
palette->SetX1NDC(0.91);
palette->SetX2NDC(0.94);
gPad->Modified();
gPad->Update();
// end of palette fixes
name = wwwAllPath + "Barrel/IC_calibMapEB";
cEB->SaveAs((name + ".pdf").c_str());
cEB->SaveAs((name + ".png").c_str());
TCanvas *cEB_ietaProfile = new TCanvas("cEB_ietaProfile","IC map EB - i#eta profile");
EB_ieta_profile->Draw("HIST");
EB_ieta_profile->GetXaxis()->SetTitle("i #eta");
EB_ieta_profile->GetXaxis()->SetTitleSize(0.06);
EB_ieta_profile->GetXaxis()->SetTitleOffset(0.7);
EB_ieta_profile->GetYaxis()->SetTitle("IC");
EB_ieta_profile->GetYaxis()->SetTitleSize(0.06);
EB_ieta_profile->GetYaxis()->SetTitleOffset(0.8);
// Double_t maxY = EB_ieta_profile->GetBinContent(EB_ieta_profile->GetMaximumBin());
// Double_t scale_factor = 1.1;
// Double_t minY = 999.9; // minimum would be 0, corresponding to ieta = 0; look for minimum excluding ieta = 0
// for (Int_t ieta = -85; ieta<= 85; ieta++) {
// if (ieta == 0) continue;
// minY = (EB_ieta_profile->GetBinContent(ieta+86) < minY) ? EB_ieta_profile->GetBinContent(ieta+86) : minY;
// }
// Double_t offset = scale_factor * (maxY -minY);
// EB_ieta_profile->GetYaxis()->SetRangeUser(minY - offset, maxY + offset);
EB_ieta_profile->GetYaxis()->SetRangeUser(0.89,0.99);
EB_ieta_profile->SetStats(0);
gPad->Update();
name = wwwAllPath + "Barrel/IC_calibMapEB_ietaProfile";
cEB_ietaProfile->SaveAs((name + ".pdf").c_str());
cEB_ietaProfile->SaveAs((name + ".png").c_str());
TCanvas *cEB_iphiProfile = new TCanvas("cEB_iphiProfile","IC map EB - i#phi profile");
EB_iphi_profile->Draw("HIST");
EB_iphi_profile->GetXaxis()->SetTitle("i #phi");
EB_iphi_profile->GetXaxis()->SetTitleSize(0.06);
EB_iphi_profile->GetXaxis()->SetTitleOffset(0.7);
EB_iphi_profile->GetYaxis()->SetTitle("IC");
EB_iphi_profile->GetYaxis()->SetTitleSize(0.06);
EB_iphi_profile->GetYaxis()->SetTitleOffset(0.8);
// maxY = EB_iphi_profile->GetBinContent(EB_iphi_profile->GetMaximumBin());
// minY = EB_iphi_profile->GetBinContent(EB_iphi_profile->GetMinimumBin());
// offset = scale_factor * (maxY -minY);
// EB_iphi_profile->GetYaxis()->SetRangeUser(minY - offset, maxY + offset);
EB_iphi_profile->GetYaxis()->SetRangeUser(0.91,0.97);
EB_iphi_profile->SetStats(0);
gPad->Update();
name = wwwAllPath + "Barrel/IC_calibMapEB_iphiProfile";
cEB_iphiProfile->SaveAs((name + ".pdf").c_str());
cEB_iphiProfile->SaveAs((name + ".png").c_str());
//EE+
TCanvas *cEEp = new TCanvas("cEEp","IC map EE+");
mapEEp->Draw("COLZ");
mapEEp->GetXaxis()->SetTitle("iX");
mapEEp->GetXaxis()->SetTitleSize(0.06);
mapEEp->GetXaxis()->SetTitleOffset(0.7);
mapEEp->GetYaxis()->SetTitle("iY");
mapEEp->GetYaxis()->SetTitleSize(0.06);
mapEEp->GetYaxis()->SetTitleOffset(0.8);
mapEEp->GetZaxis()->SetRangeUser(0.75,1.25);
mapEEp->SetStats(0);
gPad->Update();
palette = (TPaletteAxis*)mapEEp->GetListOfFunctions()->FindObject("palette");
// the following lines move the palette. Choose the values you need for the position.
palette->SetX1NDC(0.91);
palette->SetX2NDC(0.94);
gPad->Modified();
gPad->Update();
// end of palette fixes
name = wwwAllPath + "Endcap/EEp/IC_calibMapEEp";
cEEp->SaveAs((name + ".pdf").c_str());
cEEp->SaveAs((name + ".png").c_str());
//EE-
TCanvas *cEEm = new TCanvas("cEEm","IC map EE-");
mapEEm->Draw("COLZ");
mapEEm->GetXaxis()->SetTitle("iX");
mapEEm->GetXaxis()->SetTitleSize(0.06);
mapEEm->GetXaxis()->SetTitleOffset(0.7);
mapEEm->GetYaxis()->SetTitle("iY");
mapEEm->GetYaxis()->SetTitleSize(0.06);
mapEEm->GetYaxis()->SetTitleOffset(0.8);
mapEEm->GetZaxis()->SetRangeUser(0.75,1.25);
mapEEm->SetStats(0);
gPad->Update();
palette = (TPaletteAxis*)mapEEm->GetListOfFunctions()->FindObject("palette");
// the following lines move the palette. Choose the values you need for the position.
palette->SetX1NDC(0.91);
palette->SetX2NDC(0.94);
gPad->Modified();
gPad->Update();
// end of palette fixes
name = wwwAllPath + "Endcap/EEm/IC_calibMapEEm";
cEEm->SaveAs((name + ".pdf").c_str());
cEEm->SaveAs((name + ".png").c_str());
}
void draw_2D_eff_fine(int MrapNpt=89, int isPA = 1, int accCutType =2, bool isPrompt = false, bool useZvtxWeight=false, bool useSF=false, TString szDir="dir_eff")
{
gROOT->Macro("../Style2D.C");
TString szBinning;
if (MrapNpt==89) {szBinning = "8rap9pt"; }
else if (MrapNpt==83) { szBinning = "8rap3pt"; }
else if (MrapNpt==63) { szBinning = "6rap3pt"; }
else if (MrapNpt==62) { szBinning = "6rap2pt"; }
else {cout << "select among MrapNpt = 89, 83, 63, or 62"<< endl; return; }
TString szPA;
if (isPA==0) szPA="pp";
else if (isPA==1) szPA="Pbp";
else if (isPA==2) szPA="pPb";
else {cout << "select among isPA = 0, 1, or 2 (pp, Pbp or pPb) "<< endl; return; }
TString szAccCut;
if (accCutType==1) szAccCut="oldcut";
else if (accCutType==2) szAccCut="newcut";
else {cout << "select among accCutType = 1 or 2"<< endl; return; }
TString szPrompt;
if (isPrompt) szPrompt = "PR";
else szPrompt = "NP";
const TString szFinal = Form("%s_%s_%s_%s",szBinning.Data(),szPA.Data(),szPrompt.Data(),szAccCut.Data());
std::cout << "szFinal: " << szFinal << std::endl;
TFile * f2D = new TFile(Form("EffAna_%s_Zvtx%d_SF%d.root",szFinal.Data(),(int)useZvtxWeight,(int)useSF));
// --- read-in 2D hist
TH2D* h2D_Den = (TH2D*)f2D->Get("h2D_Den_pt_y_fine");
TH2D* h2D_Num = (TH2D*)f2D->Get("h2D_Num_pt_y_fine");
TH2D* h2D_Eff = (TH2D*)f2D->Get("h2D_Eff_pt_y_fine");
//latex box for beam, rapidity, pT info
TLatex* latex = new TLatex();
latex->SetNDC();
latex->SetTextAlign(12);
latex->SetTextSize(0.04);
//////////////////////////////////////////////////////////////////
// --- Draw histograms
TCanvas* c1 = new TCanvas("c1","c1",700,600);
TPaletteAxis* pal;
c1->cd();
h2D_Den->GetXaxis()->SetTitle("y_{lab}");
h2D_Den->GetXaxis()->CenterTitle();
h2D_Den->GetYaxis()->SetTitle("p_{T} (GeV/c)");
h2D_Den->Draw("colz");
c1->Update();
pal = (TPaletteAxis*)h2D_Den->GetListOfFunctions()->FindObject("palette");
pal->SetX2NDC(0.92);
c1->Modified();
c1->Update();
c1->SaveAs(Form("%s/h2D_Den_%s_fine.pdf",szDir.Data(),szFinal.Data()));
h2D_Num->GetXaxis()->SetTitle("y_{lab}");
h2D_Num->GetXaxis()->CenterTitle();
h2D_Num->GetYaxis()->SetTitle("p_{T} (GeV/c)");
h2D_Num->Draw("colz");
c1->Update();
pal = (TPaletteAxis*)h2D_Num->GetListOfFunctions()->FindObject("palette");
pal->SetX2NDC(0.92);
c1->Modified();
c1->Update();
c1->SaveAs(Form("%s/h2D_Num_%s_fine.pdf",szDir.Data(),szFinal.Data()));
h2D_Eff->GetXaxis()->SetTitle("y_{lab}");
h2D_Eff->GetXaxis()->CenterTitle();
h2D_Eff->GetYaxis()->SetTitle("p_{T} (GeV/c)");
h2D_Eff->SetMaximum(1.);
h2D_Eff->Draw("colz");
c1->Update();
pal = (TPaletteAxis*)h2D_Eff->GetListOfFunctions()->FindObject("palette");
pal->SetX2NDC(0.92);
c1->Modified();
c1->Update();
c1->SaveAs(Form("%s/h2D_Eff_%s_fine.pdf",szDir.Data(),szFinal.Data()));
return;
}
void PlotChargeFieldFocus2D( const TString &sim, Int_t time, Int_t zoom=2, Int_t Nbins=2, const TString &options="") {
#ifdef __CINT__
gSystem->Load("libplasma.so");
#endif
PlasmaGlob::Initialize();
// Palettes!
gROOT->Macro("PlasmaPalettes.C");
// Init Units table
PUnits::UnitsTable::Get();
// Load PData
PData *pData = PData::Get(sim.Data());
pData->LoadFileNames(time);
if(!pData->IsInit()) return;
TString opt = options;
// More makeup
if(opt.Contains("grid")) {
gStyle->SetPadGridX(1);
gStyle->SetPadGridY(1);
}
gStyle->SetTitleFont(42);
gStyle->SetStatFont(42);
gStyle->SetTextFont(42);
gStyle->SetTitleFont(42,"xyz");
gStyle->SetLabelFont(42,"xyz");
// Some plasma constants
Double_t n0 = pData->GetPlasmaDensity();
Double_t kp = pData->GetPlasmaK();
Double_t skindepth = 1.;
if(kp!=0.0) skindepth = 1/kp;
Double_t E0 = pData->GetPlasmaE0();
// Some beam properties:
Float_t Ebeam = pData->GetBeamEnergy() * PUnits::MeV;
Float_t gamma = Ebeam / PConst::ElectronMassE;
Float_t vbeam = TMath::Sqrt(1 - 1/(gamma*gamma));
// cout << Form(" - Bunch gamma = %8.4f", gamma ) << endl;
// cout << Form(" - Bunch velocity = %8.4f c", vbeam ) << endl;
Float_t nb = pData->GetBeamDensity();
// 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;
// z start of the neutral in normalized units.
Float_t zStartNeutral = pData->GetNeutralStart()*kp;
// z end of the neutral in normalized units.
Float_t zEndNeutral = pData->GetNeutralEnd()*kp;
if(opt.Contains("center")) {
Time -= zStartPlasma;
if(opt.Contains("comov")) // Centers on the head of the beam.
Time += zStartBeam;
}
Float_t shiftz = pData->Shift(opt);
// cout << "Shift = " << shiftz << endl;
// Calculate the "axis range" in number of bins. If Nbins==0 a RMS width is taken.
Double_t rms0 = pData->GetBeamRmsY() * kp;
if(pData->IsCyl()) rms0 = pData->GetBeamRmsR() * kp;
Int_t FirstyBin = 0;
Int_t LastyBin = 0;
if(Nbins==0) {
Nbins = TMath::Nint(rms0 / pData->GetDX(1));
}
// Slice width limits.
if(!pData->IsCyl()) {
FirstyBin = pData->GetNX(1)/2 + 1 - Nbins;
LastyBin = pData->GetNX(1)/2 + Nbins;
} else {
FirstyBin = 1;
LastyBin = Nbins;
}
// -------------------------------------------------------------------------------
// Get charge density histos
Int_t Nspecies = pData->NSpecies();
TH2F **hDen2D = new TH2F*[Nspecies];
TH1F **hDen1D = new TH1F*[Nspecies];
for(Int_t i=0;i<Nspecies;i++) {
hDen2D[i] = NULL;
hDen1D[i] = NULL;
if(!pData->GetChargeFileName(i))
continue;
cout << Form(" Getting charge density of specie: ") << i << endl;
char hName[24];
sprintf(hName,"hDen2D_%i",i);
hDen2D[i] = (TH2F*) gROOT->FindObject(hName);
if(hDen2D[i]) delete hDen2D[i];
if(!pData->Is3D())
hDen2D[i] = pData->GetCharge(i,opt);
else
hDen2D[i] = pData->GetCharge2DSliceZY(i,-1,Nbins,opt+"avg");
// cout << Form(" Charge density of specie '%s' loaded into histogram '%s'",pData->GetSpeciesName(i).c_str(),hName) << endl;
hDen2D[i]->SetName(hName);
hDen2D[i]->GetXaxis()->CenterTitle();
hDen2D[i]->GetYaxis()->CenterTitle();
hDen2D[i]->GetZaxis()->CenterTitle();
if(opt.Contains("comov"))
hDen2D[i]->GetXaxis()->SetTitle("#zeta [c/#omega_{p}]");
else
hDen2D[i]->GetXaxis()->SetTitle("z [c/#omega_{p}]");
if(pData->IsCyl())
hDen2D[i]->GetYaxis()->SetTitle("r [c/#omega_{p}]");
else
hDen2D[i]->GetYaxis()->SetTitle("y [c/#omega_{p}]");
hDen2D[i]->GetZaxis()->SetTitle("n [n_{0}]");
if(!opt.Contains("1dline")) continue;
sprintf(hName,"hDen1D_%i",i);
hDen1D[i] = (TH1F*) gROOT->FindObject(hName);
if(hDen1D[i]) delete hDen1D[i];
if(pData->Is3D()) {
hDen1D[i] = pData->GetH1SliceZ3D(pData->GetChargeFileName(i)->c_str(),"charge",-1,Nbins,-1,Nbins,opt+"avg");
} else if(pData->IsCyl()) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0).
hDen1D[i] = pData->GetH1SliceZ(pData->GetChargeFileName(i)->c_str(),"charge",1,Nbins,opt+"avg");
} else { // 2D cartesian
hDen1D[i] = pData->GetH1SliceZ(pData->GetChargeFileName(i)->c_str(),"charge",-1,Nbins,opt+"avg");
}
// cout << Form(" Charge density of specie '%s' loaded into histogram '%s'",pData->GetSpeciesName(i).c_str(),hName) << endl;
hDen1D[i]->SetName(hName);
hDen1D[i]->GetXaxis()->CenterTitle();
hDen1D[i]->GetYaxis()->CenterTitle();
if(opt.Contains("comov"))
hDen1D[i]->GetXaxis()->SetTitle("#zeta [c/#omega_{p}]");
else
hDen1D[i]->GetXaxis()->SetTitle("z [c/#omega_{p}]");
hDen1D[i]->GetYaxis()->SetTitle("n [n_{0}]");
}
// Get electric fields
const Int_t Nfields = 3;
TH2F **hE2D = new TH2F*[Nfields];
TH1F **hE1D = new TH1F*[Nfields];
for(Int_t i=0;i<Nfields;i++) {
hE2D[i] = NULL;
hE1D[i] = NULL;
if(!pData->GetEfieldFileName(i))
continue;
cout << Form(" Getting electric field number ") << i+1 << endl;
char hName[24];
sprintf(hName,"hE2D_%i",i);
hE2D[i] = (TH2F*) gROOT->FindObject(hName);
if(hE2D[i]) delete hE2D[i];
if(!pData->Is3D())
hE2D[i] = pData->GetEField(i,opt);
else
hE2D[i] = pData->GetEField2DSliceZY(i,-1,Nbins,opt+"avg");
hE2D[i]->SetName(hName);
hE2D[i]->GetXaxis()->CenterTitle();
hE2D[i]->GetYaxis()->CenterTitle();
hE2D[i]->GetZaxis()->CenterTitle();
if(opt.Contains("comov"))
hE2D[i]->GetXaxis()->SetTitle("#zeta [c/#omega_{p}]");
else
hE2D[i]->GetXaxis()->SetTitle("z [c/#omega_{p}]");
if(pData->IsCyl())
hE2D[i]->GetYaxis()->SetTitle("r [c/#omega_{p}]");
else
hE2D[i]->GetYaxis()->SetTitle("y [c/#omega_{p}]");
if(i==0)
hE2D[i]->GetZaxis()->SetTitle("E_{z} [E_{0}]");
else if(i==1)
hE2D[i]->GetZaxis()->SetTitle("E_{y} [E_{0}]");
else if(i==2)
hE2D[i]->GetZaxis()->SetTitle("E_{x} [E_{0}]");
if(!opt.Contains("1dline")) continue;
sprintf(hName,"hE1D_%i",i);
hE1D[i] = (TH1F*) gROOT->FindObject(hName);
if(hE1D[i]) delete hE1D[i];
// 1D histograms
char nam[3]; sprintf(nam,"e%i",i+1);
if(pData->Is3D()) {
if(i==0)
hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,-1,Nbins,opt+"avg");
else
hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,-Nbins,Nbins,opt+"avg");
} else if(pData->IsCyl()) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0).
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,1,Nbins,opt+"avg");
} else { // 2D cartesian
if(i==0)
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,opt+"avg");
else
hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,opt+"avg");
}
hE1D[i]->SetName(hName);
if(opt.Contains("comov"))
hE1D[i]->GetXaxis()->SetTitle("#zeta [c/#omega_{p}]");
else
hE1D[i]->GetXaxis()->SetTitle("z [c/#omega_{p}]");
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}]");
}
// Now, combine the electric field components into the total |E|
// and calculate ionization probability for He:
// Outter Helium electron
Double_t Eion0 = 24.59 * PUnits::eV;
Double_t Z = 1;
Double_t l = 0;
Double_t m = 0;
TH1F *hIonProb1D = NULL;
if(opt.Contains("ionprob")) {
hIonProb1D = (TH1F*) hE1D[0]->Clone("hIonProb1D");
hIonProb1D->Reset();
Int_t NbinsX = hE1D[0]->GetNbinsX();
for(Int_t j=1;j<=NbinsX;j++) {
Double_t E1 = hE1D[0]->GetBinContent(j);
Double_t E2 = hE1D[1]->GetBinContent(j);
Double_t E3 = hE1D[2]->GetBinContent(j);
Double_t E = TMath::Sqrt(E1*E1+E2*E2+E3*E3);
E *= E0;
Double_t IonProb = (PFunc::ADK(E,Eion0,Z,l,m)/PUnits::atomictime)*PUnits::femtosecond;
hIonProb1D->SetBinContent(j,IonProb);
}
hIonProb1D->GetYaxis()->SetTitle("W_{ADK} [fs^{-1}]");
}
// Tunning the Histograms
// ---------------------
// Chaning to user units:
// --------------------------
if(opt.Contains("units") && n0) {
for(Int_t i=0;i<Nspecies;i++) {
if(!hDen2D[i]) continue;
Int_t NbinsX = hDen2D[i]->GetNbinsX();
Float_t xMin = skindepth * hDen2D[i]->GetXaxis()->GetXmin() / PUnits::um;
Float_t xMax = skindepth * hDen2D[i]->GetXaxis()->GetXmax() / PUnits::um;
Int_t NbinsY = hDen2D[i]->GetNbinsY();
Float_t yMin = skindepth * hDen2D[i]->GetYaxis()->GetXmin() / PUnits::um;
Float_t yMax = skindepth * hDen2D[i]->GetYaxis()->GetXmax() / PUnits::um;
hDen2D[i]->SetBins(NbinsX,xMin,xMax,NbinsY,yMin,yMax);
// for(Int_t j=0;j<hDen2D[i]->GetNbinsX();j++) {
// for(Int_t k=0;k<hDen2D[i]->GetNbinsY();k++) {
// hDen2D[i]->SetBinContent(j,k, hDen2D[i]->GetBinContent(j,k) * n0 / (1e15/PUnits::cm3) );
// }
// }
if(pData->IsCyl())
hDen2D[i]->GetYaxis()->SetTitle("r [#mum]");
else
hDen2D[i]->GetYaxis()->SetTitle("y [#mum]");
if(opt.Contains("comov"))
hDen2D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hDen2D[i]->GetXaxis()->SetTitle("z [#mum]");
// hDen2D[i]->GetZaxis()->SetTitle("n [10^{15}/cm^{3}]");
if(!hDen1D[i]) continue;
hDen1D[i]->SetBins(NbinsX,xMin,xMax);
if(opt.Contains("comov"))
hDen1D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hDen1D[i]->GetXaxis()->SetTitle("z [#mum]");
}
for(Int_t i=0;i<Nfields;i++) {
Int_t NbinsX = hE2D[i]->GetNbinsX();
Float_t xMin = skindepth * hE2D[i]->GetXaxis()->GetXmin() / PUnits::um;
Float_t xMax = skindepth * hE2D[i]->GetXaxis()->GetXmax() / PUnits::um;
Int_t NbinsY = hE2D[i]->GetNbinsY();
Float_t yMin = skindepth * hE2D[i]->GetYaxis()->GetXmin() / PUnits::um;
Float_t yMax = skindepth * hE2D[i]->GetYaxis()->GetXmax() / PUnits::um;
hE2D[i]->SetBins(NbinsX,xMin,xMax,NbinsY,yMin,yMax);
if(hE1D[i])
hE1D[i]->SetBins(NbinsX,xMin,xMax);
for(Int_t j=0;j<hE2D[i]->GetNbinsX();j++) {
for(Int_t k=0;k<hE2D[i]->GetNbinsY();k++) {
hE2D[i]->SetBinContent(j,k, hE2D[i]->GetBinContent(j,k) * ( E0 / (PUnits::GV/PUnits::m) ) );
}
if(!hE1D[i]) continue;
hE1D[i]->SetBinContent(j, hE1D[i]->GetBinContent(j) * ( E0 / (PUnits::GV) ) );
}
if(pData->IsCyl())
hE2D[i]->GetYaxis()->SetTitle("r [#mum]");
else
hE2D[i]->GetYaxis()->SetTitle("y [#mum]");
if(opt.Contains("comov"))
hE2D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hE2D[i]->GetXaxis()->SetTitle("z [#mum]");
if(i==0)
hE2D[i]->GetZaxis()->SetTitle("E_{z} [GV/m]");
else if(i==1)
hE2D[i]->GetZaxis()->SetTitle("E_{y} [GV/m]");
else if(i==2)
hE2D[i]->GetZaxis()->SetTitle("E_{x} [GV/m]");
if(!hE1D[i]) continue;
if(opt.Contains("comov"))
hE1D[i]->GetXaxis()->SetTitle("#zeta [mm]");
else
hE1D[i]->GetXaxis()->SetTitle("z [mm]");
if(i==0)
hE1D[i]->GetYaxis()->SetTitle("E_{z} [GV/m]");
else if(i==1)
hE1D[i]->GetYaxis()->SetTitle("E_{y} [GV/m]");
else if(i==2)
hE1D[i]->GetYaxis()->SetTitle("E_{x} [GV/m]");
}
if(hIonProb1D) {
Int_t NbinsX = hIonProb1D->GetNbinsX();
Float_t xMin = skindepth * hIonProb1D->GetXaxis()->GetXmin() / PUnits::um;
Float_t xMax = skindepth * hIonProb1D->GetXaxis()->GetXmax() / PUnits::um;
hIonProb1D->SetBins(NbinsX,xMin,xMax);
}
}
// --------------------------------------------------- Vertical Zoom ------------
Float_t range = (hDen2D[0]->GetYaxis()->GetXmax() - hDen2D[0]->GetYaxis()->GetXmin())/zoom;
Float_t midPoint = (hDen2D[0]->GetYaxis()->GetXmax() + hDen2D[0]->GetYaxis()->GetXmin())/2.;
Double_t ymin = midPoint-range/2;
Double_t ymax = midPoint+range/2;
if(pData->IsCyl()) {
ymin = hDen2D[0]->GetYaxis()->GetXmin();
ymax = range;
}
hDen2D[0]->GetYaxis()->SetRangeUser(ymin,ymax);
hE2D[0]->GetYaxis()->SetRangeUser(ymin,ymax);
hE2D[1]->GetYaxis()->SetRangeUser(ymin,ymax);
// ------------- z Zoom --------------------------------- Plasma palette -----------
// Set the range of the plasma charge density histogram for maximum constrast
// using a dynamic palette wich adjust the nominal value to a certain color.
Float_t density = 1;
// if(opt.Contains("units") && n0)
// density = n0 / (1e17/PUnits::cm3);
Float_t Base = density;
Float_t BaseB = TMath::Nint(100*(nb/n0))/100.0;
Float_t gMax = hDen2D[0]->GetMaximum();
Float_t gMin = (0.1001) * Base;
if(BaseB<Base) gMin = (0.1001) * BaseB;
if(gMax<Base) gMax = 1.1*Base;
Float_t *Max = new Float_t[Nspecies];
Float_t *Min = new Float_t[Nspecies];
for(Int_t i=0;i<Nspecies;i++) {
if(!hDen2D[i]) continue;
Max[i] = hDen2D[i]->GetMaximum();
Min[i] = 0.01*Max[i];
// if(i==1) = Min[i] = 1.001E-4;
if(i==2) Min[i] = 1.001E-3;
if(Max[i]>gMax) gMax = Max[i];
hDen2D[i]->GetZaxis()->SetRangeUser(Min[i],Max[i]);
}
hDen2D[0]->GetZaxis()->SetRangeUser(gMin,gMax);
// if(hDen2D[1]) {
// hDen2D[1]->GetZaxis()->SetRangeUser(gMin,Max[1]);
// }
// if(Nspecies>=3) {
// if(hDen2D[2]) {
// hDen2D[2]->GetZaxis()->SetRangeUser(gMin,Max[2]);
// }
// }
// Dynamic plasma palette
const Int_t plasmaDNRGBs = 3;
const Int_t plasmaDNCont = 128;
Double_t basePos = 0.5;
if(gMax!=gMin) {
if(opt.Contains("logz")) {
Float_t a = 1.0/(TMath::Log10(gMax)-TMath::Log10(gMin));
Float_t b = TMath::Log10(gMin);
basePos = a*(TMath::Log10(Base) - b);
} else {
basePos = (1.0/(gMax-gMin))*(Base - gMin);
}
}
Double_t plasmaDStops[plasmaDNRGBs] = { 0.00, basePos, 1.00 };
Double_t plasmaDRed[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
Double_t plasmaDGreen[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
Double_t plasmaDBlue[plasmaDNRGBs] = { 0.99, 0.90, 0.00 };
PPalette * plasmaPalette = (PPalette*) gROOT->FindObject("plasma");
plasmaPalette->CreateGradientColorTable(plasmaDNRGBs, plasmaDStops,
plasmaDRed, plasmaDGreen, plasmaDBlue, plasmaDNCont);
// Change the range of z axis for the fields to be symmetric.
Float_t Emax = hE2D[0]->GetMaximum();
Float_t Emin = hE2D[0]->GetMinimum();
if(Emax > TMath::Abs(Emin))
Emin = -Emax;
else
Emax = -Emin;
hE2D[0]->GetZaxis()->SetRangeUser(Emin,Emax);
Emax = hE2D[1]->GetMaximum();
Emin = hE2D[1]->GetMinimum();
if(Emax > TMath::Abs(Emin))
Emin = -Emax;
else
Emax = -Emin;
hE2D[1]->GetZaxis()->SetRangeUser(Emin,Emax);
// "Axis range" in Osiris units:
Double_t ylow = hDen2D[1]->GetYaxis()->GetBinLowEdge(FirstyBin);
Double_t yup = hDen2D[1]->GetYaxis()->GetBinUpEdge(LastyBin);
Double_t xmin = hDen2D[1]->GetXaxis()->GetXmin();
Double_t xmax = hDen2D[1]->GetXaxis()->GetXmax();
TLine *lineYzero = new TLine(xmin,0.0,xmax,0.0);
lineYzero->SetLineColor(kGray+2);
lineYzero->SetLineStyle(2);
TLine *lineYup = new TLine(xmin,yup,xmax,yup);
lineYup->SetLineColor(kGray+1);
lineYup->SetLineStyle(2);
TLine *lineYdown = new TLine(xmin,ylow,xmax,ylow);
lineYdown->SetLineColor(kGray+1);
lineYdown->SetLineStyle(2);
zStartPlasma -= shiftz;
zStartNeutral -= shiftz;
zEndNeutral -= shiftz;
if(opt.Contains("units")) {
zStartPlasma *= skindepth / PUnits::um;
zStartNeutral *= skindepth / PUnits::um;
zEndNeutral *= skindepth / PUnits::um;
}
// cout << "Start plasma = " << zStartPlasma << endl;
TLine *lineStartPlasma = new TLine(zStartPlasma,ymin,zStartPlasma,ymax);
lineStartPlasma->SetLineColor(kRed);
lineStartPlasma->SetLineStyle(1);
lineStartPlasma->SetLineWidth(2);
// cout << "Start plasma = " << zStartNeutral << endl;
TLine *lineStartNeutral = new TLine(zStartNeutral,ymin,zStartNeutral,ymax);
lineStartNeutral->SetLineColor(kGray+1);
lineStartNeutral->SetLineStyle(1);
lineStartNeutral->SetLineWidth(2);
// cout << "End plasma = " << zEndNeutral << endl;
TLine *lineEndNeutral = new TLine(zEndNeutral,ymin,zEndNeutral,ymax);
lineEndNeutral->SetLineColor(kGray+1);
lineEndNeutral->SetLineStyle(2);
lineEndNeutral->SetLineWidth(2);
// Plotting
// -----------------------------------------------
// Canvas setup
TCanvas *C;
if(opt.Contains("hres") && !opt.Contains("pdf")) // high resolution for plain grahics output.
C = new TCanvas("C","2D Charge density, Accelerating and focusing fields",1500,2000);
else
C = new TCanvas("C","2D Charge density, Accelerating and focusing fields",750,1000);
// Palettes setup
TExec *exPlasma = new TExec("exPlasma","plasmaPalette->cd();");
TExec *exHot = new TExec("exHot","hotPalette->cd();");
TExec *exElec = new TExec("exElec","electronPalette->cd();");
TExec *exField = new TExec("exField","rbow2Palette->cd();");
// Text objects
TPaveText *textTime = new TPaveText(0.7,0.83,0.85,0.90,"NDC");
PlasmaGlob::SetPaveTextStyle(textTime,32);
char ctext[128];
if(opt.Contains("units") && n0)
sprintf(ctext,"z = %5.1f #mum", Time * skindepth / PUnits::um);
else
sprintf(ctext,"t = %5.1f #omega_{p}^{-1}",Time);
textTime->AddText(ctext);
TPaveText *textDen = new TPaveText(0.13,0.83,0.38,0.90,"NDC");
PlasmaGlob::SetPaveTextStyle(textDen,12);
textDen->SetTextColor(kOrange+10);
if(opt.Contains("units") && n0)
sprintf(ctext,"n_{0} = %5.2f x 10^{15} / cm^{3}", 1e-15 * n0 * PUnits::cm3);
else if(pData->GetBeamDensity() && n0)
sprintf(ctext,"n_{b}/n_{0} = %5.2f", pData->GetBeamDensity()/n0);
textDen->AddText(ctext);
TPaveText *textWav = new TPaveText(0.13,0.75,0.38,0.82,"NDC");
PlasmaGlob::SetPaveTextStyle(textWav,12);
textWav->SetTextColor(kGray+2);
sprintf(ctext,"#lambda_{p} = %5.3f mm", skindepth * TMath::TwoPi() / PUnits::um);
textWav->AddText(ctext);
// Actual Plotting!
// ------------------------------------------------------------
// Output file
TString fOutName = Form("./%s/Plots/ChargeFieldFocus2D/ChargeFieldFocus2D",pData->GetPath().c_str());
fOutName += Form("-%s_%i",pData->GetName(),time);
// Setup Pad layout:
Double_t lMargin = 0.10;
Double_t rMargin = 0.12;
Double_t bMargin = 0.10;
Double_t tMargin = 0.02;
Double_t vSpacing = 0.01;
Double_t hStep = (1.-lMargin-rMargin);
Double_t vStep = (1.-bMargin-tMargin)/3.;
TPad *pad[3];
// top plots
pad[0] = new TPad("padt", "padt",0.00, bMargin + 2.*vStep + vSpacing,
lMargin+hStep+rMargin, 1.00);
pad[0]->SetLeftMargin(1./(lMargin+hStep)*lMargin);
pad[0]->SetRightMargin(1./(rMargin+hStep)*rMargin);
pad[0]->SetBottomMargin(0.0);
pad[0]->SetTopMargin(1./(tMargin+vStep)*tMargin);
pad[0]->Draw();
// middle plots
pad[1] = new TPad("padm", "padm",0.00, bMargin + vStep + vSpacing,
lMargin + hStep + rMargin, bMargin + 2.*vStep );
pad[1]->SetLeftMargin(1./(lMargin+hStep)*lMargin);
pad[1]->SetRightMargin((1./(rMargin+hStep)*rMargin));
pad[1]->SetBottomMargin(0.0);
pad[1]->SetTopMargin(0.);
pad[1]->Draw();
// bottom plots
pad[2] = new TPad("padb", "padb",0.00, 0.,lMargin+hStep+rMargin,bMargin+vStep);
pad[2]->SetLeftMargin(1./(lMargin+hStep)*lMargin);
pad[2]->SetRightMargin((1./(rMargin+hStep)*rMargin));
pad[2]->SetBottomMargin(1./(bMargin+vStep)*bMargin);
pad[2]->SetTopMargin(0.);
pad[2]->Draw();
// Draw!
pad[0]->cd(); // <---------------------------------------------- Top Plot ---------
if(opt.Contains("logz")) {
pad[0]->SetLogz(1);
} else {
pad[0]->SetLogz(0);
}
pad[0]->SetFrameLineWidth(3);
TH2F *hFrame = (TH2F*) gROOT->FindObject("hFrame1");
if(hFrame) delete hFrame;
hFrame = (TH2F*) hDen2D[0]->Clone("hFrame1");
hFrame->Reset();
hFrame->GetXaxis()->SetLabelOffset(999);
hFrame->GetYaxis()->SetTitleSize(0.075);
hFrame->GetYaxis()->SetTitleOffset(0.65);
hFrame->GetYaxis()->SetLabelSize(0.065);
hFrame->GetYaxis()->SetLabelOffset(0.02);
hFrame->GetYaxis()->SetTickLength(0.02);
hFrame->GetZaxis()->SetTitleSize(0.06);
hFrame->GetZaxis()->SetTitleOffset(0.45);
hFrame->GetZaxis()->SetLabelSize(0.06);
hFrame->GetZaxis()->SetTickLength(0.02);
// hFrame->GetZaxis()->SetNdivisions(505);
hFrame->Draw("col");
if(Nspecies>=3) {
if(hDen2D[2]) {
exHot->Draw();
hDen2D[2]->Draw("colz same");
}
}
exPlasma->Draw();
hDen2D[0]->Draw("colz same");
if(hDen2D[1]) {
exElec->Draw();
hDen2D[1]->Draw("colz same");
}
if(opt.Contains("1dline")) {
lineYzero->Draw();
lineYdown->Draw();
lineYup->Draw();
}
if(zStartPlasma>xmin && zStartPlasma<xmax)
lineStartPlasma->Draw();
if(zStartNeutral>xmin && zStartNeutral<xmax)
lineStartNeutral->Draw();
if(zEndNeutral>xmin && zEndNeutral<xmax)
lineEndNeutral->Draw();
pad[0]->Update();
TPaletteAxis *palette = NULL;
for(Int_t i=0;i<Nspecies;i++) {
if(!hDen2D[i]) continue;
palette = (TPaletteAxis*) hDen2D[i]->GetListOfFunctions()->FindObject("palette");
if(!palette) continue;
Float_t y1 = gPad->GetBottomMargin();
Float_t y2 = 1 - gPad->GetTopMargin();
Float_t x1 = gPad->GetLeftMargin();
Float_t x2 = 1 - gPad->GetRightMargin();
palette->SetY2NDC( (i+1)*(y2-y1)/Nspecies + y1);
palette->SetY1NDC( i*(y2-y1)/Nspecies + y1);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(0.65);
palette->SetTitleSize(0.07);
palette->SetLabelSize(0.065);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
// 1D charge density plots:
Float_t yaxismin = pad[0]->GetUymin();
Float_t yaxismax = pad[0]->GetUymin() + 0.33*(pad[0]->GetUymax() - pad[0]->GetUymin()) - 0.00;
// Float_t denmin = (0.1001) * density;
Float_t denmin = gMin;
Float_t denmax = gMax;
if(opt.Contains("logz")) {
denmin = TMath::Log10(denmin);
denmax = TMath::Log10(denmax);
}
for(Int_t i=0;i<Nspecies;i++) {
if(!hDen1D[i]) continue;
Float_t slope = (yaxismax - yaxismin)/(denmax - denmin);
for(Int_t j=0;j<hDen1D[i]->GetNbinsX();j++) {
Float_t content = hDen1D[i]->GetBinContent(j+1);
if(opt.Contains("logz")) content = TMath::Log10(content);
if(content<denmin)
hDen1D[i]->SetBinContent(j+1,yaxismin);
else
hDen1D[i]->SetBinContent(j+1,(content - denmin) * slope + yaxismin);
}
hDen1D[i]->SetLineWidth(2);
if(i==1) {
hDen1D[i]->SetLineColor(PlasmaGlob::elecLine);
hDen1D[i]->Draw("same C");
} else if (i==2) {
hDen1D[i]->SetLineColor(kOrange+8);
hDen1D[i]->Draw("same C");
}
}
textTime->Draw();
// textDen->Draw();
// textWav->Draw();
pad[0]->RedrawAxis();
pad[1]->cd(); // <--------------------------------------------- Mid Plot
pad[1]->SetFrameLineWidth(3);
TH2F *hFrame2 = (TH2F*) gROOT->FindObject("hFrame2");
if(hFrame2) delete hFrame2;
hFrame2 = (TH2F*) hE2D[0]->Clone("hFrame2");
hFrame2->Reset();
Float_t yFactor = pad[0]->GetAbsHNDC()/pad[1]->GetAbsHNDC();
hFrame2->GetXaxis()->SetLabelOffset(999);
hFrame2->GetYaxis()->SetTitleSize(0.075*yFactor);
hFrame2->GetYaxis()->SetTitleOffset(0.65/yFactor);
hFrame2->GetYaxis()->SetLabelSize(0.0650*yFactor);
hFrame2->GetYaxis()->SetLabelOffset(0.02/yFactor);
hFrame2->GetYaxis()->SetTickLength(0.02/yFactor);
hE2D[0]->GetZaxis()->SetTitleSize(0.06*yFactor);
hE2D[0]->GetZaxis()->SetTitleOffset(0.45/yFactor);
hE2D[0]->GetZaxis()->SetLabelSize(0.06*yFactor);
hE2D[0]->GetZaxis()->SetTickLength(0.02/yFactor);
// hFrame2->GetZaxis()->SetNdivisions(505);
hFrame2->Draw("col");
exField->Draw();
hE2D[0]->Draw("colz same");
if(opt.Contains("1dline")) {
lineYzero->Draw();
lineYdown->Draw();
lineYup->Draw();
}
if(zStartPlasma>xmin && zStartPlasma<xmax)
lineStartPlasma->Draw();
if(zStartNeutral>xmin && zStartNeutral<xmax)
lineStartNeutral->Draw();
if(zEndNeutral>xmin && zEndNeutral<xmax)
lineEndNeutral->Draw();
pad[1]->Update();
palette = (TPaletteAxis*) hE2D[0]->GetListOfFunctions()->FindObject("palette");
Float_t y1 = pad[1]->GetBottomMargin();
Float_t y2 = 1 - pad[1]->GetTopMargin();
Float_t x2 = 1 - pad[1]->GetRightMargin();
palette->SetY2NDC(y2 - 0.01);
palette->SetY1NDC(y1 + 0.01);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleSize(0.07*yFactor);
palette->SetTitleOffset(0.65/yFactor);
palette->SetLabelSize(0.065*yFactor);
palette->SetBorderSize(2);
palette->SetLineColor(1);
// 1D electric field plots:
if(hE1D[0]) {
// yaxismin = pad[1]->GetUymin() + 0.16666*(pad[1]->GetUymax() - pad[1]->GetUymin());
// yaxismax = pad[1]->GetUymax() - 0.16666*(pad[1]->GetUymax() - pad[1]->GetUymin());
Float_t yaxismin = pad[1]->GetUymin();
Float_t yaxismax = pad[1]->GetUymax();
Float_t emin = hE1D[0]->GetMinimum();
Float_t emax = hE1D[0]->GetMaximum();
//Float_t slope = (yaxismax - yaxismin)/(emax - emin);
Float_t slope = yaxismin/emin;
for(Int_t j=0;j<hE1D[0]->GetNbinsX();j++) {
Float_t content = hE1D[0]->GetBinContent(j+1);
hE1D[0]->SetBinContent(j+1,(content - emin) * slope + yaxismin);
}
hE1D[0]->SetLineWidth(2);
hE1D[0]->SetLineColor(PlasmaGlob::elecLine);
// hE1D[0]->SetLineColor(kGray+2);
hE1D[0]->Draw("same C");
}
// Plot ionization probability:
if(hIonProb1D) {
Float_t ionmin = 0;
Float_t ionmax = hIonProb1D->GetMaximum();
Float_t slope = yaxismax/ionmax;
for(Int_t j=0;j<hIonProb1D->GetNbinsX();j++) {
Float_t content = hIonProb1D->GetBinContent(j+1);
hIonProb1D->SetBinContent(j+1,content * slope);
}
hIonProb1D->SetLineWidth(2);
hIonProb1D->SetLineColor(kGray+2);
hIonProb1D->Draw("same C");
}
pad[1]->RedrawAxis();
pad[2]->cd(); // <--------------------------------------------- Bottom Plot
pad[2]->SetFrameLineWidth(3);
TH2F *hFrame3 = (TH2F*) gROOT->FindObject("hFrame3");
if(hFrame3) delete hFrame3;
hFrame3 = (TH2F*) hE2D[1]->Clone("hFrame3");
hFrame3->Reset();
yFactor = pad[0]->GetAbsHNDC()/pad[2]->GetAbsHNDC();
hFrame3->GetXaxis()->SetTitleSize(0.075);
hFrame3->GetXaxis()->SetLabelSize(0.070);
hFrame3->GetYaxis()->SetTitleSize(0.075*yFactor);
hFrame3->GetYaxis()->SetTitleOffset(0.65/yFactor);
hFrame3->GetYaxis()->SetLabelSize(0.0650*yFactor);
hFrame3->GetYaxis()->SetLabelOffset(0.02/yFactor);
hFrame3->GetYaxis()->SetTickLength(0.02/yFactor);
hE2D[1]->GetZaxis()->SetTitleSize(0.06*yFactor);
hE2D[1]->GetZaxis()->SetTitleOffset(0.45/yFactor);
hE2D[1]->GetZaxis()->SetLabelSize(0.06*yFactor);
hE2D[1]->GetZaxis()->SetTickLength(0.02/yFactor);
// hE2D[1]->GetZaxis()->SetNdivisions(505);
hFrame3->Draw("col");
exField->Draw();
hE2D[1]->Draw("colz same");
if(opt.Contains("1dline")) {
lineYzero->Draw();
lineYup->Draw();
}
if(zStartPlasma>xmin && zStartPlasma<xmax)
lineStartPlasma->Draw();
if(zStartNeutral>xmin && zStartNeutral<xmax)
lineStartNeutral->Draw();
if(zEndNeutral>xmin && zEndNeutral<xmax)
lineEndNeutral->Draw();
pad[2]->Update();
palette = (TPaletteAxis*)hE2D[1]->GetListOfFunctions()->FindObject("palette");
y1 = pad[2]->GetBottomMargin();
y2 = 1 - pad[2]->GetTopMargin();
x2 = 1 - pad[2]->GetRightMargin();
palette->SetY2NDC(y2 - 0.01);
palette->SetY1NDC(y1 + 0.01);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleSize(0.07*yFactor);
palette->SetTitleOffset(0.65/yFactor);
palette->SetLabelSize(0.065*yFactor);
palette->SetBorderSize(2);
palette->SetLineColor(1);
// 1D electric field plots:
if(hE1D[1]) {
// yaxismin = pad[2]->GetUymin() + 0.16666*(pad[2]->GetUymax() - pad[2]->GetUymin());
// yaxismax = pad[2]->GetUymax() - 0.16666*(pad[2]->GetUymax() - pad[2]->GetUymin());
Float_t yaxismin = pad[2]->GetUymin();
Float_t yaxismax = pad[2]->GetUymax();
Float_t emin = hE1D[1]->GetMinimum();
Float_t emax = hE1D[1]->GetMaximum();
Float_t slope = yaxismin/emin;
for(Int_t j=0;j<hE1D[1]->GetNbinsX();j++) {
Float_t content = hE1D[1]->GetBinContent(j+1);
hE1D[1]->SetBinContent(j+1,(content - emin) * slope + yaxismin);
}
hE1D[1]->SetLineWidth(2);
//hE1D[1]->SetLineStyle(2);
// hE1D[1]->SetLineColor(kGray+2);
hE1D[1]->SetLineColor(PlasmaGlob::elecLine);
hE1D[1]->Draw("same C");
}
// Plot ionization probability:
if(hIonProb1D) {
Float_t ionmin = 0;
Float_t ionmax = hIonProb1D->GetMaximum();
Float_t slope = yaxismax/ionmax;
for(Int_t j=0;j<hIonProb1D->GetNbinsX();j++) {
Float_t content = hIonProb1D->GetBinContent(j+1);
hIonProb1D->SetBinContent(j+1,content * slope);
}
hIonProb1D->SetLineWidth(2);
hIonProb1D->SetLineColor(kGray+2);
hIonProb1D->Draw("same C");
}
pad[2]->RedrawAxis();
C->cd();
// Print to a file
PlasmaGlob::imgconv(C,fOutName,opt);
// ---------------------------------------------------------
}
void MakeBioluminescencePlots(){
gStyle->SetOptStat(0);
gStyle->SetCanvasColor(0);
gStyle->SetPadColor(0);
gStyle->SetPadBorderMode(0);
gStyle->SetCanvasBorderMode(0);
gStyle->SetFrameBorderMode(0);
gStyle->SetLabelSize(0.03,"x");
gStyle->SetLabelSize(0.03,"y");
gStyle->SetLabelFont(42,"x");
gStyle->SetLabelFont(42,"y");
gStyle->SetOptStat(1111);
////////////// DECLARES HISTOGRAMS /////////////////////////////////////////////////////////////
TH2D * histXY = new TH2D("histXY","",200,-15,15,200,-15,15);
///////////////////// DECLARES CHAINS ////////////////////////////////////////////////////////////
TChain *chain1 = new TChain("OpticalData","");
///////////////////////////// ADDS NTUPLES TO CHAINS ////////////////////////////////////////////
chain1->Add("./Bioluminescence_skin.root/OpticalData");
//////////////////////////////////// MAKES SELECTIONS IN EACH CHAIN ////////////////////////////////////////////////////////////
chain1->Draw("CrystalLastHitPos_Y:CrystalLastHitPos_X>>histXY","CrystalLastHitPos_Z == 30.0 && CrystalLastHitEnergy > 0.0","goff");
TCanvas *XY = new TCanvas("XY", " ",0,22,800,802);
XY->Range(-125,-125,125,125);
XY->SetGridx();
XY->SetGridy();
XY->SetTickx(1);
XY->SetTicky(1);
XY->SetFrameBorderMode(0);
XY->SetFrameBorderMode(0);
XY->SetFillColor(kWhite);
TPaletteAxis *palette = new TPaletteAxis(13.23807,-14.97093,14.93405,15.01938,histXY);
palette->SetLabelColor(1);
palette->SetLabelFont(62);
palette->SetLabelOffset(0.005);
palette->SetLabelSize(0.02);
palette->SetTitleOffset(1);
palette->SetTitleSize(0.04);
palette->SetFillColor(0);
palette->SetFillStyle(1001);
histXY->GetListOfFunctions()->Add(palette,"br");
histXY->GetXaxis()->SetTitle("x-position(mm)");
histXY->GetXaxis()->SetLabelFont(42);
histXY->GetXaxis()->SetTitleFont(42);
histXY->GetYaxis()->SetTitle("y-position(mm)");
histXY->GetYaxis()->SetLabelFont(42);
histXY->GetYaxis()->SetTitleOffset(1.43);
histXY->GetYaxis()->SetTitleFont(42);
histXY->Draw("colz");
histXY->GetXaxis()->SetTitleSize(0.03);
histXY->GetYaxis()->SetTitleSize(0.03);
histXY->GetXaxis()->SetLabelSize(0.03);
histXY->GetYaxis()->SetLabelSize(0.03);
XY->Modified();
XY->cd();
XY->SetSelected(XY);
}
void PlotRakeBunch( const TString &sim, Int_t time, Int_t index = 0, const TString &options="") {
#ifdef __CINT__
gSystem->Load("libplasma.so");
#endif
PlasmaGlob::Initialize();
TString opt = options;
// Palettes!
gROOT->Macro("PlasmaPalettes.C");
if(opt.Contains("grid")) {
gStyle->SetPadGridX(1);
gStyle->SetPadGridY(1);
}
gStyle->SetLabelFont(42,"xyz");
gStyle->SetTextFont(62);
// 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;
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.;
if(kp!=0.0) skindepth = 1/kp;
Double_t E0 = pData->GetPlasmaE0();
// 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;
opt += "comovcenter";
// Centering time and z position:
Double_t shiftz = pData->Shift(opt);
TString sshiftz = Form("(x1-%f)",shiftz);
if(opt.Contains("center")) {
Time -= zStartPlasma;
if(opt.Contains("comov")) // Centers on the head of the beam.
Time += zStartBeam;
}
// Spatial coordinates intervals:
Float_t x1Min = -4.3;
Float_t x1Max = -3.9;
Float_t x2Min = -0.5;
Float_t x2Max = 0.5;
Float_t x3Min = -0.5;
Float_t x3Max = 0.5;
// Momentum coordinates intervals:
Float_t p1Min = 6500.01;
Float_t p1Max = 10099.99;
Float_t p2Min = -20.0;
Float_t p2Max = 20.0;
Float_t p3Min = -20.0;
Float_t p3Max = 20.0;
// Bining, intervals, labels, etc.
Int_t xNbin = 200;
Int_t yNbin = 200;
if(sim.Contains("DR")) {
xNbin = 200;
yNbin = 200;
// p1Min = 2200.01;
// p1Max = 3399.99;
// p1Min = 3500.01;
// p1Max = 4999.99;
p1Min = 1800.01;
p1Max = 3999.99;
// x1Min = -4.0;
// x1Max = -3.2;
x1Min = 8637.0;
x1Max = 8639.0;
x2Min = -0.5;
x2Max = 0.5;
x3Min = -0.5;
x3Max = 0.5;
} else if(sim.Contains("flash") && sim.Contains(".G.") ) {
x1Min = -6.3;
x1Max = -5.0;
//p1Min = 0.001;
p1Min = 650.001;
p1Max = 1499.99;
} else if(sim.Contains("facet_v23kA.G.A")) {
x1Min = -7.8;
x1Max = -7.1;
x2Min = -1.0;
x2Max = 1.0;
x3Min = -1.0;
x3Max = 1.0;
// t=150
p1Min = 1100.001;
p1Max = 1999.99;
} else if(sim.Contains("facet_v23kA.G")) {
x1Min = -7.8;
x1Max = -7.0;
x2Min = -1.0;
x2Max = 1.0;
x3Min = -1.0;
x3Max = 1.0;
// t=60
p1Min = 350.01;
p1Max = 799.99;
// t = 100
// p1Min = 700.01;
// p1Max = 1399.99;
// t=105
//p1Min = 800.001;
//p1Max = 1399.99;
// t=183
// p1Min = 1500.001;
// p1Max = 2499.99;
// t=235
// p1Min = 2000.01;
// p1Max = 3499.99;
// t=310
// p1Min = 2800.01;
// p1Max = 4799.99;
}
// Get phasespace histos
Int_t Nspecies = pData->NSpecies();
if(index>Nspecies-1) {
return;
}
if(!pData->GetRawFileName(index)) {
return;
}
TH1F *hX1 = NULL;
TH1F *hP1 = NULL;
TH2F *hP1X1 = NULL;
TH2F *hP2X2 = NULL;
cout << Form("\n1. Getting data... ") << endl;
char cutString[512];
sprintf(cutString,"TMath::Abs(q)*(%s > %.1f && %s < %.1f && x2 > %.1f && x2 < %.1f && x3 > %.1f && x3 < %.1f)",sshiftz.Data(),x1Min,sshiftz.Data(),x1Max,x2Min,x2Max,x3Min,x3Max);
TCut Cut = cutString;
cout << Form(" (applied cut: \n %s)",cutString) << endl;
TTree *tree = pData->GetTreeRaw(pData->GetRawFileName(index)->c_str(),opt);
char hName[24];
char dCommand[128];
cout << Form("\n2. Dumping 1D histograms.. ") << endl;
sprintf(hName,"hX1");
hX1 = (TH1F*) gROOT->FindObject(hName);
if(hX1) delete hX1;
hX1 = new TH1F(hName,"",xNbin,x1Min,x1Max);
sprintf(dCommand,"%s>>%s",sshiftz.Data(),hName);
cout << Form(" - x1. ") << endl;
tree->Draw(dCommand,Cut,"goff");
sprintf(hName,"hP1");
hP1 = (TH1F*) gROOT->FindObject(hName);
if(hP1) delete hP1;
hP1 = new TH1F(hName,"",yNbin,p1Min,p1Max);
sprintf(dCommand,"p1>>%s",hName);
cout << Form(" - p1. ") << endl;
tree->Draw(dCommand,Cut,"goff");
cout << Form("\n3. Dumping 2D histograms.. ") << endl;
sprintf(hName,"hP1X1");
hP1X1 = (TH2F*) gROOT->FindObject(hName);
if(hP1X1) delete hP1X1;
hP1X1 = new TH2F(hName,"",xNbin,x1Min,x1Max,yNbin,p1Min,p1Max);
sprintf(dCommand,"p1:%s>>%s",sshiftz.Data(),hName);
cout << Form(" - p1 vs. x1 ") << endl;
tree->Draw(dCommand,Cut,"goff");
sprintf(hName,"hP2X2");
hP2X2 = (TH2F*) gROOT->FindObject(hName);
if(hP2X2) delete hP2X2;
hP2X2 = new TH2F(hName,"",xNbin,x2Min,x2Max,yNbin,p2Min,p2Max);
sprintf(dCommand,"p2:x2>>%s",hName);
cout << Form(" - p2 vs. x2 ") << endl;
tree->Draw(dCommand,Cut,"goff");
hX1->GetXaxis()->CenterTitle();
hX1->GetYaxis()->CenterTitle();
hX1->GetZaxis()->CenterTitle();
hP1X1->GetXaxis()->CenterTitle();
hP1X1->GetYaxis()->CenterTitle();
hP1X1->GetZaxis()->CenterTitle();
hP2X2->GetXaxis()->CenterTitle();
hP2X2->GetYaxis()->CenterTitle();
hP2X2->GetZaxis()->CenterTitle();
// Integrated long. emittance:
cout << Form("\n4. Calculating integrated quantities.. ") << endl;
Double_t xmean = 0.0;
Double_t ymean = 0.0;
Double_t x2mean = 0.0;
Double_t y2mean = 0.0;
Double_t xymean = 0.0;
Double_t Ntotal = 0.0;
for(Int_t i=1;i<=xNbin;i++) {
Double_t x = hP1X1->GetXaxis()->GetBinCenter(i);
// if(x<xmin || x>xmax) continue;
for(Int_t j=1;j<=yNbin;j++) {
Double_t y = hP1X1->GetYaxis()->GetBinCenter(j);
// if(y<ymin || y>ymax) continue;
Double_t value = TMath::Abs(hP1X1->GetBinContent(i,j));
xmean += x*value;
ymean += y*value;
x2mean += x*x*value;
y2mean += y*y*value;
xymean += x*y*value;
Ntotal += value;
}
}
xmean /= Ntotal;
ymean /= Ntotal;
x2mean /= Ntotal;
y2mean /= Ntotal;
xymean /= Ntotal;
Double_t xrms2 = x2mean - xmean*xmean;
Double_t yrms2 = y2mean - ymean*ymean;
Double_t xrms = TMath::Sqrt(xrms2);
Double_t yrms = TMath::Sqrt(yrms2);
Double_t xyrms2 = xymean - xmean*ymean;
Double_t emittance = TMath::Sqrt(xrms2*yrms2 - xyrms2*xyrms2);
// cout << " xrms = " << xrms << endl;
// Sliced emittance:
// --------------------------------------------------------------------------
cout << Form("\n5. Slicing ") << endl;
// Bining for sliced quantities:
// const Int_t SNbin = 7;
// Float_t sBinLim[SNbin+1] = {-4.16,-4.14,-4.12,-4.10,-4.08,-4.06,-4.04,-4.02};
// const Int_t SNbin = 7;
// Float_t sBinLim[SNbin+1] = {-4.20,-4.17,-4.14,-4.12,-4.10,-4.08,-4.06,-4.00};
// const Int_t SNbin = 8;
// Float_t sBinLim[SNbin+1] = {-3.93,-3.87,-3.81,-3.75,-3.69,-3.63,-3.57,-3.51,-3.45};
Int_t SNbin = 7;
Float_t nsigma = 2;
Float_t x1BinMin = -4.16;
Float_t x1BinMax = -4.02;
if(sim.Contains("DR")) {
SNbin = 150;
nsigma = 1.4;
} else if(sim.Contains("facet_v23kA.G.A")) {
SNbin = 46;
nsigma = 1;
x1BinMin = -7.55;
x1BinMax = -7.25;
} else if(sim.Contains("facet_v23kA.G")) {
SNbin = 10;
nsigma = 1;
x1BinMin = -7.55;
x1BinMax = -7.15;
}
Float_t *sBinLim = new Float_t[SNbin+1];
if(opt.Contains("rms")) {
sBinLim[0] = xmean - nsigma*xrms;
sBinLim[SNbin] = xmean + nsigma*xrms;
} else {
sBinLim[0] = x1BinMin;
sBinLim[SNbin] = x1BinMax;
}
Float_t slbinSize = (sBinLim[SNbin] - sBinLim[0])/SNbin;
for(Int_t i=1;i<SNbin;i++) {
sBinLim[i] = sBinLim[i-1] + slbinSize;
}
TH1F **hP1sl = new TH1F*[SNbin];
TH2F **hP2X2sl = new TH2F*[SNbin];
cout << Form("\n - Dumping in %i bins ",SNbin) << endl;
for(Int_t k=0;k<SNbin;k++) {
cout<< Form("k = %i : (x1 > %f && x1 < %f)",k,sBinLim[k],sBinLim[k+1]) << endl;
sprintf(hName,"hP2X2sl_%2i",k);
hP2X2sl[k] = (TH2F*) gROOT->FindObject(hName);
if(hP2X2sl[k]) delete hP2X2sl[k];
hP2X2sl[k] = new TH2F(hName,"",xNbin,x2Min,x2Max,yNbin,p2Min,p2Max);
char zCutString[128];
sprintf(zCutString,"(%s > %f && %s < %f)",sshiftz.Data(),sBinLim[k],sshiftz.Data(),sBinLim[k+1]);
TCut zCut = zCutString;
tree->Project(hName,"p2:x2",Cut + zCut);
sprintf(hName,"hP1sl_%2i",k);
hP1sl[k] = (TH1F*) gROOT->FindObject(hName);
if(hP1sl[k]) delete hP1sl[k];
hP1sl[k] = new TH1F(hName,"",yNbin,p1Min,p1Max);
tree->Project(hName,"p1",Cut + zCut);
}
cout << Form("\n6. Calculating sliced quantities.. ") << endl;
TGraph *gemit = NULL;
TGraph *gYrms = NULL;
TGraph *gErms = NULL;
TGraph *gErmsB = NULL;
Double_t * sxmean = new Double_t[SNbin];
Double_t * symean = new Double_t[SNbin];
Double_t * sx2mean = new Double_t[SNbin];
Double_t * sy2mean = new Double_t[SNbin];
Double_t * sxymean = new Double_t[SNbin];
Double_t * sNtotal = new Double_t[SNbin];
Double_t * sxrms2 = new Double_t[SNbin];
Double_t * syrms2 = new Double_t[SNbin];
Double_t * sxrms = new Double_t[SNbin];
Double_t * syrms = new Double_t[SNbin];
Double_t * sxyrms2 = new Double_t[SNbin];
Double_t * xbin = new Double_t[SNbin];
Double_t * semittance = new Double_t[SNbin];
Double_t * sNEtotal = new Double_t[SNbin];
Double_t * sEmean = new Double_t[SNbin];
Double_t * sE2mean = new Double_t[SNbin];
Double_t * sErms = new Double_t[SNbin];
for(Int_t k=0;k<SNbin;k++) {
sxmean[k] = symean[k] = sx2mean[k] = sy2mean[k] = sxymean[k]
= sNtotal[k] = sxrms2[k] = syrms2[k] = sxrms[k] = syrms[k]
= sxyrms2[k] = xbin[k] = semittance[k] = 0.0;
sNEtotal[k] = sEmean[k] = sE2mean[k] = sErms[k] = 0.0;
xbin[k] = (sBinLim[k] + sBinLim[k+1])/2.;
for(Int_t i=1;i<=xNbin;i++) {
Double_t x = hP2X2sl[k]->GetXaxis()->GetBinCenter(i);
// if(x<xmin || x>xmax) continue;
for(Int_t j=1;j<=yNbin;j++) {
Double_t y = hP2X2sl[k]->GetYaxis()->GetBinCenter(j);
// if(y<ymin || y>ymax) continue;
Double_t value = TMath::Abs(hP2X2sl[k]->GetBinContent(i,j));
sxmean[k] += x*value;
symean[k] += y*value;
sx2mean[k] += x*x*value;
sy2mean[k] += y*y*value;
sxymean[k] += x*y*value;
sNtotal[k] += value;
}
}
for(Int_t i=1;i<=yNbin;i++) {
Double_t y = hP1sl[k]->GetXaxis()->GetBinCenter(i);
Double_t value = TMath::Abs(hP1sl[k]->GetBinContent(i));
sEmean[k] += y*value;
sE2mean[k] += y*y*value;
sNEtotal[k] += value;
}
sxmean[k] /= sNtotal[k];
symean[k] /= sNtotal[k];
sx2mean[k] /= sNtotal[k];
sy2mean[k] /= sNtotal[k];
sxymean[k] /= sNtotal[k];
sxrms2[k] = sx2mean[k] - sxmean[k]*sxmean[k];
syrms2[k] = sy2mean[k] - symean[k]*symean[k];
sxrms[k] = TMath::Sqrt(sxrms2[k]);
syrms[k] = TMath::Sqrt(syrms2[k]);
sxyrms2[k] = sxymean[k] - sxmean[k]*symean[k];
semittance[k] = TMath::Sqrt(sxrms2[k]*syrms2[k] - sxyrms2[k]*sxyrms2[k]);
sEmean[k] /= sNEtotal[k];
sE2mean[k] /= sNEtotal[k];
sErms[k] = TMath::Sqrt(sE2mean[k] - sEmean[k]*sEmean[k]);
cout << " Bunch properties: " << endl;
cout << Form(" xMean = %7.3f yMean = %7.3f",sxmean[k],symean[k]) << endl;
cout << Form(" xRms = %7.3f yRms = %7.3f",sxrms[k],syrms[k]) << endl;
cout << Form(" Emittance = %7.3f",semittance[k]) << endl;
cout << Form(" Emean = %7.3f Erms = %7.3f",sEmean[k],sErms[k]) << endl;
}
// Charge
Double_t dx1 = pData->GetDX(0);
Double_t dx2 = pData->GetDX(1);
Double_t dx3 = pData->GetDX(2);
hX1->Scale(dx1*dx2*dx3);
Double_t Charge = hX1->Integral();
// Charge *= dx1*dx2*dx3;
if(opt.Contains("units")) {
Double_t dV = skindepth * skindepth * skindepth;
Charge *= n0 * dV * (PConst::ElectronCharge/PUnits::picocoulomb);
cout << Form(" Integrated charge (RAW) of specie %3i = %8f pC",index,Charge) << endl;
} else {
cout << Form(" Integrated charge (RAW) of specie %3i = %8.4f n0 * kp^-3",index,Charge) << endl;
}
// Chaning to user units:
// --------------------------
if(opt.Contains("units") && n0) {
Int_t NbinsX = hP1X1->GetNbinsX();
Double_t xMin = skindepth * hP1X1->GetXaxis()->GetXmin() / PUnits::um;
Double_t xMax = skindepth * hP1X1->GetXaxis()->GetXmax() / PUnits::um;
Int_t NbinsY = hP1X1->GetNbinsY();
Double_t yMin = hP1X1->GetYaxis()->GetXmin() * pData->GetBeamMass() / PUnits::GeV;
Double_t yMax = hP1X1->GetYaxis()->GetXmax() * pData->GetBeamMass() / PUnits::GeV;
hP1X1->SetBins(NbinsX,xMin,xMax,NbinsY,yMin,yMax);
// Converting electron density
Double_t dVb = skindepth * skindepth * skindepth;
Double_t dX = (xMax-xMin)/NbinsX;
Double_t dE = (yMax-yMin)/NbinsY;
for(Int_t j=0;j<hP1X1->GetNbinsX();j++) {
for(Int_t k=0;k<hP1X1->GetNbinsY();k++) {
Double_t binValue = fabs(hP1X1->GetBinContent(j,k) * dx1 * dx2 * dx3 * dVb * n0 *
(PConst::ElectronCharge/PUnits::picocoulomb));
//cout << Form(" value = %f",binValue) << endl;
hP1X1->SetBinContent(j,k,binValue);
}
}
if(opt.Contains("comov"))
hP1X1->GetXaxis()->SetTitle("#zeta [#mum]");
else
hP1X1->GetXaxis()->SetTitle("z [#mum]");
hP1X1->GetYaxis()->SetTitle("p_{z} [GeV/c]");
hP1X1->GetZaxis()->SetTitle("dQ/d#zetadp_{z} [pC]");
hP1->SetBins(NbinsY,yMin,yMax);
hP1->GetYaxis()->SetTitle("p_{z} [GeV/c]");
hX1->SetBins(NbinsX,xMin,xMax);
Double_t binSize = (xMax - xMin)/NbinsX;
Double_t dV = skindepth * skindepth * skindepth;
Double_t lightspeed = PConst::c_light / (PUnits::um/PUnits::femtosecond);
cout << Form("Speed of light = %f",lightspeed) << endl;
hX1->Scale(TMath::Abs(n0 * dV * (PConst::ElectronCharge/PUnits::picocoulomb) * (lightspeed/binSize)));
// hX1->Scale(TMath::Abs((PUnits::um/skindepth)*(PConst::ElectronCharge/PUnits::picocoulomb)*PConst::c_light));
// hX1->GetYaxis()->SetTitle("I[kA]");
hX1->GetYaxis()->SetTitle("");
if(opt.Contains("comov"))
hX1->GetXaxis()->SetTitle("#zeta [#mum]");
else
hX1->GetXaxis()->SetTitle("z [#mum]");
xmean *= skindepth / PUnits::um;
xrms *= skindepth / PUnits::um;
ymean *= pData->GetBeamMass() / PUnits::GeV;
yrms *= pData->GetBeamMass() / PUnits::GeV;
emittance *= (skindepth / PUnits::um);
for(Int_t k=0;k<SNbin;k++) {
xbin[k] *= skindepth / PUnits::um;
sxmean[k] *= skindepth / PUnits::um;
sxrms[k] *= skindepth / PUnits::um;
symean[k] *= pData->GetBeamMass() / PUnits::MeV;
syrms[k] *= pData->GetBeamMass() / PUnits::MeV;
semittance[k] *= (skindepth / PUnits::um);
sEmean[k] *= pData->GetBeamMass() / PUnits::GeV;
sErms[k] *= 100 * pData->GetBeamMass() / PUnits::GeV / ymean; //sEmean[k];
// sErms[k] *= pData->GetBeamMass() / PUnits::GeV;
}
}
// Create the graph with the emittances:
gemit = new TGraph(SNbin,xbin,semittance);
gYrms = new TGraph(SNbin,xbin,sxrms);
gErms = new TGraph(SNbin,xbin,sErms);
// Profile energy for p1 vs x1:
TString pname = hP1X1->GetName();
pname += "_pfx";
TProfile *hP1X1prof = (TProfile*) gROOT->FindObject(pname.Data());
if(hP1X1prof) { delete hP1X1prof; hP1X1prof = NULL; }
hP1X1prof = hP1X1->ProfileX("_pfx",1,-1,"s");
// get the errors from the profile:
Int_t NP1X1Bins = hP1X1prof->GetNbinsX();
Double_t *x1bins = new Double_t[NP1X1Bins];
Double_t *eRms = new Double_t[NP1X1Bins];
for(Int_t i=1;i<=hP1X1prof->GetNbinsX();i++) {
x1bins[i] = hP1X1prof->GetBinCenter(i);
eRms[i] = 100 * hP1X1prof->GetBinError(i) / hP1X1prof->GetBinContent(i);
}
gErmsB = new TGraph(NP1X1Bins,x1bins,eRms);
// Vertical Energy histogram:
// --------------------------------------------------------------------------------
TGraph *gP1left = NULL;
if(hP1) {
Double_t *yarray = new Double_t[yNbin];
Double_t *xarray = new Double_t[yNbin];
// This is for the right side:
// Double_t xMax = x1Min + (x1Max-x1Min) * 0.9;
// Double_t xMin = x1Max;
// And this for left:
Double_t xMin = hX1->GetXaxis()->GetXmin();
Double_t xMax = hX1->GetXaxis()->GetXmin() + (hX1->GetXaxis()->GetXmax()
-hX1->GetXaxis()->GetXmin()) * 0.2;
Double_t EneMax = hP1->GetMaximum();
// cout << Form(" EneMax = %f ", EneMax) << endl;
for(Int_t j=0; j<yNbin; j++) {
yarray[j] = hP1->GetBinCenter(j+1);
xarray[j] = ((xMax-xMin)/EneMax)*hP1->GetBinContent(j+1) + xMin;
// cout << Form(" x = %f y = %f ", xarray[j],yarray[j]) << endl;
}
gP1left = new TGraph(yNbin,xarray,yarray);
gP1left->SetLineColor(PlasmaGlob::elecLine);
gP1left->SetLineWidth(2);
gP1left->SetFillStyle(1001);
gP1left->SetFillColor(PlasmaGlob::elecFill);
}
// Plotting
// -----------------------------------------------
// Canvas setup
// Create the canvas and the pads before the Frame loop
// Resolution:
Int_t sizex = 800;
Int_t sizey = 600;
if(opt.Contains("hres")) {
Int_t sizex = 1600;
Int_t sizey = 1200;
}
TCanvas *C = new TCanvas("C1","Evolution of Injection",sizex,sizey);
C->cd();
// Set palette:
PPalette * pPalette = (PPalette*) gROOT->FindObject("electron");
pPalette->cd();
// Float_t Max = hP1X1->GetMaximum();
// Float_t Min = hP1X1->GetMinimum();
// hP1X1->GetZaxis()->SetRangeUser(Min,Max);
// Text objects
TPaveText *textTime = new TPaveText(0.55,0.8,0.82,0.9,"NDC");
PlasmaGlob::SetPaveTextStyle(textTime,32);
textTime->SetTextColor(kGray+2);
char ctext[128];
if(opt.Contains("units") && pData->GetPlasmaDensity())
sprintf(ctext,"z = %5.1f mm", Time * skindepth / PUnits::mm);
else
sprintf(ctext,"t = %5.1f #omega_{p}^{-1}",Time);
textTime->AddText(ctext);
TPaveText *textDen = new TPaveText(0.15,0.85,0.48,0.9,"NDC");
PlasmaGlob::SetPaveTextStyle(textDen,12);
textDen->SetTextColor(kOrange+10);
if(opt.Contains("units") && pData->GetPlasmaDensity())
sprintf(ctext,"n_{0} = %5.2f x 10^{17} / cc", n0 / (1e17/PUnits::cm3));
else if(pData->GetBeamDensity() && pData->GetPlasmaDensity())
sprintf(ctext,"n_{b}/n_{0} = %5.2f", pData->GetBeamDensity()/n0);
textDen->AddText(ctext);
TPaveText *textWav = new TPaveText(0.15,0.2,0.48,0.25,"NDC");
PlasmaGlob::SetPaveTextStyle(textWav,12);
textWav->SetTextColor(kGray+2);
sprintf(ctext,"#lambda_{p} = %5.2f #mum", pData->GetPlasmaWaveLength() / PUnits::um);
textWav->AddText(ctext);
TPaveText *textCharge = new TPaveText(0.15,0.25,0.48,0.3,"NDC");
PlasmaGlob::SetPaveTextStyle(textCharge,12);
textCharge->SetTextColor(kGray+2);
if(opt.Contains("units") && pData->GetPlasmaDensity())
sprintf(ctext,"Charge = %5.2f pC", Charge);
else
sprintf(ctext,"Charge = %5.2f n0#timeskp^{-3}", Charge);
textCharge->AddText(ctext);
TPaveText *textMom = new TPaveText(0.55,0.03,0.82,0.13,"NDC");
PlasmaGlob::SetPaveTextStyle(textMom,32);
textMom->SetTextColor(kGray+3);
textMom->SetTextFont(62);
if(opt.Contains("units") && pData->GetPlasmaDensity())
sprintf(ctext,"#LTp_{z}#GT = %5.2f GeV/c", ymean);
else
sprintf(ctext,"Mom = %5.2f mc", ymean);
textMom->AddText(ctext);
TPaveText *textInfo = new TPaveText(0.55,0.52,0.82,0.75,"NDC");
PlasmaGlob::SetPaveTextStyle(textInfo,32);
textInfo->SetTextColor(kGray+2);
textInfo->SetTextFont(42);
sprintf(ctext,"Charge = %5.2f pC",Charge);
textInfo->AddText(ctext);
sprintf(ctext,"#LT#zeta#GT_{rms} = %5.2f #mum",xrms);
textInfo->AddText(ctext);
sprintf(ctext,"#LTp_{z}#GT_{rms} = %5.2f GeV/c",yrms);
textInfo->AddText(ctext);
// sprintf(ctext,"#epsilon_{N} = %5.2f #mum",emittance);
// textInfo->AddText(ctext);
// Setup Pad layout:
const Int_t NFrames = 2;
TPad **pad = new TPad*[NFrames];
TH1F *hFrame[NFrames];
Double_t lMargin = 0.15;
Double_t rMargin = 0.18;
Double_t bMargin = 0.15;
Double_t tMargin = 0.04;
Double_t vSpacing = 0.00;
Double_t hStep = (1.-lMargin-rMargin);
Double_t vStep = (1.- bMargin - tMargin - (NFrames-1) * vSpacing) / NFrames;
Float_t vposd = 0.0;
Float_t vposu = 0.0;
Float_t vmard = 0.0;
Float_t vmaru = 0.0;
Float_t vfactor = 0.0;
Float_t hposl = 0.0;
Float_t hposr = 1.0;
Float_t hmarl = lMargin;
Float_t hmarr = rMargin;
Float_t hfactor = 1.0;
// Actual Plotting!
// ------------------------------------------------------------
for(Int_t k=0;k<NFrames;k++) {
// PLOTTING!
if(k==0) {
vposd = 0.0;
vposu = bMargin + vStep;
vfactor = vposu-vposd;
vmard = bMargin / vfactor;
vmaru = 0.0;
} else if(k == NFrames-1) {
vposd = vposu + vSpacing;
vposu = vposd + vStep + tMargin;
vfactor = vposu-vposd;
vmard = 0.0;
vmaru = tMargin / (vposu-vposd);
} else {
vposd = vposu + vSpacing;
vposu = vposd + vStep;
vfactor = vposu-vposd;
vmard = 0.0;
vmaru = 0.0;
}
hfactor = hposl-hposr;
char name[16];
sprintf(name,"pad_%i",k);
pad[k] = new TPad(name,"",hposl,vposd,hposr,vposu);
// // cout << Form("%f %f %f %f",hposl,vposd,hposr,vposu) << endl;
// // cout << Form("%f %f %f %f",hmarl,vmard,hmarr,vmaru) << endl;
pad[k]->SetLeftMargin(hmarl);
pad[k]->SetRightMargin(hmarr);
pad[k]->SetBottomMargin(vmard);
pad[k]->SetTopMargin(vmaru);
pad[k]->SetFrameLineWidth(3);
sprintf(name,"hFrame_%i",k);
hFrame[k] = (TH1F*) gROOT->FindObject(name);
if(hFrame[k]) delete hFrame[k];
hFrame[k] = (TH1F*) hX1->Clone(name);
hFrame[k]->Reset();
hFrame[k]->GetXaxis()->CenterTitle();
hFrame[k]->GetYaxis()->CenterTitle();
hFrame[k]->GetZaxis()->CenterTitle();
hFrame[k]->SetLabelFont(42,"xyz");
hFrame[k]->SetTitleFont(42,"xyz");
hFrame[k]->SetNdivisions(505,"xyz");
hFrame[k]->SetTickLength(0.04,"xyz");
hFrame[k]->SetTickLength(0.04*vfactor,"y");
hFrame[k]->GetYaxis()->SetLabelSize(0.04/vfactor);
hFrame[k]->GetYaxis()->SetLabelOffset(0.02);
hFrame[k]->GetYaxis()->SetTitleSize(0.05/vfactor);
hFrame[k]->GetYaxis()->SetTitleOffset(1.2*vfactor);
if(k==0) {
hFrame[k]->GetXaxis()->SetLabelSize(0.08);
hFrame[k]->GetXaxis()->SetLabelOffset(0.02);
hFrame[k]->GetXaxis()->SetTitleSize(0.12);
hFrame[k]->GetXaxis()->SetTitleOffset(1.0);
} else {
hFrame[k]->GetXaxis()->SetLabelSize(0.0);
hFrame[k]->GetXaxis()->SetTitleSize(0.0);
}
}
// Ranges!!
Double_t yMin = 999.9;
Double_t yMax = -999.9;
for(Int_t k=0;k<SNbin;k++) {
if(semittance[k]<yMin)
yMin = semittance[k];
if(semittance[k]>yMax)
yMax = semittance[k];
if(sErms[k]<yMin)
yMin = sErms[k];
if(sErms[k]>yMax)
yMax = sErms[k];
}
for(Int_t k=1;k<=xNbin;k++) {
Double_t value = hX1->GetBinContent(k);
if(value<yMin)
yMin = value;
if(value>yMax)
yMax = value;
}
C->cd();
pad[1]->Draw();
pad[1]->cd();
if(opt.Contains("logz")) {
gPad->SetLogz(1);
} else {
gPad->SetLogz(0);
}
hFrame[1]->GetYaxis()->SetRangeUser(hP1X1->GetYaxis()->GetXmin(),hP1X1->GetYaxis()->GetXmax());
if(opt.Contains("units"))
hFrame[1]->GetYaxis()->SetTitle("p_{z} [GeV/c]");
hFrame[1]->Draw();
gP1left->SetLineWidth(2);
gP1left->Draw("F");
gP1left->Draw("L");
TLine lZmean(xmean,hP1X1->GetYaxis()->GetXmin(),xmean,hP1X1->GetYaxis()->GetXmax());
lZmean.SetLineColor(kGray+2);
lZmean.SetLineStyle(2);
lZmean.Draw();
TLine lPmean(hP1X1->GetXaxis()->GetXmin(),ymean,hP1X1->GetXaxis()->GetXmax(),ymean);
lPmean.SetLineColor(kGray+2);
lPmean.SetLineStyle(2);
lPmean.Draw();
hP1X1->GetYaxis()->SetNdivisions(503);
hP1X1->GetZaxis()->SetNdivisions(503);
hP1X1->GetZaxis()->SetRangeUser(0.001*hP1X1->GetMaximum(),hP1X1->GetMaximum());
hP1X1->GetZaxis()->SetLabelSize(0.05);
hP1X1->GetZaxis()->SetTitleSize(0.04);
hP1X1->GetZaxis()->SetTitleFont(42);
hP1X1->Draw("colzsame");
// hP1X1->SetContour(20);
// hP1X1->Draw("contzsame");
// hP1X1prof->SetMarkerStyle(1);
// hP1X1prof->SetLineWidth(2);
// hP1X1prof->Draw("zsame");
//hP1->Draw("C");
gPad->Update();
TPaletteAxis *palette = (TPaletteAxis*)hP1X1->GetListOfFunctions()->FindObject("palette");
if(palette) {
Float_t y1 = gPad->GetBottomMargin();
Float_t y2 = 1 - gPad->GetTopMargin();
Float_t x1 = 1 - gPad->GetRightMargin();
palette->SetY2NDC(y2 - 0.04);
palette->SetY1NDC(y1 + 0.04);
palette->SetX1NDC(x1 + 0.01);
palette->SetX2NDC(x1 + 0.04);
palette->SetLabelFont(42);
palette->SetLabelSize(0.08);
//palette->SetLabelOffset(0.005/vfactor);
palette->SetTitleSize(0.10);
// palette->SetTitleOffset(9999.0*vfactor);
palette->SetTitleOffset(0.6);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
textTime->Draw();
textInfo->Draw();
// textCharge->Draw();
textMom->Draw();
gPad->RedrawAxis();
// Bottom plot -----------------------------------------
C->cd();
pad[0]->Draw();
pad[0]->cd();
hFrame[0]->GetYaxis()->SetRangeUser(0.0,1.1*yMax);
hFrame[0]->Draw();
hX1->SetLineWidth(2);
hX1->SetFillStyle(1001);
hX1->SetFillColor(PlasmaGlob::elecFill);
// hX1->SetLineColor(kBlue);
hX1->Draw("FL same");
//hX1->Draw("C");
TLine lZmean2(xmean,0.0,xmean,1.1*yMax);
lZmean2.SetLineColor(kGray+2);
lZmean2.SetLineStyle(2);
lZmean2.Draw();
Int_t markerSize = 1.2;
Int_t lineWidth = 2.0;
gYrms->SetMarkerStyle(20);
gYrms->SetLineStyle(1);
gYrms->SetMarkerColor(kGray+1);
gYrms->SetMarkerSize(markerSize);
gYrms->SetLineColor(kGray+1);
gYrms->SetLineWidth(lineWidth);
gYrms->Draw("PL");
// hP2X2sl[0]->Draw("colz");
gemit->SetMarkerStyle(20);
// gemit->SetMarkerColor(kMagenta-2);
gemit->SetMarkerColor(kGray+2);
gemit->SetMarkerSize(markerSize);
gemit->SetLineWidth(lineWidth);
gemit->SetLineColor(kGray+2);
gemit->Draw("PL");
gErms->SetMarkerStyle(20);
gErms->SetMarkerSize(markerSize);
gErms->SetMarkerColor(kOrange+10);
gErms->SetLineColor(kOrange+10);
gErms->SetLineWidth(lineWidth);
gErms->Draw("PL");
TLegend *Leg;
if(!sim.Contains("DR"))
Leg=new TLegend(0.55,0.60,1 - gPad->GetRightMargin() - 0.02,0.95);
else
Leg=new TLegend(gPad->GetLeftMargin() + 0.02, 1.0-gPad->GetTopMargin()-0.20,
gPad->GetLeftMargin() + 0.30, 1.0-gPad->GetTopMargin()-0.02);
PlasmaGlob::SetPaveStyle(Leg);
Leg->SetTextAlign(12);
Leg->SetTextColor(kGray+3);
Leg->SetTextFont(42);
Leg->SetLineColor(1);
Leg->SetBorderSize(0);
Leg->SetFillColor(0);
Leg->SetFillStyle(1001);
Leg->SetFillStyle(0); // Hollow
Leg->AddEntry(hX1 ,"Current [kA]","L");
// Leg->AddEntry(gErms,"Energy spread (GeV)","PL");
Leg->AddEntry(gErms,"Energy spread [%]","PL");
Leg->AddEntry(gemit,"Emittance [#mum]","PL");
Leg->AddEntry(gYrms,"Bunch width [#mum]","PL");
Leg->Draw();
gPad->RedrawAxis();
gPad->Update();
// Print to file --------------------------------------
C->cd();
// Print to a file
// Output file
TString fOutName = Form("./%s/Plots/RakeBunch/RakeBunch",sim.Data());
fOutName += Form("-%s_%i",sim.Data(),time);
PlasmaGlob::imgconv(C,fOutName,opt);
// ---------------------------------------------------------
}
void PlotField2D( const TString &sim, Int_t time, Int_t index = 0, Float_t zoom=2, Int_t Nbins=2, const TString &options="") {
#ifdef __CINT__
gSystem->Load("libptools.so");
#endif
// Load PData
PData *pData = PData::Get(sim.Data());
pData->LoadFileNames(time);
if(!pData->IsInit()) return;
// Refresh and Style
PGlobals::Initialize();
// Coloured palettes
gROOT->Macro("PPalettes.C");
TString opt = options;
// More makeup
if(opt.Contains("grid")) {
gStyle->SetPadGridX(1);
gStyle->SetPadGridY(1);
}
gStyle->SetTitleFont(42);
gStyle->SetStatFont(42);
gStyle->SetTextFont(42);
gStyle->SetTitleFont(42,"xyz");
gStyle->SetLabelFont(42,"xyz");
// Some plasma constants
Double_t n0 = pData->GetPlasmaDensity();
Double_t kp = pData->GetPlasmaK();
Double_t skindepth = 1.;
if(kp!=0.0) skindepth = 1/kp;
Double_t E0 = pData->GetPlasmaE0();
// Some beam properties:
Float_t Ebeam = pData->GetBeamEnergy() * PUnits::MeV;
Float_t gamma = Ebeam / PConst::ElectronMassE;
Float_t vbeam = TMath::Sqrt(1 - 1/(gamma*gamma));
// cout << Form(" - Bunch gamma = %8.4f", gamma ) << endl;
// cout << Form(" - Bunch velocity = %8.4f c", vbeam ) << endl;
Float_t nb = pData->GetBeamDensity();
// 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;
// z start of the neutral in normalized units.
Float_t zStartNeutral = pData->GetNeutralStart()*kp;
// z end of the neutral in normalized units.
Float_t zEndNeutral = pData->GetNeutralEnd()*kp;
if(opt.Contains("center")) {
Time -= zStartPlasma;
if(opt.Contains("comov")) // Centers on the head of the beam.
Time += zStartBeam;
}
Float_t shiftz = pData->Shift(opt);
// cout << "Shift = " << shiftz << endl;
// Calculate the "axis range" in number of bins. If Nbins==0 a RMS width is taken.
Double_t rms0 = pData->GetBeamRmsY() * kp;
if(pData->IsCyl()) rms0 = pData->GetBeamRmsR() * kp;
Int_t FirstyBin = 0;
Int_t LastyBin = 0;
if(Nbins==0) {
Nbins = TMath::Nint(rms0 / pData->GetDX(1));
}
// Slice width limits.
if(!pData->IsCyl()) {
FirstyBin = pData->GetNX(1)/2 + 1 - Nbins;
LastyBin = pData->GetNX(1)/2 + Nbins;
} else {
FirstyBin = 1;
LastyBin = Nbins;
}
// -------------------------------------------------------------------------------
// Get field histos
const Int_t Nfields = 3;
TH2F **hE2D = new TH2F*[Nfields];
for(Int_t i=0;i<Nfields;i++) {
hE2D[i] = NULL;
if(i!=index) continue;
if(!pData->GetEfieldFileName(i))
continue;
char hName[24];
sprintf(hName,"hE2D_%i",i);
hE2D[i] = (TH2F*) gROOT->FindObject(hName);
if(hE2D[i]) delete hE2D[i];
if(!pData->Is3D())
hE2D[i] = pData->GetEField(i,opt);
else
hE2D[i] = pData->GetEField2DSliceZY(i,-1,Nbins,opt+"avg");
hE2D[i]->SetName(hName);
hE2D[i]->GetXaxis()->CenterTitle();
hE2D[i]->GetYaxis()->CenterTitle();
hE2D[i]->GetZaxis()->CenterTitle();
if(opt.Contains("comov"))
hE2D[i]->GetXaxis()->SetTitle("k_{p} #zeta");
else
hE2D[i]->GetXaxis()->SetTitle("k_{p} z");
if(pData->IsCyl())
hE2D[i]->GetYaxis()->SetTitle("k_{p} r");
else
hE2D[i]->GetYaxis()->SetTitle("k_{p} x");
if(i==0)
hE2D[i]->GetZaxis()->SetTitle("E_{z} / E_{0}");
else if(i==1)
hE2D[i]->GetZaxis()->SetTitle("E_{y} / E_{0}");
else if(i==2)
hE2D[i]->GetZaxis()->SetTitle("E_{x} / E_{0}");
}
// Tunning the Histograms
// ---------------------
// Chaning to user units:
// --------------------------
if(opt.Contains("units") && n0) {
for(Int_t i=0;i<Nfields;i++) {
if(i!=index) continue;
Int_t NbinsX = hE2D[i]->GetNbinsX();
Float_t xMin = skindepth * hE2D[i]->GetXaxis()->GetXmin() / PUnits::um;
Float_t xMax = skindepth * hE2D[i]->GetXaxis()->GetXmax() / PUnits::um;
Int_t NbinsY = hE2D[i]->GetNbinsY();
Float_t yMin = skindepth * hE2D[i]->GetYaxis()->GetXmin() / PUnits::um;
Float_t yMax = skindepth * hE2D[i]->GetYaxis()->GetXmax() / PUnits::um;
hE2D[i]->SetBins(NbinsX,xMin,xMax,NbinsY,yMin,yMax);
for(Int_t j=0;j<hE2D[i]->GetNbinsX();j++) {
for(Int_t k=0;k<hE2D[i]->GetNbinsY();k++) {
hE2D[i]->SetBinContent(j,k, hE2D[i]->GetBinContent(j,k) * ( E0 / (PUnits::GV/PUnits::m) ) );
}
}
if(pData->IsCyl())
hE2D[i]->GetYaxis()->SetTitle("r [#mum]");
else
hE2D[i]->GetYaxis()->SetTitle("x [#mum]");
if(opt.Contains("comov"))
hE2D[i]->GetXaxis()->SetTitle("#zeta [#mum]");
else
hE2D[i]->GetXaxis()->SetTitle("z [#mum]");
if(i==0)
hE2D[i]->GetZaxis()->SetTitle("E_{z} [GV/m]");
else if(i==1)
hE2D[i]->GetZaxis()->SetTitle("E_{y} [GV/m]");
else if(i==2)
hE2D[i]->GetZaxis()->SetTitle("E_{x} [GV/m]");
}
}
// --------------------------------------------------- Vertical Zoom ------------
Float_t yRange = (hE2D[index]->GetYaxis()->GetXmax() - hE2D[index]->GetYaxis()->GetXmin())/zoom;
Float_t midPoint = (hE2D[index]->GetYaxis()->GetXmax() + hE2D[index]->GetYaxis()->GetXmin())/2.;
Float_t yMin = midPoint-yRange/2;
Float_t yMax = midPoint+yRange/2;
if(pData->IsCyl()) {
yMin = hE2D[index]->GetYaxis()->GetXmin();
yMax = yRange;
}
hE2D[index]->GetYaxis()->SetRangeUser(yMin,yMax);
Float_t xMin = hE2D[index]->GetXaxis()->GetXmin();
Float_t xMax = hE2D[index]->GetXaxis()->GetXmax();
Float_t xRange = xMax - xMin;
// Change the range of z axis for the fields to be symmetric.
Float_t Emax = hE2D[index]->GetMaximum();
Float_t Emin = hE2D[index]->GetMinimum();
if(Emax > TMath::Abs(Emin))
Emin = -Emax;
else
Emax = -Emin;
hE2D[index]->GetZaxis()->SetRangeUser(Emin,Emax);
PPalette * plasmaPalette = (PPalette*) gROOT->FindObject("rbowwhite");
plasmaPalette->cd();
// Plotting
// -----------------------------------------------
// Canvas setup
TCanvas *C = new TCanvas("C","2D electric",800,500);
// Actual Plotting!
// ------------------------------------------------------------
// Output file
TString fname;
if(index<3) fname = Form("E%i",index+1);
TString fOutName = Form("./%s/Plots/Field2D/Field2D-%s",sim.Data(),fname.Data());
fOutName += Form("-%s_%i",sim.Data(),time);
C->cd();
// Setup Pad layout:
Float_t lMargin = 0.15;
Float_t rMargin = 0.18;
Float_t bMargin = 0.20;
Float_t tMargin = 0.06;
gPad->SetLeftMargin(lMargin);
gPad->SetRightMargin(rMargin);
gPad->SetBottomMargin(bMargin);
gPad->SetTopMargin(tMargin);
if(opt.Contains("logz")) {
gPad->SetLogz(1);
} else {
gPad->SetLogz(0);
}
gPad->SetFrameLineWidth(2);
// Define the frames for plotting
Int_t fonttype = 43;
Int_t fontsize = 28;
Int_t tfontsize = 30;
Float_t txoffset = 1.3;
Float_t lxoffset = 0.02;
Float_t tyoffset = 1.0;
Float_t lyoffset = 0.01;
Float_t tylength = 0.02;
Float_t txlength = 0.04;
TH2F *hFrame = (TH2F*) gROOT->FindObject("hFrame");
if(hFrame) delete hFrame;
hFrame = (TH2F*) hE2D[index]->Clone("hFrame");
hFrame->Reset();
// Format for y axis
hFrame->GetYaxis()->SetTitleFont(fonttype);
hFrame->GetYaxis()->SetTitleSize(tfontsize);
hFrame->GetYaxis()->SetTitleOffset(tyoffset);
hFrame->GetYaxis()->SetLabelFont(fonttype);
hFrame->GetYaxis()->SetLabelSize(fontsize);
hFrame->GetYaxis()->SetLabelOffset(lyoffset);
hFrame->GetYaxis()->SetTickLength(tylength);
// Format for x axis
hFrame->GetXaxis()->SetTitleFont(fonttype);
hFrame->GetXaxis()->SetTitleSize(tfontsize+2);
hFrame->GetXaxis()->SetTitleOffset(txoffset);
hFrame->GetXaxis()->SetLabelFont(fonttype);
hFrame->GetXaxis()->SetLabelSize(fontsize+2);
hFrame->GetXaxis()->SetLabelOffset(lxoffset);
hFrame->GetXaxis()->SetTickLength(txlength);
hFrame->Draw("col");
// hE2D[index]->GetZaxis()->SetNdivisions(505);
hE2D[index]->GetZaxis()->SetTitleFont(fonttype);
hE2D[index]->Draw("colz same");
// Re-touchs
gPad->Update();
Float_t y1 = gPad->GetBottomMargin();
Float_t y2 = 1 - gPad->GetTopMargin();
Float_t x1 = gPad->GetLeftMargin();
Float_t x2 = 1 - gPad->GetRightMargin();
Float_t gap = 0.005;
TPaletteAxis *palette = (TPaletteAxis*)hE2D[index]->GetListOfFunctions()->FindObject("palette");
if(palette) {
palette->SetY2NDC(y2 - gap);
palette->SetY1NDC(y1 + gap);
palette->SetX1NDC(x2 + 0.005);
palette->SetX2NDC(x2 + 0.03);
palette->SetTitleOffset(tyoffset);
palette->SetTitleSize(tfontsize);
palette->SetLabelFont(fonttype);
palette->SetLabelSize(fontsize);
if(opt.Contains("logz"))
palette->SetLabelOffset(0);
else
palette->SetLabelOffset(lyoffset);
palette->SetBorderSize(2);
palette->SetLineColor(1);
}
// Text objects
TPaveText *textTime = new TPaveText(xMax - 0.30*xRange, yMax-0.10*yRange, xMax-0.02*xRange, yMax-0.02*yRange);
PGlobals::SetPaveTextStyle(textTime,32);
char ctext[128];
if(opt.Contains("units") && n0)
sprintf(ctext,"z = %5.1f #mum", Time * skindepth / PUnits::um);
else
sprintf(ctext,"#omega_{p} t = %5.1f",Time);
textTime->AddText(ctext);
TPaveText *textDen = new TPaveText(xMin + 0.02*xRange, yMax-0.10*yRange, xMin + 0.40*xRange, yMax-0.02*yRange);
PGlobals::SetPaveTextStyle(textDen,12);
textDen->SetTextColor(kOrange+10);
if(opt.Contains("units") && n0) {
sprintf(ctext,"n_{0} = %5.2f x 10^{17} / cm^{3}", 1e-17 * n0 * PUnits::cm3);
textDen->AddText(ctext);
textDen->Draw();
}
textTime->Draw();
gPad->RedrawAxis();
C->cd();
// Print to a file
PGlobals::imgconv(C,fOutName,opt);
// ---------------------------------------------------------
}
