--- /dev/null
+const Int_t nCentralityBins = 20;
+
+void calculateNuDyn(Int_t runNumber = 1) {
+ //macro to read the output of the fluctuations task
+ //calculate nu_dyn for each centrality bin
+ //and draw the centrality dependence
+ TString filename = "mergedOutputCentrality.Pass1_4Plus."; filename += runNumber; filename += ".root";
+ TString outputFileName = "output."; outputFileName += runNumber; outputFileName += ".txt";
+
+ //===============================================================//
+ Double_t nEvents[nCentralityBins] = {1.,1.,1.,1.,1.,1.,1.,1.,1.};
+ Double_t nMeanPlus[nCentralityBins] = {1.,1.,1.,1.,1.,1.,1.,1.,1.};
+ Double_t nMeanMinus[nCentralityBins] = {1.,1.,1.,1.,1.,1.,1.,1.,1.};
+ Double_t gNuStat[nCentralityBins] = {1.,1.,1.,1.,1.,1.,1.,1.,1.};
+ Double_t gNu[nCentralityBins] = {1.,1.,1.,1.,1.,1.,1.,1.,1.};
+ Double_t gNuDyn[nCentralityBins] = {1.,1.,1.,1.,1.,1.,1.,1.,1.};
+ //===============================================================//
+
+ //_______________________________________________________________//
+ //Open the input file
+ TFile *f = TFile::Open(filename.Data());
+ if(!f->IsOpen()) {
+ Printf("File not found!!!");
+ break;
+ }
+
+ //_______________________________________________________________//
+ //Get the TDirectoryFile
+ TDirectoryFile *dir = dynamic_cast<TDirectoryFile *>(f->Get("outputFluctuationAnalysis.root"));
+ if(!dir) {
+ Printf("TDirectoryFile not found!!!");
+ break;
+ }
+
+ //_______________________________________________________________//
+ //Get the TList
+ TList *list = dynamic_cast<TList *>(dir->Get("fluctuationsOutput"));
+ if(!list) {
+ Printf("TList not found!!!");
+ break;
+ }
+
+ //_______________________________________________________________//
+ //Get the histograms
+ TH1F *gHistEventStats = dynamic_cast<TH1F *>(list->FindObject("fHistEventStats"));
+ PrintEventStats(gHistEventStats);
+ TH1F *gHistCentrality = dynamic_cast<TH1F *>(list->FindObject("fHistCentrality"));
+ GetCentralityStats(gHistCentrality,nEvents);
+
+ TH2F *gHistNPlusNMinus[nCentralityBins];
+ TH1F *gHistNetCharge[nCentralityBins];
+ TCanvas *c[nCentralityBins];
+ TString histName;
+
+ ofstream outputAscii;
+ outputAscii.open(outputFileName.Data());
+
+ for(Int_t iBin = 1; iBin <= nCentralityBins; iBin++) {
+ histName = "fHistNPlusNMinusCentrality"; histName += iBin;
+ gHistNPlusNMinus[iBin-1] = dynamic_cast<TH2F *>(list->FindObject(histName.Data()));
+ histName = "fHistNetChargeCentrality"; histName += iBin;
+ gHistNetCharge[iBin-1] = new TH1F(histName.Data(),
+ "Net Charge;#Delta Q = N_{+} - N_{-};Entries",100,-100,100);
+ gHistNetCharge[iBin-1]->SetStats(kFALSE);
+ //Printf("%s",gHistNPlusNMinus[iBin-1]->GetName());
+ if(nEvents[iBin-1] != 0) {
+ gNuDyn[iBin-1] = GetNuDun(gHistNPlusNMinus[iBin-1],
+ gHistNetCharge[iBin-1],
+ nEvents[iBin-1]);
+ cout<<"Centrality: "<<iBin<<" - nuDyn: "<<gNuDyn[iBin-1]<<endl;
+ outputAscii << iBin<<" "<<gNuDyn[iBin-1]<<" "<<gHistNetCharge[iBin-1]->GetMean()<<" "<<gHistNetCharge[iBin-1]->GetRMS()<<" "<<nEvents[iBin-1]<<endl;
+
+ //c[iBin-1] = new TCanvas(histName.Data(),histName.Data(),
+ //(iBin-1)*50,(iBin-1)*50,600,500);
+ //c[iBin-1]->SetFillColor(10); c[iBin-1]->SetHighLightColor(10);
+ //gHistNetCharge[iBin-1]->Draw("E");
+ }//centrality with events
+ }//centrality loop
+ outputAscii.close();
+}
+
+//_______________________________________________________________//
+void PrintEventStats(TH1F *gHistEventStats) {
+ Printf("================EVENT STATISTICS================");
+ Printf("Total events: %d",(Int_t)(gHistEventStats->GetBinContent(1)));
+ Printf("Total triggered events: %d",(Int_t)(gHistEventStats->GetBinContent(2)));
+ Printf("Total events with proper vertex: %d",(Int_t)(gHistEventStats->GetBinContent(3)));
+ Printf("Total events analyzed: %d",(Int_t)(gHistEventStats->GetBinContent(4)));
+ Printf("================EVENT STATISTICS================\n\n\n");
+
+ return;
+}
+
+//_______________________________________________________________//
+void GetCentralityStats(TH1F *gHistCentrality,
+ Double_t *nEvents) {
+ Printf("================CENTRALITY STATISTICS================");
+ for(Int_t iBin = 1; iBin <= gHistCentrality->GetNbinsX(); iBin++) {
+ nEvents[iBin-1] = gHistCentrality->GetBinContent(iBin);
+ Printf("Centrality %d: %d",iBin,
+ (Int_t)(gHistCentrality->GetBinContent(iBin)));
+ }
+ Printf("================CENTRALITY STATISTICS================");
+
+ return;
+}
+
+//_______________________________________________________________//
+Double_t GetNuDun(TH2F *gHistNPlusNMinus,
+ TH1F *gHistNetCharge,
+ Int_t numberOfEvents) {
+ Double_t avgNPlus = gHistNPlusNMinus->GetMean(1);
+ Double_t avgNMinus = gHistNPlusNMinus->GetMean(2);
+ Double_t gNuStat = (1./avgNPlus) + (1./avgNMinus);
+ Double_t gNuDyn = 0., gNu = 0.;
+
+ for(Int_t iBinX = 1; iBinX <= gHistNPlusNMinus->GetNbinsX(); iBinX++) {
+ for(Int_t iBinY = 1; iBinY <= gHistNPlusNMinus->GetNbinsY(); iBinY++) {
+ if(gHistNPlusNMinus->GetBinContent(iBinX,iBinY) != 0) {
+ for(Int_t nEvents = 0; nEvents < gHistNPlusNMinus->GetBinContent(iBinX,iBinY); nEvents++) {
+ Int_t nPlus = (Int_t)(gHistNPlusNMinus->GetXaxis()->GetBinCenter(iBinX));
+ Int_t nMinus = (Int_t)(gHistNPlusNMinus->GetYaxis()->GetBinCenter(iBinY));
+ if((avgNPlus != 0)&&(avgNMinus != 0)) {
+ gHistNetCharge->Fill(nPlus-nMinus);
+ gNu += TMath::Power(((nPlus/avgNPlus)-(nMinus/avgNMinus)),2);
+ }
+ }
+ }
+ }
+ }
+
+ gNu /= numberOfEvents;
+ gNuDyn = gNu - gNuStat;
+
+ return gNuDyn;
+}
--- /dev/null
+//=======================================================================//
+//Macro to draw the main results of the charge fluctuation analysis:
+//=======================================================================//
+
+//+++++++++++++++++++++GLOBAL VARIABLES+++++++++++++++++++++//
+const Int_t nCentralityBins = 20;
+//Double_t gCentralityPercentile[nCentralityBins] = {2.5,7.5,12.5,17.5,22.5,27.5,32.5,37.5,42.5,47.5,52.5,57.5,62.5,67.5,72.5,77.5,82.5,87.5,92.5,97.5};
+//Double_t gCentralityPercentileError[nCentralityBins] = {0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5};
+Double_t gCentralityPercentile[nCentralityBins] = {5.,15.,25.,35.,45.,55.,65.,75.,85.,95.};
+Double_t gCentralityPercentileError[nCentralityBins] = {0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5};
+
+//================================ALICE================================//
+Double_t gNuDynALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNuDynALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+Double_t gNetChargeALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNetChargeALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+Double_t gNetChargeRmsALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNetChargeRmsALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+//================================ALICE================================//
+//+++++++++++++++++++++END OF VARIABLES+++++++++++++++++++++//
+
+//_____________________________________________________//
+void drawCentralityDependence(const char*resultPath = "../LHC10h/Pass1_4Plus/20CentralityBins/") {
+ //Draws the nu_dyn vs centrality percentile
+ SetDataPoints(resultPath);
+ //================================================//
+ //ALICE PbPb @ 2.76 TeV
+ TGraphErrors *grALICEDataNudyn = new TGraphErrors(nCentralityBins,
+ gCentralityPercentile,
+ gNuDynALICEData,
+ gCentralityPercentileError,
+ gNuDynALICEDataError);
+ grALICEDataNudyn->SetMarkerStyle(20);
+ grALICEDataNudyn->SetMarkerColor(2);
+
+ TGraphErrors *grALICEDataNetCharge = new TGraphErrors(nCentralityBins,
+ gCentralityPercentile,
+ gNetChargeALICEData,
+ gCentralityPercentileError,
+ gNetChargeALICEDataError);
+ grALICEDataNetCharge->SetMarkerStyle(20);
+ grALICEDataNetCharge->SetMarkerColor(2);
+
+ TGraphErrors *grALICEDataNetChargeRms = new TGraphErrors(nCentralityBins,
+ gCentralityPercentile,
+ gNetChargeRmsALICEData,
+ gCentralityPercentileError,
+ gNetChargeRmsALICEDataError);
+ grALICEDataNetChargeRms->SetMarkerStyle(20);
+ grALICEDataNetChargeRms->SetMarkerColor(2);
+
+ //_____________________________________________________//
+ //Draw the results
+ //_____________________________________________________//
+ TLatex *latex = new TLatex();
+ latex->SetTextSize(0.035);
+
+ //====================================//
+ //Results vs centrality
+ TH2F *gEmpty1 = new TH2F("gEmpty1",
+ ";Centrality percentile;",
+ nCentralityBins,0,100,10000,-0.1,50.);
+ gEmpty1->SetStats(kFALSE);
+ gEmpty1->GetYaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetXaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetYaxis()->SetNdivisions(10);
+ gEmpty1->GetXaxis()->SetNdivisions(10);
+
+ TF1 *f1 = new TF1("f1","0",0,1000);
+ f1->SetLineColor(1); f1->SetLineStyle(3); f1->SetLineWidth(2);
+
+ //============================================================//
+ //nu_{dyn.}
+ TCanvas *c1 = new TCanvas("c1","Centrality dependence: nu_dyn",
+ 0,0,500,500);
+ c1->SetFillColor(10); c1->SetHighLightColor(10);
+ c1->SetLeftMargin(0.15); c1->SetBottomMargin(0.15);
+ c1->SetGridx(); c1->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(-0.08,0.01);
+ gEmpty1->GetYaxis()->SetTitle("#nu_{dyn.}");
+ gEmpty1->DrawCopy();
+ f1->Draw("same");
+ grALICEDataNudyn->Draw("P");
+
+ DrawMarker(47., 0.0043, 20, 1.6, 2);
+ latex->DrawLatex(52.,0.0035,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c1->SaveAs("centralityPercentileDependenceNuDyn.png");
+
+ //============================================================//
+ //net charge
+ TCanvas *c2 = new TCanvas("c2","Centrality dependence: net charge",
+ 100,100,500,500);
+ c2->SetFillColor(10); c2->SetHighLightColor(10);
+ c2->SetLeftMargin(0.15); c2->SetBottomMargin(0.15);
+ c2->SetGridx(); c2->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,10.0);
+ gEmpty1->GetYaxis()->SetTitle("#LT #Delta Q = N_{+} - N_{-}#GT");
+ gEmpty1->DrawCopy();
+ grALICEDataNetCharge->Draw("P");
+
+ DrawMarker(47., 8.3, 20, 1.6, 2);
+ latex->DrawLatex(52.,8.1,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c2->SaveAs("centralityPercentileDependenceNetCharge.png");
+
+ //============================================================//
+ //rms net charge
+ TCanvas *c3 = new TCanvas("c3","Centrality dependence: net charge rms",
+ 200,200,500,500);
+ c3->SetFillColor(10); c3->SetHighLightColor(10);
+ c3->SetLeftMargin(0.15); c3->SetBottomMargin(0.15);
+ c3->SetGridx(); c3->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,40.0);
+ gEmpty1->GetYaxis()->SetTitle("#sigma_{#Delta Q}");
+ gEmpty1->DrawCopy();
+ grALICEDataNetChargeRms->Draw("P");
+
+ DrawMarker(47., 38.3, 20, 1.6, 2);
+ latex->DrawLatex(52.,38.1,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c3->SaveAs("centralityPercentileDependenceNetChargeRms.png");
+}
+
+//_______________________________________________________________//
+void SetDataPoints(const char* resultPath) {
+ //Calculate the mean and the statistical error of the data points
+ const Int_t nRuns = 7;
+ Double_t nuDyn[nRuns][nCentralityBins];
+ Double_t gNetCharge[nRuns][nCentralityBins];
+ Double_t gNetChargeRms[nRuns][nCentralityBins];
+ Double_t nuDyn[nRuns][nCentralityBins];
+ Int_t nEvents[nRuns][nCentralityBins];
+ Int_t nRunNumbers[nRuns] = {137161,137431,137549,
+ 137595,137638,137639,137693};
+ Int_t gCentrality;
+ Double_t netChargeValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t netChargeValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.};
+ Double_t netChargeRmsValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.};
+ Double_t netChargeRmsValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.};
+ Double_t nuDynValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t nuDynValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t nEventsValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+
+ TString inputFileName;
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ ifstream inputAscii;
+ Printf("Adding run %d",nRunNumbers[iRun]);
+ inputFileName = resultPath;
+ inputFileName += "/output."; inputFileName += nRunNumbers[iRun];
+ inputFileName += ".txt";
+
+ //Printf("Filename: %s",inputFileName.Data());
+ inputAscii.open(inputFileName.Data());
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ inputAscii>>gCentrality>>nuDyn[iRun][iCentrality]>>gNetCharge[iRun][iCentrality]>>gNetChargeRms[iRun][iCentrality]>>nEvents[iRun][iCentrality];
+ //cout<<nuDyn[iRun][iCentrality]<<" "<<nEvents[iRun][iCentrality]<<endl;
+ }
+ inputAscii.close();
+ }
+
+ Int_t nRunCounter = 0;
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ nuDynValues[iCentrality] += nuDyn[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ netChargeValues[iCentrality] += gNetCharge[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ netChargeRmsValues[iCentrality] += gNetChargeRms[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ nEventsValues[iCentrality] += nEvents[iRun][iCentrality];
+ }
+
+ if(nEventsValues[iCentrality] != 0) {
+ nRunCounter += 1;
+
+ netChargeValues[iCentrality] /= nEventsValues[iCentrality];
+ netChargeRmsValues[iCentrality] /= nEventsValues[iCentrality];
+ nuDynValues[iCentrality] /= nEventsValues[iCentrality];
+ }
+ else {
+ netChargeValues[iCentrality] = 999.;
+ netChargeRmsValues[iCentrality] = 999.;
+ nuDynValues[iCentrality] = 999.;
+ }
+
+ gNetChargeALICEData[iCentrality] = netChargeValues[iCentrality];
+ gNetChargeRmsALICEData[iCentrality] = netChargeRmsValues[iCentrality];
+ gNuDynALICEData[iCentrality] = nuDynValues[iCentrality];
+ }
+
+ ofstream outputAscii;
+ outputAscii.open("output.txt");
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ netChargeValuesError[iCentrality] += TMath::Power((netChargeValues[iCentrality]-gNetCharge[iRun][iCentrality]),2);
+ netChargeRmsValuesError[iCentrality] += TMath::Power((netChargeRmsValues[iCentrality]-gNetChargeRms[iRun][iCentrality]),2);
+ nuDynValuesError[iCentrality] += TMath::Power((nuDynValues[iCentrality]-nuDyn[iRun][iCentrality]),2);
+ }
+ gNetChargeALICEDataError[iCentrality] = TMath::Sqrt(netChargeValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)));
+ gNetChargeRmsALICEDataError[iCentrality] = TMath::Sqrt(netChargeRmsValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)));
+ gNuDynALICEDataError[iCentrality] = TMath::Sqrt(nuDynValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)));
+ Printf("Centrality: %d - nu_dyn: %lf +- %lf - Net charge: %lf +- %lf - RMS: %lf - %lf",iCentrality+1,
+ gNuDynALICEData[iCentrality],
+ gNuDynALICEDataError[iCentrality],
+ gNetChargeALICEData[iCentrality],
+ gNetChargeALICEDataError[iCentrality],
+ gNetChargeRmsALICEData[iCentrality],
+ gNetChargeRmsALICEDataError[iCentrality]);
+
+ outputAscii<<iCentrality+1<<" "<<gNuDynALICEData[iCentrality]<<" "<<gNuDynALICEDataError[iCentrality]<<" "<<gNetChargeALICEData[iCentrality]<<" "<<gNetChargeALICEDataError[iCentrality]<<" "<<gNetChargeRmsALICEData[iCentrality]<<" "<<gNetChargeRmsALICEDataError[iCentrality]<<endl;
+ }
+ outputAscii.close();
+
+}
+
+
+//_______________________________________________________________//
+void DrawMarker(Double_t x, Double_t y, Int_t style,
+ Double_t size, Int_t color) {
+ TMarker *m = new TMarker(x,y,style);
+ m->SetMarkerSize(size);
+ m->SetMarkerColor(color);
+ m->Draw();
+}
--- /dev/null
+void drawEnergyDependence() {
+ //Macro to draw the energy dependence of the nu_dyn
+
+ //================================ALICE================================//
+ Double_t gNuDynALICEData[1] = {-0.000991451};
+ Double_t gNuDynALICEDataStatError[1] = {3.06304e-05};
+
+ Double_t gALICEEnergy[1] = {2760.};
+ Double_t gALICEEnergyError[1] = {10.};
+
+ TGraphErrors *grNuDynALICEData = new TGraphErrors(1,gALICEEnergy,
+ gNuDynALICEData,
+ gALICEEnergyError,
+ gNuDynALICEDataStatError);
+ grNuDynALICEData->SetMarkerStyle(20);
+ grNuDynALICEData->SetMarkerColor(2);
+ grNuDynALICEData->SetMarkerSize(1.4);
+
+ //================================CERES================================//
+ Double_t gNuDynCERESData[3] = {-0.00006,-0.00069,-0.00108};
+ Double_t gNuDynCERESDataStatError[3] = {5.0e-05,5.0e-05,5.0e-05};
+
+ Double_t gCERESEnergy[3] = {7.8,12.3,17.3};
+ Double_t gCERESEnergyError[3] = {0.5,0.5,0.5};
+
+ TGraphErrors *grNuDynCERESData = new TGraphErrors(3,gCERESEnergy,
+ gNuDynCERESData,
+ gCERESEnergyError,
+ gNuDynCERESDataStatError);
+ grNuDynCERESData->SetMarkerStyle(23);
+ grNuDynCERESData->SetMarkerColor(1);
+ grNuDynCERESData->SetMarkerSize(1.4);
+
+ //================================STAR================================//
+ Double_t gNuDynSTARData[4] = {-0.00113,-0.00147,-0.00122,-0.00163};
+ Double_t gNuDynSTARDataStatError[4] = {0.00026,0.00018,0.00014,7e-05};
+
+ Double_t gSTAREnergy[4] = {19.6,62.4,130.,200.};
+ Double_t gSTAREnergyError[4] = {0.5,0.5,0.5,0.5};
+
+ TGraphErrors *grNuDynSTARData = new TGraphErrors(4,gSTAREnergy,
+ gNuDynSTARData,
+ gSTAREnergyError,
+ gNuDynSTARDataStatError);
+ grNuDynSTARData->SetMarkerStyle(29);
+ grNuDynSTARData->SetMarkerColor(3);
+ grNuDynSTARData->SetMarkerSize(1.6);
+
+ //================================PHENIX================================//
+ Double_t gNuDynPHENIXData[1] = {-0.00086};
+ Double_t gNuDynPHENIXDataStatError[1] = {0.00038};
+
+ Double_t gPHENIXEnergy[1] = {150.};
+ Double_t gPHENIXEnergyError[4] = {0.5};
+
+ TGraphErrors *grNuDynPHENIXData = new TGraphErrors(1,gPHENIXEnergy,
+ gNuDynPHENIXData,
+ gPHENIXEnergyError,
+ gNuDynPHENIXDataStatError);
+ grNuDynPHENIXData->SetMarkerStyle(21);
+ grNuDynPHENIXData->SetMarkerColor(4);
+ grNuDynPHENIXData->SetMarkerSize(1.2);
+
+ //_____________________________________________________//
+ //Draw the results
+ //_____________________________________________________//
+ TLatex *latex = new TLatex();
+ latex->SetTextSize(0.035);
+ //====================================//
+ //results vs centrality
+ TH2F *gEmpty1 = new TH2F("gEmpty1",
+ ";#sqrt{s_{NN}} (GeV);",
+ 100,1,10000,10000,-0.003,0.5e-03);
+ gEmpty1->SetStats(kFALSE);
+ gEmpty1->GetYaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetXaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetYaxis()->SetNdivisions(10);
+ gEmpty1->GetXaxis()->SetNdivisions(10);
+
+ TF1 *f1 = new TF1("f1","0",0,10000);
+ f1->SetLineColor(1); f1->SetLineStyle(3); f1->SetLineWidth(3);
+
+ //============================================================//
+ //nu_{dyn.}
+ TCanvas *c1 = new TCanvas("c1","Energy dependence: nu_dyn",
+ 0,0,500,500);
+ c1->SetFillColor(10); c1->SetHighLightColor(10);
+ c1->SetLeftMargin(0.15); c1->SetBottomMargin(0.15);
+ c1->SetGridx(); c1->SetGridy(); c1->SetLogx();
+ gEmpty1->GetYaxis()->SetTitle("#nu_{dyn.}");
+ gEmpty1->DrawCopy();
+ f1->Draw("same");
+ grNuDynALICEData->Draw("P");
+ grNuDynCERESData->Draw("P");
+ grNuDynSTARData->Draw("P");
+ grNuDynPHENIXData->Draw("P");
+
+ DrawMarker(7., -0.0019, 20, 1.6, 2);
+ DrawMarker(7., -0.0021, 29, 1.6, 3);
+ DrawMarker(7., -0.0023, 21, 1.6, 4);
+ DrawMarker(7., -0.0025, 23, 1.6, 1);
+ latex->DrawLatex(10.,-0.00195,"ALICE");
+ latex->DrawLatex(10.,-0.00215,"STAR");
+ latex->DrawLatex(10.,-0.00235,"PHENIX");
+ latex->DrawLatex(10.,-0.00255,"CERES");
+
+ c1->SaveAs("energyDependenceNuDyn.png");
+}
+
+//_______________________________________________________________//
+void DrawMarker(Double_t x, Double_t y, Int_t style,
+ Double_t size, Int_t color) {
+ TMarker *m = new TMarker(x,y,style);
+ m->SetMarkerSize(size);
+ m->SetMarkerColor(color);
+ m->Draw();
+}
--- /dev/null
+void drawMultiplicity(const char* filename = "AnalysisResults.root") {
+ //Draws the multiplicity for each centrality bin
+ const Int_t nCentralityBins = 20;
+
+ //_______________________________________________________________//
+ //Open the input file
+ TFile *f = TFile::Open(filename);
+ if(!f->IsOpen()) {
+ Printf("File not found!!!");
+ break;
+ }
+
+ //_______________________________________________________________//
+ //Get the TDirectoryFile
+ TDirectoryFile *dir = dynamic_cast<TDirectoryFile *>(f->Get("outputFluctuationAnalysis.root"));
+ if(!dir) {
+ Printf("TDirectoryFile not found!!!");
+ break;
+ }
+
+ //_______________________________________________________________//
+ //Get the TList
+ TList *list = dynamic_cast<TList *>(dir->Get("fluctuationsOutput"));
+ if(!list) {
+ Printf("TList not found!!!");
+ break;
+ }
+ //list->ls();
+
+ TH1F *gHistNMultiplicity[nCentralityBins];
+ TH2F *gHistNPlusNMinus[nCentralityBins];
+ TString histName;
+
+ for(Int_t iBin = 1; iBin <= nCentralityBins; iBin++) {
+ histName = "fHistNPlusNMinusCentrality"; histName += iBin;
+ gHistNPlusNMinus[iBin-1] = dynamic_cast<TH2F *>(list->FindObject(histName.Data()));
+ gHistNPlusNMinus[iBin-1]->SetMarkerColor(iBin);
+
+ histName = "fHistNMultCentrality"; histName += iBin;
+ gHistNMultiplicity[iBin-1] = dynamic_cast<TH1F *>(list->FindObject(histName.Data()));
+ gHistNMultiplicity[iBin-1]->SetMarkerColor(iBin);
+ gHistNMultiplicity[iBin-1]->SetLineColor(iBin);
+ gHistNMultiplicity[iBin-1]->Scale(5000./gHistNMultiplicity[iBin-1]->Integral());
+ }
+
+ //_______________________________________________________________//
+ //Draw the multiplicity distributions
+ TH2F *hEmpty = new TH2F("hEmpty","",200,0,2000,500,0,2000);
+ hEmpty->SetStats(kFALSE);
+ hEmpty->GetXaxis()->SetNdivisions(10);
+ hEmpty->GetYaxis()->SetNdivisions(10);
+ hEmpty->GetXaxis()->SetTitleOffset(1.4);
+ hEmpty->GetYaxis()->SetTitleOffset(1.4);
+
+ TCanvas *c1 = new TCanvas("c1","",0,0,600,500);
+ c1->SetFillColor(10); c1->SetHighLightColor(10);
+ c1->SetLeftMargin(0.15); c1->SetBottomMargin(0.15);
+ hEmpty->GetXaxis()->SetTitle("N_{+}");
+ hEmpty->GetYaxis()->SetTitle("N_{-}");
+ hEmpty->GetXaxis()->SetRangeUser(0,1000);
+ hEmpty->GetYaxis()->SetRangeUser(0,1000);
+ hEmpty->DrawCopy();
+ for(Int_t iBin = 1; iBin <= nCentralityBins; iBin++)
+ gHistNPlusNMinus[iBin-1]->DrawCopy("same");
+
+ TCanvas *c2 = new TCanvas("c2","",600,0,600,500);
+ c2->SetFillColor(10); c2->SetHighLightColor(10);
+ c2->SetLeftMargin(0.15); c2->SetBottomMargin(0.15);
+ hEmpty->GetXaxis()->SetTitle("N_{tracks}");
+ hEmpty->GetYaxis()->SetTitle("Entries");
+ hEmpty->GetYaxis()->SetRangeUser(0,2000);
+ hEmpty->GetXaxis()->SetRangeUser(0,2000);
+ hEmpty->DrawCopy();
+ for(Int_t iBin = 1; iBin <= nCentralityBins; iBin++)
+ gHistNMultiplicity[iBin-1]->DrawCopy("esame");
+}
--- /dev/null
+//=======================================================================//
+//Macro to draw the main results of the charge fluctuation analysis:
+//=======================================================================//
+
+//+++++++++++++++++++++GLOBAL VARIABLES+++++++++++++++++++++//
+const Int_t nCentralityBins = 20;
+
+Double_t gNParticipants[nCentralityBins] = {382.646,329.213,280.911,238.617,201.81,169.339,141.067,116.208,94.2515,75.4558,59.4054,45.7565,34.4839,25.3127,18.0293,12.6535,8.84139,6.16348,4.37454,3.06182};
+Double_t gNParticipantsError[nCentralityBins] = {16.9428,18.0505,17.0971,16.2076,15.5418,14.9458,14.3174,13.9067,13.2661,12.6134,11.8133,11.0495,10.0939,8.99737,7.7884,6.48725,5.21602,3.91988,2.78741,1.75066};
+//Double_t gNParticipants[nCentralityBins] = {356.132,260.175,185.76,128.428,84.5666,52.3432,29.7072,15.2207,7.47192,3.71973};//10 bins
+//Double_t gNParticipantsError[nCentralityBins] = {31.8228,26.9093,22.3767,18.8802,15.9735,13.3103,10.5806,7.62745,4.78538,2.41942};//10 bins
+
+//================================ALICE================================//
+Double_t gNuDynALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNuDynALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+Double_t gNetChargeALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNetChargeALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+Double_t gNetChargeRmsALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNetChargeRmsALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+//================================ALICE================================//
+//+++++++++++++++++++++END OF VARIABLES+++++++++++++++++++++//
+
+//_____________________________________________________//
+void drawNpartDependence(const char*resultPath = "../LHC10h/Pass1_4Plus/20CentralityBins/") {
+ //Draws the nu_dyn vs centrality percentile
+ SetDataPoints(resultPath);
+ //================================================//
+ //ALICE PbPb @ 2.76 TeV
+ TGraphErrors *grALICEDataNudyn = new TGraphErrors(nCentralityBins,
+ gNParticipants,
+ gNuDynALICEData,
+ gNParticipantsError,
+ gNuDynALICEDataError);
+ grALICEDataNudyn->SetMarkerStyle(20);
+ grALICEDataNudyn->SetMarkerColor(2);
+
+ TGraphErrors *grALICEDataNetCharge = new TGraphErrors(nCentralityBins,
+ gNParticipants,
+ gNetChargeALICEData,
+ gNParticipantsError,
+ gNetChargeALICEDataError);
+ grALICEDataNetCharge->SetMarkerStyle(20);
+ grALICEDataNetCharge->SetMarkerColor(2);
+
+ TGraphErrors *grALICEDataNetChargeRms = new TGraphErrors(nCentralityBins,
+ gNParticipants,
+ gNetChargeRmsALICEData,
+ gNParticipantsError,
+ gNetChargeRmsALICEDataError);
+ grALICEDataNetChargeRms->SetMarkerStyle(20);
+ grALICEDataNetChargeRms->SetMarkerColor(2);
+
+ //_____________________________________________________//
+ //Draw the results
+ //_____________________________________________________//
+ TLatex *latex = new TLatex();
+ latex->SetTextSize(0.035);
+
+ //====================================//
+ //Results vs centrality
+ TH2F *gEmpty1 = new TH2F("gEmpty1",
+ ";N_{part.};",
+ 100,0,400,10000,-0.1,50.);
+ gEmpty1->SetStats(kFALSE);
+ gEmpty1->GetYaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetXaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetYaxis()->SetNdivisions(10);
+ gEmpty1->GetXaxis()->SetNdivisions(10);
+
+ TF1 *f1 = new TF1("f1","0",0,1000);
+ f1->SetLineColor(1); f1->SetLineStyle(3); f1->SetLineWidth(2);
+
+ //============================================================//
+ //nu_{dyn.}
+ TCanvas *c1 = new TCanvas("c1","Centrality dependence: nu_dyn",
+ 0,0,500,500);
+ c1->SetFillColor(10); c1->SetHighLightColor(10);
+ c1->SetLeftMargin(0.15); c1->SetBottomMargin(0.15);
+ c1->SetGridx(); c1->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(-0.08,0.01);
+ gEmpty1->GetYaxis()->SetTitle("#nu_{dyn.}");
+ gEmpty1->DrawCopy();
+ f1->Draw("same");
+ grALICEDataNudyn->Draw("P");
+
+ DrawMarker(40., 0.0043, 20, 1.6, 2);
+ latex->DrawLatex(50.,0.0033,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c1->SaveAs("NparticipantsDependenceNuDyn.png");
+
+ //============================================================//
+ //net charge
+ TCanvas *c2 = new TCanvas("c2","Centrality dependence: net charge",
+ 100,100,500,500);
+ c2->SetFillColor(10); c2->SetHighLightColor(10);
+ c2->SetLeftMargin(0.15); c2->SetBottomMargin(0.15);
+ c2->SetGridx(); c2->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,10.0);
+ gEmpty1->GetYaxis()->SetTitle("#LT #Delta Q = N_{+} - N_{-}#GT");
+ gEmpty1->DrawCopy();
+ grALICEDataNetCharge->Draw("P");
+
+ DrawMarker(40., 8.3, 20, 1.6, 2);
+ latex->DrawLatex(50.,8.1,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c2->SaveAs("NparticipantsDependenceNetCharge.png");
+
+ //============================================================//
+ //rms net charge
+ TCanvas *c3 = new TCanvas("c3","Centrality dependence: net charge rms",
+ 200,200,500,500);
+ c3->SetFillColor(10); c3->SetHighLightColor(10);
+ c3->SetLeftMargin(0.15); c3->SetBottomMargin(0.15);
+ c3->SetGridx(); c3->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,40.0);
+ gEmpty1->GetYaxis()->SetTitle("#sigma_{#Delta Q}");
+ gEmpty1->DrawCopy();
+ grALICEDataNetChargeRms->Draw("P");
+
+ DrawMarker(40., 38., 20, 1.6, 2);
+ latex->DrawLatex(50.,37.,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c3->SaveAs("NparticipantsDependenceNetChargeRms.png");
+}
+
+//_______________________________________________________________//
+void SetDataPoints(const char* resultPath) {
+ //Calculate the mean and the statistical error of the data points
+ const Int_t nRuns = 7;
+ Double_t nuDyn[nRuns][nCentralityBins];
+ Double_t gNetCharge[nRuns][nCentralityBins];
+ Double_t gNetChargeRms[nRuns][nCentralityBins];
+ Double_t nuDyn[nRuns][nCentralityBins];
+ Int_t nEvents[nRuns][nCentralityBins];
+ Int_t nRunNumbers[nRuns] = {137161,137431,137549,
+ 137595,137638,137639,137693};
+ Int_t gCentrality;
+ Double_t netChargeValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t netChargeValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.};
+ Double_t netChargeRmsValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.};
+ Double_t netChargeRmsValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.};
+ Double_t nuDynValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t nuDynValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t nEventsValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+
+ TString inputFileName;
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ ifstream inputAscii;
+ Printf("Adding run %d",nRunNumbers[iRun]);
+ inputFileName = resultPath;
+ inputFileName += "/output."; inputFileName += nRunNumbers[iRun];
+ inputFileName += ".txt";
+
+ Printf("Filename: %s",inputFileName.Data());
+ inputAscii.open(inputFileName.Data());
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ inputAscii>>gCentrality>>nuDyn[iRun][iCentrality]>>gNetCharge[iRun][iCentrality]>>gNetChargeRms[iRun][iCentrality]>>nEvents[iRun][iCentrality];
+ cout<<nuDyn[iRun][iCentrality]<<" "<<nEvents[iRun][iCentrality]<<endl;
+ }
+ inputAscii.close();
+ }
+
+ Int_t nRunCounter = 0;
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ nuDynValues[iCentrality] += nuDyn[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ netChargeValues[iCentrality] += gNetCharge[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ netChargeRmsValues[iCentrality] += gNetChargeRms[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ nEventsValues[iCentrality] += nEvents[iRun][iCentrality];
+ }
+
+ if(nEventsValues[iCentrality] != 0) {
+ nRunCounter += 1;
+
+ netChargeValues[iCentrality] /= nEventsValues[iCentrality];
+ netChargeRmsValues[iCentrality] /= nEventsValues[iCentrality];
+ nuDynValues[iCentrality] /= nEventsValues[iCentrality];
+ }
+ else {
+ netChargeValues[iCentrality] = 999.;
+ netChargeRmsValues[iCentrality] = 999.;
+ nuDynValues[iCentrality] = 999.;
+ }
+
+ gNetChargeALICEData[iCentrality] = netChargeValues[iCentrality];
+ gNetChargeRmsALICEData[iCentrality] = netChargeRmsValues[iCentrality];
+ gNuDynALICEData[iCentrality] = nuDynValues[iCentrality];
+ }
+
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ netChargeValuesError[iCentrality] += TMath::Power((netChargeValues[iCentrality]-gNetCharge[iRun][iCentrality]),2);
+ netChargeRmsValuesError[iCentrality] += TMath::Power((netChargeRmsValues[iCentrality]-gNetChargeRms[iRun][iCentrality]),2);
+ nuDynValuesError[iCentrality] += TMath::Power((nuDynValues[iCentrality]-nuDyn[iRun][iCentrality]),2);
+ }
+ gNetChargeALICEDataError[iCentrality] = TMath::Sqrt(netChargeValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)));
+ gNetChargeRmsALICEDataError[iCentrality] = TMath::Sqrt(netChargeRmsValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)));
+ gNuDynALICEDataError[iCentrality] = TMath::Sqrt(nuDynValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)));
+ Printf("Centrality: %d - nu_dyn: %lf +- %lf - Net charge: %lf +- %lf - RMS: %lf - %lf",iCentrality+1,
+ gNuDynALICEData[iCentrality],
+ gNuDynALICEDataError[iCentrality],
+ gNetChargeALICEData[iCentrality],
+ gNetChargeALICEDataError[iCentrality],
+ gNetChargeRmsALICEData[iCentrality],
+ gNetChargeRmsALICEDataError[iCentrality]);
+ }
+
+}
+
+
+//_______________________________________________________________//
+void DrawMarker(Double_t x, Double_t y, Int_t style,
+ Double_t size, Int_t color) {
+ TMarker *m = new TMarker(x,y,style);
+ m->SetMarkerSize(size);
+ m->SetMarkerColor(color);
+ m->Draw();
+}
--- /dev/null
+//=======================================================================//
+//Macro to draw the main results of the charge fluctuation analysis:
+//=======================================================================//
+
+//+++++++++++++++++++++GLOBAL VARIABLES+++++++++++++++++++++//
+const Int_t nCentralityBins = 20;
+
+Double_t gNParticipants[nCentralityBins] = {382.646,329.213,280.911,238.617,201.81,169.339,141.067,116.208,94.2515,75.4558,59.4054,45.7565,34.4839,25.3127,18.0293,12.6535,8.84139,6.16348,4.37454,3.06182};
+Double_t gNParticipantsError[nCentralityBins] = {16.9428,18.0505,17.0971,16.2076,15.5418,14.9458,14.3174,13.9067,13.2661,12.6134,11.8133,11.0495,10.0939,8.99737,7.7884,6.48725,5.21602,3.91988,2.78741,1.75066};
+//Double_t gNParticipants[nCentralityBins] = {356.132,260.175,185.76,128.428,84.5666,52.3432,29.7072,15.2207,7.47192,3.71973};//10 bins
+//Double_t gNParticipantsError[nCentralityBins] = {31.8228,26.9093,22.3767,18.8802,15.9735,13.3103,10.5806,7.62745,4.78538,2.41942};//10 bins
+
+//================================ALICE================================//
+Double_t gNuDynALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNuDynALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+Double_t gNetChargeALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNetChargeALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+Double_t gNetChargeRmsALICEData[nCentralityBins] = {10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.,10.};
+Double_t gNetChargeRmsALICEDataError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+//================================ALICE================================//
+//+++++++++++++++++++++END OF VARIABLES+++++++++++++++++++++//
+
+//_____________________________________________________//
+void drawScaledNpartDependence(const char*resultPath = "../LHC10h/Pass1_4Plus/20CentralityBins/") {
+ //Draws the nu_dyn vs centrality percentile
+ SetDataPoints(resultPath);
+ //================================================//
+ //ALICE PbPb @ 2.76 TeV
+ TGraphErrors *grALICEDataNudyn = new TGraphErrors(nCentralityBins,
+ gNParticipants,
+ gNuDynALICEData,
+ gNParticipantsError,
+ gNuDynALICEDataError);
+ grALICEDataNudyn->SetMarkerStyle(20);
+ grALICEDataNudyn->SetMarkerColor(2);
+
+ TGraphErrors *grALICEDataNetCharge = new TGraphErrors(nCentralityBins,
+ gNParticipants,
+ gNetChargeALICEData,
+ gNParticipantsError,
+ gNetChargeALICEDataError);
+ grALICEDataNetCharge->SetMarkerStyle(20);
+ grALICEDataNetCharge->SetMarkerColor(2);
+
+ TGraphErrors *grALICEDataNetChargeRms = new TGraphErrors(nCentralityBins,
+ gNParticipants,
+ gNetChargeRmsALICEData,
+ gNParticipantsError,
+ gNetChargeRmsALICEDataError);
+ grALICEDataNetChargeRms->SetMarkerStyle(20);
+ grALICEDataNetChargeRms->SetMarkerColor(2);
+
+ //_____________________________________________________//
+ //Draw the results
+ //_____________________________________________________//
+ TLatex *latex = new TLatex();
+ latex->SetTextSize(0.035);
+
+ //====================================//
+ //Results vs centrality
+ TH2F *gEmpty1 = new TH2F("gEmpty1",
+ ";N_{part.};",
+ 100,0,400,10000,-2.,1.);
+ gEmpty1->SetStats(kFALSE);
+ gEmpty1->GetYaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetXaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetYaxis()->SetNdivisions(10);
+ gEmpty1->GetXaxis()->SetNdivisions(10);
+
+ TF1 *f1 = new TF1("f1","0",0,1000);
+ f1->SetLineColor(1); f1->SetLineStyle(3); f1->SetLineWidth(2);
+
+ //============================================================//
+ //nu_{dyn.}
+ TCanvas *c1 = new TCanvas("c1","Centrality dependence: nu_dyn",
+ 0,0,500,500);
+ c1->SetFillColor(10); c1->SetHighLightColor(10);
+ c1->SetLeftMargin(0.15); c1->SetBottomMargin(0.15);
+ c1->SetGridx(); c1->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(-2.,0.0);
+ gEmpty1->GetYaxis()->SetTitle("#nu_{dyn.} #times N_{part.}");
+ gEmpty1->DrawCopy();
+ f1->Draw("same");
+ grALICEDataNudyn->Draw("P");
+
+ DrawMarker(40., 0.0043, 20, 1.6, 2);
+ latex->DrawLatex(50.,0.0033,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c1->SaveAs("scaledNparticipantsDependenceNuDyn.png");
+
+ //============================================================//
+ //net charge
+ TCanvas *c2 = new TCanvas("c2","Centrality dependence: net charge",
+ 100,100,500,500);
+ c2->SetFillColor(10); c2->SetHighLightColor(10);
+ c2->SetLeftMargin(0.15); c2->SetBottomMargin(0.15);
+ c2->SetGridx(); c2->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,0.05);
+ gEmpty1->GetYaxis()->SetTitle("#LT #Delta Q = N_{+} - N_{-}#GT/N_{part.}");
+ gEmpty1->DrawCopy();
+ grALICEDataNetCharge->Draw("P");
+
+ DrawMarker(40., 8.3, 20, 1.6, 2);
+ latex->DrawLatex(50.,8.1,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c2->SaveAs("scaledNparticipantsDependenceNetCharge.png");
+
+ //============================================================//
+ //rms net charge
+ TCanvas *c3 = new TCanvas("c3","Centrality dependence: net charge rms",
+ 200,200,500,500);
+ c3->SetFillColor(10); c3->SetHighLightColor(10);
+ c3->SetLeftMargin(0.15); c3->SetBottomMargin(0.15);
+ c3->SetGridx(); c3->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,0.6);
+ gEmpty1->GetYaxis()->SetTitle("#sigma_{#Delta Q}/N_{part.}");
+ gEmpty1->DrawCopy();
+ grALICEDataNetChargeRms->Draw("P");
+
+ DrawMarker(40., 38., 20, 1.6, 2);
+ latex->DrawLatex(50.,37.,"PbPb @ #sqrt{s_{NN}} = 2.76 TeV");
+
+ c3->SaveAs("scaledNparticipantsDependenceNetChargeRms.png");
+}
+
+//_______________________________________________________________//
+void SetDataPoints(const char* resultPath) {
+ //Calculate the mean and the statistical error of the data points
+ const Int_t nRuns = 7;
+ Double_t nuDyn[nRuns][nCentralityBins];
+ Double_t gNetCharge[nRuns][nCentralityBins];
+ Double_t gNetChargeRms[nRuns][nCentralityBins];
+ Double_t nuDyn[nRuns][nCentralityBins];
+ Int_t nEvents[nRuns][nCentralityBins];
+ Int_t nRunNumbers[nRuns] = {137161,137431,137549,
+ 137595,137638,137639,137693};
+ Int_t gCentrality;
+ Double_t netChargeValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t netChargeValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.};
+ Double_t netChargeRmsValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.};
+ Double_t netChargeRmsValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.};
+ Double_t nuDynValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t nuDynValuesError[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ Double_t nEventsValues[nCentralityBins] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,
+ 0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+
+ TString inputFileName;
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ ifstream inputAscii;
+ Printf("Adding run %d",nRunNumbers[iRun]);
+ inputFileName = resultPath;
+ inputFileName += "/output."; inputFileName += nRunNumbers[iRun];
+ inputFileName += ".txt";
+
+ Printf("Filename: %s",inputFileName.Data());
+ inputAscii.open(inputFileName.Data());
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ inputAscii>>gCentrality>>nuDyn[iRun][iCentrality]>>gNetCharge[iRun][iCentrality]>>gNetChargeRms[iRun][iCentrality]>>nEvents[iRun][iCentrality];
+ cout<<nuDyn[iRun][iCentrality]<<" "<<nEvents[iRun][iCentrality]<<endl;
+ }
+ inputAscii.close();
+ }
+
+ Int_t nRunCounter = 0;
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ nuDynValues[iCentrality] += nuDyn[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ netChargeValues[iCentrality] += gNetCharge[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ netChargeRmsValues[iCentrality] += gNetChargeRms[iRun][iCentrality]*nEvents[iRun][iCentrality];
+ nEventsValues[iCentrality] += nEvents[iRun][iCentrality];
+ }
+
+ if(nEventsValues[iCentrality] != 0) {
+ nRunCounter += 1;
+
+ netChargeValues[iCentrality] /= nEventsValues[iCentrality];
+ netChargeRmsValues[iCentrality] /= nEventsValues[iCentrality];
+ nuDynValues[iCentrality] /= nEventsValues[iCentrality];
+ }
+ else {
+ netChargeValues[iCentrality] = 999.;
+ netChargeRmsValues[iCentrality] = 999.;
+ nuDynValues[iCentrality] = 999.;
+ }
+
+ gNetChargeALICEData[iCentrality] = netChargeValues[iCentrality]/gNParticipants[iCentrality];
+ gNetChargeRmsALICEData[iCentrality] = netChargeRmsValues[iCentrality]/gNParticipants[iCentrality];;
+ gNuDynALICEData[iCentrality] = nuDynValues[iCentrality]*gNParticipants[iCentrality];
+ }
+
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ for(Int_t iRun = 0; iRun < nRuns; iRun++) {
+ netChargeValuesError[iCentrality] += TMath::Power((netChargeValues[iCentrality]-gNetCharge[iRun][iCentrality]),2);
+ netChargeRmsValuesError[iCentrality] += TMath::Power((netChargeRmsValues[iCentrality]-gNetChargeRms[iRun][iCentrality]),2);
+ nuDynValuesError[iCentrality] += TMath::Power((nuDynValues[iCentrality]-nuDyn[iRun][iCentrality]),2);
+ }
+ gNetChargeALICEDataError[iCentrality] = TMath::Sqrt(netChargeValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)))/gNParticipants[iCentrality];
+ gNetChargeRmsALICEDataError[iCentrality] = TMath::Sqrt(netChargeRmsValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)))/gNParticipants[iCentrality];
+ gNuDynALICEDataError[iCentrality] = TMath::Sqrt(nuDynValuesError[iCentrality]/(nRunCounter*(nRunCounter-1)));
+ Printf("Centrality: %d - nu_dyn: %lf +- %lf - Net charge: %lf +- %lf - RMS: %lf - %lf",iCentrality+1,
+ gNuDynALICEData[iCentrality],
+ gNuDynALICEDataError[iCentrality],
+ gNetChargeALICEData[iCentrality],
+ gNetChargeALICEDataError[iCentrality],
+ gNetChargeRmsALICEData[iCentrality],
+ gNetChargeRmsALICEDataError[iCentrality]);
+ }
+
+}
+
+
+//_______________________________________________________________//
+void DrawMarker(Double_t x, Double_t y, Int_t style,
+ Double_t size, Int_t color) {
+ TMarker *m = new TMarker(x,y,style);
+ m->SetMarkerSize(size);
+ m->SetMarkerColor(color);
+ m->Draw();
+}
--- /dev/null
+//=======================================================================//
+//Macro to draw the main results of the charge fluctuation analysis:
+//=======================================================================//
+
+//+++++++++++++++++++++GLOBAL VARIABLES+++++++++++++++++++++//
+const Int_t nCentralityBins = 10;
+Double_t gCentralityPercentileSet1[nCentralityBins];
+Double_t gCentralityPercentileSet2[nCentralityBins];
+Double_t gCentralityPercentileSet3[nCentralityBins];
+Double_t gCentralityPercentileError[nCentralityBins];
+
+//================================ALICE================================//
+Double_t gNuDynALICEDataSet1[nCentralityBins];
+Double_t gNuDynALICEDataSet1Error[nCentralityBins];
+Double_t gNuDynALICEDataSet2[nCentralityBins];
+Double_t gNuDynALICEDataSet2Error[nCentralityBins];
+Double_t gNuDynALICEDataSet3[nCentralityBins];
+Double_t gNuDynALICEDataSet3Error[nCentralityBins];
+
+Double_t gNetChargeALICEDataSet1[nCentralityBins];
+Double_t gNetChargeALICEDataSet1Error[nCentralityBins];
+Double_t gNetChargeALICEDataSet2[nCentralityBins];
+Double_t gNetChargeALICEDataSet2Error[nCentralityBins];
+Double_t gNetChargeALICEDataSet3[nCentralityBins];
+Double_t gNetChargeALICEDataSet3Error[nCentralityBins];
+
+Double_t gNetChargeRmsALICEDataSet1[nCentralityBins];
+Double_t gNetChargeRmsALICEDataSet1Error[nCentralityBins];
+Double_t gNetChargeRmsALICEDataSet2[nCentralityBins];
+Double_t gNetChargeRmsALICEDataSet2Error[nCentralityBins];
+Double_t gNetChargeRmsALICEDataSet3[nCentralityBins];
+Double_t gNetChargeRmsALICEDataSet3Error[nCentralityBins];
+//================================ALICE================================//
+//+++++++++++++++++++++END OF VARIABLES+++++++++++++++++++++//
+
+//_____________________________________________________//
+void drawSystematics(const char* resultsPath) {
+ //Draws the nu_dyn vs centrality percentile
+ for(Int_t i = 0; i < nCentralityBins; i++) {
+ if(nCentralityBins == 20) {
+ gCentralityPercentileSet1[i] = 1.0 + i*5.0;
+ gCentralityPercentileSet2[i] = 2.5 + i*5.0;
+ gCentralityPercentileSet3[i] = 4.0 + i*5.0;
+ }
+ if(nCentralityBins == 10) {
+ gCentralityPercentileSet1[i] = 3.0 + i*10.0;
+ gCentralityPercentileSet2[i] = 5.0 + i*10.0;
+ gCentralityPercentileSet3[i] = 7.0 + i*10.0;
+ }
+ gCentralityPercentileError[i] = 0.5;
+ }
+
+ SetDataPoints(resultsPath);
+
+ //================================================//
+ //ALICE PbPb @ 2.76 TeV
+ //Nu dyn
+ TGraphErrors *grNuDynALICEDataSet1 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet1,
+ gNuDynALICEDataSet1,
+ gCentralityPercentileError,
+ gNuDynALICEDataSet1Error);
+ grNuDynALICEDataSet1->SetMarkerStyle(20);
+ grNuDynALICEDataSet1->SetMarkerColor(4);
+
+ TGraphErrors *grNuDynALICEDataSet2 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet2,
+ gNuDynALICEDataSet2,
+ gCentralityPercentileError,
+ gNuDynALICEDataSet2Error);
+ grNuDynALICEDataSet2->SetMarkerStyle(25);
+ grNuDynALICEDataSet2->SetMarkerColor(2);
+
+ TGraphErrors *grNuDynALICEDataSet3 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet3,
+ gNuDynALICEDataSet3,
+ gCentralityPercentileError,
+ gNuDynALICEDataSet3Error);
+ grNuDynALICEDataSet3->SetMarkerStyle(29);
+ grNuDynALICEDataSet3->SetMarkerColor(3);
+
+ //Net charge
+ TGraphErrors *grNetChargeALICEDataSet1 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet1,
+ gNetChargeALICEDataSet1,
+ gCentralityPercentileError,
+ gNetChargeALICEDataSet1Error);
+ grNetChargeALICEDataSet1->SetMarkerStyle(20);
+ grNetChargeALICEDataSet1->SetMarkerColor(4);
+
+ TGraphErrors *grNetChargeALICEDataSet2 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet2,
+ gNetChargeALICEDataSet2,
+ gCentralityPercentileError,
+ gNetChargeALICEDataSet2Error);
+ grNetChargeALICEDataSet2->SetMarkerStyle(25);
+ grNetChargeALICEDataSet2->SetMarkerColor(2);
+
+ TGraphErrors *grNetChargeALICEDataSet3 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet3,
+ gNetChargeALICEDataSet3,
+ gCentralityPercentileError,
+ gNetChargeALICEDataSet3Error);
+ grNetChargeALICEDataSet3->SetMarkerStyle(29);
+ grNetChargeALICEDataSet3->SetMarkerColor(3);
+
+ //Net charge rms
+ TGraphErrors *grNetChargeRmsALICEDataSet1 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet1,
+ gNetChargeRmsALICEDataSet1,
+ gCentralityPercentileError,
+ gNetChargeRmsALICEDataSet1Error);
+ grNetChargeRmsALICEDataSet1->SetMarkerStyle(20);
+ grNetChargeRmsALICEDataSet1->SetMarkerColor(4);
+
+ TGraphErrors *grNetChargeRmsALICEDataSet2 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet2,
+ gNetChargeRmsALICEDataSet2,
+ gCentralityPercentileError,
+ gNetChargeRmsALICEDataSet2Error);
+ grNetChargeRmsALICEDataSet2->SetMarkerStyle(25);
+ grNetChargeRmsALICEDataSet2->SetMarkerColor(2);
+
+ TGraphErrors *grNetChargeRmsALICEDataSet3 = new TGraphErrors(nCentralityBins,
+ gCentralityPercentileSet3,
+ gNetChargeRmsALICEDataSet3,
+ gCentralityPercentileError,
+ gNetChargeRmsALICEDataSet3Error);
+ grNetChargeRmsALICEDataSet3->SetMarkerStyle(29);
+ grNetChargeRmsALICEDataSet3->SetMarkerColor(3);
+
+ //_____________________________________________________//
+ //Draw the results
+ //_____________________________________________________//
+ TLatex *latex = new TLatex();
+ latex->SetTextSize(0.035);
+
+ //====================================//
+ //results vs centrality
+ TH2F *gEmpty1 = new TH2F("gEmpty1",
+ ";Centrality percentile;",
+ nCentralityBins,0,100,10000,-0.1,50.);
+ gEmpty1->SetStats(kFALSE);
+ gEmpty1->GetYaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetXaxis()->SetTitleOffset(1.5);
+ gEmpty1->GetYaxis()->SetNdivisions(10);
+ gEmpty1->GetXaxis()->SetNdivisions(10);
+
+ TF1 *f1 = new TF1("f1","0",0,1000);
+ f1->SetLineColor(1); f1->SetLineStyle(3); f1->SetLineWidth(2);
+
+ //============================================================//
+ //nu_{dyn.}
+ TCanvas *c1 = new TCanvas("c1","Centrality dependence: nu_dyn",
+ 0,0,500,500);
+ c1->SetFillColor(10); c1->SetHighLightColor(10);
+ c1->SetLeftMargin(0.15); c1->SetBottomMargin(0.15);
+ c1->SetGridx(); c1->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(-0.08,0.01);
+ gEmpty1->GetYaxis()->SetTitle("#nu_{dyn.}");
+ gEmpty1->DrawCopy();
+ f1->Draw("same");
+ grNuDynALICEDataSet1->Draw("P");
+ grNuDynALICEDataSet2->Draw("P");
+ grNuDynALICEDataSet3->Draw("P");
+
+ DrawMarker(7., -0.053, 20, 1.6, 1);
+ DrawMarker(7., -0.058, 25, 1.6, 2);
+ DrawMarker(7., -0.063, 29, 1.6, 3);
+ latex->DrawLatex(12.,-0.0545,"V0");
+ latex->DrawLatex(12.,-0.0595,"TPC tracks");
+ latex->DrawLatex(12.,-0.0645,"SPD clusters");
+
+ c1->SaveAs("systematicsCentralityPercentileDependenceNuDyn.png");
+
+ //============================================================//
+ //net charge
+ TCanvas *c2 = new TCanvas("c2","Centrality dependence: net charge",
+ 100,100,500,500);
+ c2->SetFillColor(10); c2->SetHighLightColor(10);
+ c2->SetLeftMargin(0.15); c2->SetBottomMargin(0.15);
+ c2->SetGridx(); c2->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,10.0);
+ gEmpty1->GetYaxis()->SetTitle("#LT #Delta Q = N_{+} - N_{-}#GT");
+ gEmpty1->DrawCopy();
+ grNetChargeALICEDataSet1->Draw("P");
+ grNetChargeALICEDataSet2->Draw("P");
+ grNetChargeALICEDataSet3->Draw("P");
+
+ DrawMarker(47., 9.0, 20, 1.6, 1);
+ DrawMarker(47., 8.0, 25, 1.6, 2);
+ DrawMarker(47., 7.0, 29, 1.6, 3);
+ latex->DrawLatex(52.,8.8,"V0");
+ latex->DrawLatex(52.,7.8,"TPC tracks");
+ latex->DrawLatex(52.,6.8,"SPD clusters");
+
+ c2->SaveAs("systematicsCentralityPercentileDependenceNetCharge.png");
+
+ //============================================================//
+ //net charge
+ TCanvas *c3 = new TCanvas("c3","Centrality dependence: net charge rms",
+ 200,200,500,500);
+ c3->SetFillColor(10); c3->SetHighLightColor(10);
+ c3->SetLeftMargin(0.15); c3->SetBottomMargin(0.15);
+ c3->SetGridx(); c3->SetGridy();
+ gEmpty1->GetYaxis()->SetRangeUser(0.0,40.0);
+ gEmpty1->GetYaxis()->SetTitle("#sigma_{#Delta Q}");
+ gEmpty1->DrawCopy();
+ grNetChargeRmsALICEDataSet1->Draw("P");
+ grNetChargeRmsALICEDataSet2->Draw("P");
+ grNetChargeRmsALICEDataSet3->Draw("P");
+
+ DrawMarker(47., 37., 20, 1.6, 1);
+ DrawMarker(47., 35., 25, 1.6, 2);
+ DrawMarker(47., 33., 29, 1.6, 3);
+ latex->DrawLatex(52.,36.,"V0");
+ latex->DrawLatex(52.,34.,"TPC tracks");
+ latex->DrawLatex(52.,32,"SPD clusters");
+
+ c3->SaveAs("systematicsCentralityPercentileDependenceNetChargeRms.png");
+}
+
+//_______________________________________________________________//
+void SetDataPoints(const char* resultsPath) {
+ //Calculate the mean and the statistical error of the data points
+
+ TString inputFileName;
+ Int_t gCentrality = 0;
+
+ //Set 1
+ ifstream inputAscii1;
+ inputFileName = resultsPath; inputFileName += "V0/output.txt";
+ inputAscii1.open(inputFileName.Data());
+
+ //Set 2
+ ifstream inputAscii2;
+ inputFileName = resultsPath; inputFileName += "TPC/output.txt";
+ inputAscii2.open(inputFileName.Data());
+
+ //Set 3
+ ifstream inputAscii3;
+ inputFileName = resultsPath; inputFileName += "SPDClusters/output.txt";
+ inputAscii3.open(inputFileName.Data());
+
+ for(Int_t iCentrality = 0; iCentrality < nCentralityBins; iCentrality++) {
+ inputAscii1>>gCentrality>>gNuDynALICEDataSet1[iCentrality]>>gNuDynALICEDataSet1Error[iCentrality]>>gNetChargeALICEDataSet1[iCentrality]>>gNetChargeALICEDataSet1Error[iCentrality]>>gNetChargeRmsALICEDataSet1[iCentrality]>>gNetChargeRmsALICEDataSet1Error[iCentrality];
+ inputAscii2>>gCentrality>>gNuDynALICEDataSet2[iCentrality]>>gNuDynALICEDataSet2Error[iCentrality]>>gNetChargeALICEDataSet2[iCentrality]>>gNetChargeALICEDataSet2Error[iCentrality]>>gNetChargeRmsALICEDataSet2[iCentrality]>>gNetChargeRmsALICEDataSet2Error[iCentrality];
+ inputAscii3>>gCentrality>>gNuDynALICEDataSet3[iCentrality]>>gNuDynALICEDataSet3Error[iCentrality]>>gNetChargeALICEDataSet3[iCentrality]>>gNetChargeALICEDataSet3Error[iCentrality]>>gNetChargeRmsALICEDataSet3[iCentrality]>>gNetChargeRmsALICEDataSet3Error[iCentrality];
+
+ }
+ inputAscii1.close();
+
+}
+
+
+//_______________________________________________________________//
+void DrawMarker(Double_t x, Double_t y, Int_t style,
+ Double_t size, Int_t color) {
+ TMarker *m = new TMarker(x,y,style);
+ m->SetMarkerSize(size);
+ m->SetMarkerColor(color);
+ m->Draw();
+}
fMaxDCAXY(0.), fMaxDCAXYTPC(0.),
fMaxDCAZ(0.), fMaxDCAZTPC(0.),
fMaxDCA3D(0.), fMaxDCA3DTPC(0.),
- fMaxConstrainChi2(0), fMinTPCdEdxPoints(0),
+ fMaxConstrainChi2(0.), fMinTPCdEdxPoints(0),
fMinTPCClustersFlag(kFALSE), fMinITSClustersFlag(kFALSE),
fMaxChi2PerTPCClusterFlag(kFALSE), fMaxChi2PerITSClusterFlag(kFALSE),
fMaxCov11Flag(kFALSE), fMaxCov22Flag(kFALSE),
fPointOnITSLayer3Flag(0), fPointOnITSLayer4Flag(0),
fPointOnITSLayer5Flag(0), fPointOnITSLayer6Flag(0),
fMinTPCdEdxPointsFlag(kFALSE),
- fPtDependentDcaXY(0), fPtDependentDcaXYFlag(kFALSE), fNSigmaDCAXY(0.0),
+ fPtDependentDcaXY(0), fPtDependentDcaXYFlag(kFALSE), fNSigmaDCAXY(0),
fFunctionProbabilityFlag(kFALSE),
- fNSigma(0), fNRatio(0),
+ fNSigma(0), fNRatio(0.),
fElectronFunction(0), fMuonFunction(0),
fPionFunction(0), fKaonFunction(0), fProtonFunction(0),
fDebugMode(kFALSE), fListVertexQA(0) {
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff