Cosmetics (Dont printout ecm method type if it does not change.)
[u/mrichter/AliRoot.git] / FASTSIM / AliFastGlauber.cxx
CommitLineData
5b3a5a5d 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
88cb7938 16/* $Id$ */
041f7f97 17//
65aa45f2 18// Utility class to make simple Glauber type calculations
19// for SYMMTRIC collision geometries (AA):
041f7f97 20// Impact parameter, production points, reaction plane dependence
65aa45f2 21//
041f7f97 22// The SimulateTrigger method can be used for simple MB and hard-process
23// (binary scaling) trigger studies.
65aa45f2 24//
041f7f97 25// Some basic quantities can be visualized directly.
041f7f97 26//
65aa45f2 27// The default set-up for PbPb or AUAu collisions can be read from a file
28// calling Init(1) or Init(2) if you want to read Almonds too.
29//
30// ***** If you change settings dont forget to call init afterwards, *****
31// ***** in order to update the formulas with the new parameters. *****
041f7f97 32//
33// Author: andreas.morsch@cern.ch
65aa45f2 34//=================== Added by A. Dainese 11/02/04 ===========================
35// Calculate path length for a parton with production point (x0,y0)
36// and propagation direction (ux=cos(phi0),uy=sin(phi0))
37// in a collision with impact parameter b and functions that make use
38// of it.
39//=================== Added by A. Dainese 05/03/04 ===========================
40// Calculation of line integrals I0 and I1
41// integral0 = \int_0^ellCut dl*(T_A*T_B)(x0+l*ux,y0+l*uy)
42// integral1 = \int_0^ellCut dl*l*(T_A*T_B)(x0+l*ux,y0+l*uy)
43// mostly for use in the Quenching class
44//=================== Added by C. Loizdes 27/03/04 ===========================
45// Handling of AuAu collisions
46// More get/set functions
47// Comments, units and clearing of code
48//
5b3a5a5d 49
50// from AliRoot
51#include "AliFastGlauber.h"
52// from root
a2f2f511 53#include <TStyle.h>
5b3a5a5d 54#include <TH1F.h>
a2f2f511 55#include <TH2F.h>
5b3a5a5d 56#include <TF1.h>
57#include <TF2.h>
65aa45f2 58#include <TLegend.h>
5b3a5a5d 59#include <TCanvas.h>
60#include <TRandom.h>
61#include <TFile.h>
65aa45f2 62#include <TROOT.h>
63#include <Riostream.h>
5b3a5a5d 64
65ClassImp(AliFastGlauber)
66
65aa45f2 67Float_t AliFastGlauber::fgBMax = 0.;
041f7f97 68TF1* AliFastGlauber::fgWSb = NULL;
69TF2* AliFastGlauber::fgWSbz = NULL;
70TF1* AliFastGlauber::fgWSz = NULL;
71TF1* AliFastGlauber::fgWSta = NULL;
72TF2* AliFastGlauber::fgWStarfi = NULL;
73TF2* AliFastGlauber::fgWAlmond = NULL;
74TF1* AliFastGlauber::fgWStaa = NULL;
75TF1* AliFastGlauber::fgWSgeo = NULL;
76TF1* AliFastGlauber::fgWSbinary = NULL;
77TF1* AliFastGlauber::fgWSN = NULL;
78TF1* AliFastGlauber::fgWPathLength0 = NULL;
79TF1* AliFastGlauber::fgWPathLength = NULL;
80TF1* AliFastGlauber::fgWEnergyDensity = NULL;
81TF1* AliFastGlauber::fgWIntRadius = NULL;
1bc228f5 82TF2* AliFastGlauber::fgWKParticipants = NULL;
83TF1* AliFastGlauber::fgWParticipants = NULL;
65aa45f2 84TF2* AliFastGlauber::fgWAlmondCurrent = NULL;
85TF2 AliFastGlauber::fgWAlmondFixedB[40];
86const Int_t AliFastGlauber::fgkMCInts = 100000;
87Int_t AliFastGlauber::fgCounter = 0;
5b3a5a5d 88
65aa45f2 89AliFastGlauber::AliFastGlauber() : fName()
5b3a5a5d 90{
65aa45f2 91 // Default Constructor
92 //
93 fgCounter++;
94 if(fgCounter>1)
95 Error("AliFastGlauber","More than more instance (%d) is not supported, check your code!",fgCounter);
96
97 // Defaults for Pb
98 SetMaxImpact();
99 SetLengthDefinition();
100 SetPbPbLHC();
101}
102
103AliFastGlauber::~AliFastGlauber()
104{
105 fgCounter--;
106 // if(fgCounter==0) Reset();
107}
108
109void AliFastGlauber::SetAuAuRhic()
110{
111 //Set all parameters for RHIC
112 SetWoodSaxonParametersAu();
113 SetHardCrossSection();
114 SetNNCrossSection(40);
115 SetNucleus(197);
116 SetFileName("$(ALICE_ROOT)/FASTSIM/data/glauberAuAu.root");
117}
118
119void AliFastGlauber::SetPbPbLHC()
120{
121 //Set all parameters for LHC
122 SetWoodSaxonParametersPb();
123 SetHardCrossSection();
124 SetNNCrossSection();
125 SetNucleus();
126 SetFileName();
5b3a5a5d 127}
128
129void AliFastGlauber::Init(Int_t mode)
130{
65aa45f2 131 // Initialisation
132 // mode = 0; all functions are calculated
133 // mode = 1; overlap function is read from file (for Pb-Pb only)
134 // mode = 2; interaction almond functions are read from file
135 // USE THIS FOR PATH LENGTH CALC.!
136 //
a2f2f511 137
65aa45f2 138 //
139 Reset();
140 //
5b3a5a5d 141
65aa45f2 142 //
143 // Wood-Saxon
144 //
145 fgWSb = new TF1("WSb", WSb, 0, fgBMax, 4);
146 fgWSb->SetParameter(0, fWSr0);
147 fgWSb->SetParameter(1, fWSd);
148 fgWSb->SetParameter(2, fWSw);
149 fgWSb->SetParameter(3, fWSn);
150
151 fgWSbz = new TF2("WSbz", WSbz, 0, fgBMax, 4);
152 fgWSbz->SetParameter(0, fWSr0);
153 fgWSbz->SetParameter(1, fWSd);
154 fgWSbz->SetParameter(2, fWSw);
155 fgWSbz->SetParameter(3, fWSn);
156
157 fgWSz = new TF1("WSz", WSz, 0, fgBMax, 5);
158 fgWSz->SetParameter(0, fWSr0);
159 fgWSz->SetParameter(1, fWSd);
160 fgWSz->SetParameter(2, fWSw);
161 fgWSz->SetParameter(3, fWSn);
162
163 //
164 // Thickness
165 //
166 fgWSta = new TF1("WSta", WSta, 0., fgBMax, 0);
5b3a5a5d 167
65aa45f2 168 //
169 // Overlap Kernel
170 //
171 fgWStarfi = new TF2("WStarfi", WStarfi, 0., fgBMax, 0., TMath::Pi(), 1);
172 fgWStarfi->SetParameter(0, 0.);
173 fgWStarfi->SetNpx(200);
174 fgWStarfi->SetNpy(20);
8de7e046 175
65aa45f2 176 //
177 // Participants Kernel
178 //
179 fgWKParticipants = new TF2("WKParticipants", WKParticipants, 0., fgBMax, 0., TMath::Pi(), 3);
180 fgWKParticipants->SetParameter(0, 0.);
181 fgWKParticipants->SetParameter(1, fSigmaNN);
182 fgWKParticipants->SetParameter(2, fA);
183 fgWKParticipants->SetNpx(200);
184 fgWKParticipants->SetNpy(20);
f3a04204 185
65aa45f2 186 //
187 // Overlap and Participants
188 //
189 if (!mode) {
190 fgWStaa = new TF1("WStaa", WStaa, 0., fgBMax, 1);
191 fgWStaa->SetNpx(100);
192 fgWStaa->SetParameter(0,fA);
193 fgWStaa->SetNpx(100);
194 fgWParticipants = new TF1("WParticipants", WParticipants, 0., fgBMax, 2);
195 fgWParticipants->SetParameter(0, fSigmaNN);
196 fgWParticipants->SetParameter(1, fA);
197 fgWParticipants->SetNpx(100);
198 } else {
199 Info("Init","Reading overlap function from file %s",fName.Data());
200 TFile* f = new TFile(fName.Data());
201 if(!f->IsOpen()){
202 Fatal("Init", "Could not open file %s",fName.Data());
203 }
204 fgWStaa = (TF1*) f->Get("WStaa");
205 fgWParticipants = (TF1*) f->Get("WParticipants");
206 delete f;
207 }
2a103154 208
65aa45f2 209 //
210 // Energy Density
211 //
212 fgWEnergyDensity = new TF1("WEnergyDensity", WEnergyDensity, 0., 2. * fWSr0, 1);
213 fgWEnergyDensity->SetParameter(0, fWSr0 + 1.);
214
215 //
216 // Geometrical Cross-Section
217 //
218 fgWSgeo = new TF1("WSgeo", WSgeo, 0., fgBMax, 1);
219 fgWSgeo->SetParameter(0,fSigmaNN); //mbarn
220 fgWSgeo->SetNpx(100);
2a103154 221
65aa45f2 222 //
223 // Hard cross section (binary collisions)
224 //
225 fgWSbinary = new TF1("WSbinary", WSbinary, 0., fgBMax, 1);
226 fgWSbinary->SetParameter(0, fSigmaHard); //mbarn
227 fgWSbinary->SetNpx(100);
1bc228f5 228
65aa45f2 229 //
230 // Hard collisions per event
231 //
232 fgWSN = new TF1("WSN", WSN, 0., fgBMax, 1);
233 fgWSN->SetNpx(100);
234
235 //
236 // Almond shaped interaction region
237 //
238 fgWAlmond = new TF2("WAlmond", WAlmond, -fgBMax, fgBMax, -fgBMax, fgBMax, 1);
239 fgWAlmond->SetParameter(0, 0.);
240 fgWAlmond->SetNpx(200);
241 fgWAlmond->SetNpy(200);
242
243 if(mode==2) {
244 Info("Init","Reading interaction almonds from file: %s",fName.Data());
245 Char_t almondName[100];
246 TFile* ff = new TFile(fName.Data());
247 for(Int_t k=0; k<40; k++) {
248 sprintf(almondName,"WAlmondFixedB%d",k);
249 fgWAlmondCurrent = (TF2*)ff->Get(almondName);
250 new(&fgWAlmondFixedB[k]) TF2(*fgWAlmondCurrent);
5b3a5a5d 251 }
65aa45f2 252 delete ff;
253 }
254
255 fgWIntRadius = new TF1("WIntRadius", WIntRadius, 0., fgBMax, 1);
256 fgWIntRadius->SetParameter(0, 0.);
257
258 //
259 // Path Length as a function of Phi
260 //
261 fgWPathLength0 = new TF1("WPathLength0", WPathLength0, -TMath::Pi(), TMath::Pi(), 2);
262 fgWPathLength0->SetParameter(0, 0.);
263 fgWPathLength0->SetParameter(1, 0.); //Pathlength definition
264
265 fgWPathLength = new TF1("WPathLength", WPathLength, -TMath::Pi(), TMath::Pi(), 3);
266 fgWPathLength->SetParameter(0, 0.); //Impact Parameter
267 fgWPathLength->SetParameter(1, 1000.); //Number of interactions used for average
268 fgWPathLength->SetParameter(2, 0); //Pathlength definition
269}
270
271void AliFastGlauber::Reset()
272{
273 //
274 // Reset dynamic allocated formulas
275 // in case init is called twice
276
277 if(fgWSb) delete fgWSb;
278 if(fgWSbz) delete fgWSbz;
279 if(fgWSz) delete fgWSz;
280 if(fgWSta) delete fgWSta;
281 if(fgWStarfi) delete fgWStarfi;
282 if(fgWAlmond) delete fgWAlmond;
283 if(fgWStaa) delete fgWStaa;
284 if(fgWSgeo) delete fgWSgeo;
285 if(fgWSbinary) delete fgWSbinary;
286 if(fgWSN) delete fgWSN;
287 if(fgWPathLength0) delete fgWPathLength0;
288 if(fgWPathLength) delete fgWPathLength;
289 if(fgWEnergyDensity) delete fgWEnergyDensity;
290 if(fgWIntRadius) delete fgWIntRadius;
291 if(fgWKParticipants) delete fgWKParticipants;
292 if(fgWParticipants) delete fgWParticipants;
5b3a5a5d 293}
294
295void AliFastGlauber::DrawWSb()
296{
65aa45f2 297 //
298 // Draw Wood-Saxon Nuclear Density Function
299 //
300 TCanvas *c1 = new TCanvas("c1","Wood Saxon",400,10,600,700);
301 c1->cd();
302 Double_t max=fgWSb->GetMaximum(0,fgBMax)*1.01;
303 TH2F *h2f=new TH2F("h2fwsb","Wood Saxon: #rho(r) = n (1-#omega(r/r_{0})^2)/(1+exp((r-r_{0})/d)) [fm^{-3}]",2,0,fgBMax,2,0,max);
304 h2f->SetStats(0);
305 h2f->GetXaxis()->SetTitle("r [fm]");
306 h2f->GetYaxis()->SetNoExponent(kTRUE);
307 h2f->GetYaxis()->SetTitle("#rho [fm^{-3}]");
308 h2f->Draw();
309 fgWSb->Draw("same");
310 TLegend *l1a = new TLegend(0.45,0.6,.90,0.8);
311 l1a->SetFillStyle(0);
312 l1a->SetBorderSize(0);
313 Char_t label[100];
314 sprintf(label,"r_{0} = %.2f fm",fWSr0);
315 l1a->AddEntry(fgWSb,label,"");
316 sprintf(label,"d = %.2f fm",fWSd);
317 l1a->AddEntry(fgWSb,label,"");
318 sprintf(label,"n = %.2e fm^{-3}",fWSn);
319 l1a->AddEntry(fgWSb,label,"");
320 sprintf(label,"#omega = %.2f",fWSw);
321 l1a->AddEntry(fgWSb,label,"");
322 l1a->Draw();
323 c1->Update();
5b3a5a5d 324}
325
326void AliFastGlauber::DrawOverlap()
327{
65aa45f2 328 //
329 // Draw Overlap Function
330 //
331 TCanvas *c2 = new TCanvas("c2","Overlap",400,10,600,700);
332 c2->cd();
333 Double_t max=fgWStaa->GetMaximum(0,fgBMax)*1.01;
334 TH2F *h2f=new TH2F("h2ftaa","Overlap function: T_{AB} [mbarn^{-1}]",2,0,fgBMax,2,0,max);
335 h2f->SetStats(0);
336 h2f->GetXaxis()->SetTitle("b [fm]");
337 h2f->GetYaxis()->SetTitle("T_{AB} [mbarn^{-1}]");
338 h2f->Draw();
339 fgWStaa->Draw("same");
5b3a5a5d 340}
341
1bc228f5 342void AliFastGlauber::DrawParticipants()
343{
65aa45f2 344 //
345 // Draw Number of Participants Npart
346 //
347 TCanvas *c3 = new TCanvas("c3","Participants",400,10,600,700);
348 c3->cd();
349 Double_t max=fgWParticipants->GetMaximum(0,fgBMax)*1.01;
350 TH2F *h2f=new TH2F("h2fpart","Number of Participants",2,0,fgBMax,2,0,max);
351 h2f->SetStats(0);
352 h2f->GetXaxis()->SetTitle("b [fm]");
353 h2f->GetYaxis()->SetTitle("N_{part}");
354 h2f->Draw();
355 fgWParticipants->Draw("same");
356 TLegend *l1a = new TLegend(0.50,0.75,.90,0.9);
357 l1a->SetFillStyle(0);
358 l1a->SetBorderSize(0);
359 Char_t label[100];
360 sprintf(label,"#sigma^{inel.}_{NN} = %.1f mbarn",fSigmaNN);
361 l1a->AddEntry(fgWParticipants,label,"");
362 l1a->Draw();
363 c3->Update();
1bc228f5 364}
365
5b3a5a5d 366void AliFastGlauber::DrawThickness()
367{
65aa45f2 368 //
369 // Draw Thickness Function
370 //
371 TCanvas *c4 = new TCanvas("c4","Thickness",400,10,600,700);
372 c4->cd();
373 Double_t max=fgWSta->GetMaximum(0,fgBMax)*1.01;
374 TH2F *h2f=new TH2F("h2fta","Thickness function: T_{A} [fm^{-2}]",2,0,fgBMax,2,0,max);
375 h2f->SetStats(0);
376 h2f->GetXaxis()->SetTitle("b [fm]");
377 h2f->GetYaxis()->SetTitle("T_{A} [fm^{-2}]");
378 h2f->Draw();
379 fgWSta->Draw("same");
5b3a5a5d 380}
381
382void AliFastGlauber::DrawGeo()
383{
65aa45f2 384 //
385 // Draw Geometrical Cross-Section
386 //
387 TCanvas *c5 = new TCanvas("c5","Geometrical Cross-Section",400,10,600,700);
388 c5->cd();
389 Double_t max=fgWSgeo->GetMaximum(0,fgBMax)*1.01;
390 TH2F *h2f=new TH2F("h2fgeo","Differential Geometrical Cross-Section: d#sigma^{geo}_{AB}/db [fm]",2,0,fgBMax,2,0,max);
391 h2f->SetStats(0);
392 h2f->GetXaxis()->SetTitle("b [fm]");
393 h2f->GetYaxis()->SetTitle("d#sigma^{geo}_{AB}/db [fm]");
394 h2f->Draw();
395 fgWSgeo->Draw("same");
396 TLegend *l1a = new TLegend(0.10,0.8,.40,0.9);
397 l1a->SetFillStyle(0);
398 l1a->SetBorderSize(0);
399 Char_t label[100];
400 sprintf(label,"#sigma_{NN}^{inel.} = %.1f mbarn",fSigmaNN);
401 l1a->AddEntry(fgWSgeo,label,"");
402 l1a->Draw();
403 c5->Update();
5b3a5a5d 404}
405
406void AliFastGlauber::DrawBinary()
407{
65aa45f2 408 //
409 // Draw Binary Cross-Section
410 //
411 TCanvas *c6 = new TCanvas("c6","Binary Cross-Section",400,10,600,700);
412 c6->cd();
413 Double_t max=fgWSbinary->GetMaximum(0,fgBMax)*1.01;
414 TH2F *h2f=new TH2F("h2fbinary","Differential Binary Cross-Section: #sigma^{hard}_{NN} dT_{AB}/db [fm]",2,0,fgBMax,2,0,max);
415 h2f->SetStats(0);
416 h2f->GetXaxis()->SetTitle("b [fm]");
417 h2f->GetYaxis()->SetTitle("d#sigma^{hard}_{AB}/db [fm]");
418 h2f->Draw();
419 fgWSbinary->Draw("same");
420 TLegend *l1a = new TLegend(0.50,0.8,.90,0.9);
421 l1a->SetFillStyle(0);
422 l1a->SetBorderSize(0);
423 Char_t label[100];
424 sprintf(label,"#sigma_{NN}^{hard} = %.1f mbarn",fSigmaHard);
425 l1a->AddEntry(fgWSb,label,"");
426 l1a->Draw();
427 c6->Update();
5b3a5a5d 428}
429
430void AliFastGlauber::DrawN()
431{
65aa45f2 432 //
433 // Draw Binaries per event (Ncoll)
434 //
435 TCanvas *c7 = new TCanvas("c7","Binaries per event",400,10,600,700);
436 c7->cd();
437 Double_t max=fgWSN->GetMaximum(0,fgBMax)*1.01;
438 TH2F *h2f=new TH2F("h2fhardcols","Number of hard collisions: T_{AB} #sigma^{hard}_{NN}/#sigma_{AB}^{geo}",2,0,fgBMax,2,0,max);
439 h2f->SetStats(0);
440 h2f->GetXaxis()->SetTitle("b [fm]");
441 h2f->GetYaxis()->SetTitle("N_{coll}");
442 h2f->Draw();
443 fgWSN->Draw("same");
444 TLegend *l1a = new TLegend(0.50,0.75,.90,0.9);
445 l1a->SetFillStyle(0);
446 l1a->SetBorderSize(0);
447 Char_t label[100];
448 sprintf(label,"#sigma^{hard}_{NN} = %.1f mbarn",fSigmaHard);
449 l1a->AddEntry(fgWSN,label,"");
450 sprintf(label,"#sigma^{inel.}_{NN} = %.1f mbarn",fSigmaNN);
451 l1a->AddEntry(fgWSN,label,"");
452 l1a->Draw();
453 c7->Update();
5b3a5a5d 454}
455
f3a04204 456void AliFastGlauber::DrawKernel(Double_t b)
5b3a5a5d 457{
65aa45f2 458 //
459 // Draw Kernel
460 //
461 TCanvas *c8 = new TCanvas("c8","Kernel",400,10,600,700);
462 c8->cd();
463 fgWStarfi->SetParameter(0, b);
464 TH2F *h2f=new TH2F("h2fkernel","Kernel of Overlap function: d^{2}T_{AB}/dr/d#phi [fm^{-3}]",2,0,fgBMax,2,0,TMath::Pi());
465 h2f->SetStats(0);
466 h2f->GetXaxis()->SetTitle("r [fm]");
467 h2f->GetYaxis()->SetTitle("#phi [rad]");
468 h2f->Draw();
469 fgWStarfi->Draw("same");
470 TLegend *l1a = new TLegend(0.65,0.8,.90,0.9);
471 l1a->SetFillStyle(0);
472 l1a->SetBorderSize(0);
473 Char_t label[100];
474 sprintf(label,"b = %.f fm",b);
475 l1a->AddEntry(fgWStarfi,label,"");
476 l1a->Draw();
477 c8->Update();
5b3a5a5d 478}
479
f3a04204 480void AliFastGlauber::DrawAlmond(Double_t b)
481{
65aa45f2 482 //
483 // Draw Interaction Almond
484 //
485 TCanvas *c9 = new TCanvas("c9","Almond",400,10,600,700);
486 c9->cd();
487 fgWAlmond->SetParameter(0, b);
488 TH2F *h2f=new TH2F("h2falmond","Interaction Almond [fm^{-4}]",2,0,fgBMax,2,0,fgBMax);
489 h2f->SetStats(0);
490 h2f->GetXaxis()->SetTitle("x [fm]");
491 h2f->GetYaxis()->SetTitle("y [fm]");
492 h2f->Draw();
493 fgWAlmond->Draw("same");
494 TLegend *l1a = new TLegend(0.65,0.8,.90,0.9);
495 l1a->SetFillStyle(0);
496 l1a->SetBorderSize(0);
497 Char_t label[100];
498 sprintf(label,"b = %.f fm",b);
499 l1a->AddEntry(fgWAlmond,label,"");
500 l1a->Draw();
501 c9->Update();
f3a04204 502}
503
65aa45f2 504void AliFastGlauber::DrawEnergyDensity()
f3a04204 505{
65aa45f2 506 //
507 // Draw energy density
508 //
509 TCanvas *c10 = new TCanvas("c10","Energy Density",400, 10, 600, 700);
510 c10->cd();
511 fgWEnergyDensity->SetMinimum(0.);
512 Double_t max=fgWEnergyDensity->GetMaximum(0,fgWEnergyDensity->GetParameter(0))*1.01;
513 TH2F *h2f=new TH2F("h2fenergydens","Energy density",2,0,fgBMax,2,0,max);
514 h2f->SetStats(0);
515 h2f->GetXaxis()->SetTitle("b [fm]");
516 h2f->GetYaxis()->SetTitle("fm^{-4}");
517 h2f->Draw();
518 fgWEnergyDensity->Draw("same");
519 c10->Update();
f3a04204 520}
521
65aa45f2 522void AliFastGlauber::DrawPathLength0(Double_t b, Int_t iopt)
f3a04204 523{
65aa45f2 524 //
525 // Draw Path Length
526 //
527 TCanvas *c11 = new TCanvas("c11","Path Length",400,10,600,700);
528 c11->cd();
529 fgWPathLength0->SetParameter(0, b);
530 fgWPathLength0->SetParameter(1, Double_t(iopt));
531 fgWPathLength0->SetMinimum(0.);
532 fgWPathLength0->SetMaximum(10.);
533 TH2F *h2f=new TH2F("h2fpathlength0","Path length",2,-TMath::Pi(), TMath::Pi(),2,0,10.);
534 h2f->SetStats(0);
535 h2f->GetXaxis()->SetTitle("#phi [rad]");
536 h2f->GetYaxis()->SetTitle("l [fm]");
537 h2f->Draw();
538 fgWPathLength0->Draw("same");
f3a04204 539}
540
65aa45f2 541void AliFastGlauber::DrawPathLength(Double_t b , Int_t ni, Int_t iopt)
f3a04204 542{
65aa45f2 543 //
544 // Draw Path Length
545 //
546 TCanvas *c12 = new TCanvas("c12","Path Length",400,10,600,700);
547 c12->cd();
548 fgWAlmond->SetParameter(0, b);
549 fgWPathLength->SetParameter(0, b);
550 fgWPathLength->SetParameter(1, Double_t (ni));
551 fgWPathLength->SetParameter(2, Double_t (iopt));
552 fgWPathLength->SetMinimum(0.);
553 fgWPathLength->SetMaximum(10.);
554 TH2F *h2f=new TH2F("h2fpathlength","Path length",2,-TMath::Pi(), TMath::Pi(),2,0,10.);
555 h2f->SetStats(0);
556 h2f->GetXaxis()->SetTitle("#phi [rad]");
557 h2f->GetYaxis()->SetTitle("l [fm]");
558 h2f->Draw();
559 fgWPathLength->Draw("same");
f3a04204 560}
561
65aa45f2 562void AliFastGlauber::DrawIntRadius(Double_t b)
2a103154 563{
65aa45f2 564 //
565 // Draw Interaction Radius
566 //
567 TCanvas *c13 = new TCanvas("c13","Interaction Radius",400,10,600,700);
568 c13->cd();
569 fgWIntRadius->SetParameter(0, b);
570 fgWIntRadius->SetMinimum(0);
571 Double_t max=fgWIntRadius->GetMaximum(0,fgBMax)*1.01;
572 TH2F *h2f=new TH2F("h2fintradius","Interaction Density",2,0.,fgBMax,2,0,max);
573 h2f->SetStats(0);
574 h2f->GetXaxis()->SetTitle("r [fm]");
575 h2f->GetYaxis()->SetTitle("[fm^{-3}]");
576 h2f->Draw();
577 fgWIntRadius->Draw("same");
2a103154 578}
579
5b3a5a5d 580Double_t AliFastGlauber::WSb(Double_t* x, Double_t* par)
581{
65aa45f2 582 //
583 // Woods-Saxon Parameterisation
584 // as a function of radius (xx)
585 //
586 const Double_t xx = x[0]; //fm
587 const Double_t r0 = par[0]; //fm
588 const Double_t d = par[1]; //fm
589 const Double_t w = par[2]; //no units
590 const Double_t n = par[3]; //fm^-3 (used to normalize integral to one)
591 const Double_t y = n * (1.+w*(xx/r0)*(xx/r0))/(1.+TMath::Exp((xx-r0)/d));
592 return y; //fm^-3
5b3a5a5d 593}
594
595Double_t AliFastGlauber::WSbz(Double_t* x, Double_t* par)
596{
65aa45f2 597 //
598 // Wood Saxon Parameterisation
599 // as a function of z and b
600 //
601 const Double_t bb = x[0]; //fm
602 const Double_t zz = x[1]; //fm
603 const Double_t r0 = par[0]; //fm
604 const Double_t d = par[1]; //fm
605 const Double_t w = par[2]; //no units
606 const Double_t n = par[3]; //fm^-3 (used to normalize integral to one)
607 const Double_t xx = TMath::Sqrt(bb*bb+zz*zz);
608 const Double_t y = n * (1.+w*(xx/r0)*(xx/r0))/(1.+TMath::Exp((xx-r0)/d));
609 return y; //fm^-3
5b3a5a5d 610}
611
612Double_t AliFastGlauber::WSz(Double_t* x, Double_t* par)
613{
65aa45f2 614 //
615 // Wood Saxon Parameterisation
616 // as a function of z for fixed b
617 //
618 const Double_t zz = x[0]; //fm
619 const Double_t r0 = par[0]; //fm
620 const Double_t d = par[1]; //fm
621 const Double_t w = par[2]; //no units
622 const Double_t n = par[3]; //fm^-3 (used to normalize integral to one)
623 const Double_t bb = par[4]; //fm
624 const Double_t xx = TMath::Sqrt(bb*bb+zz*zz);
625 const Double_t y = n * (1.+w*(xx/r0)*(xx/r0))/(1.+TMath::Exp((xx-r0)/d));
626 return y; //fm^-3
5b3a5a5d 627}
628
f86dad79 629Double_t AliFastGlauber::WSta(Double_t* x, Double_t* /*par*/)
5b3a5a5d 630{
65aa45f2 631 //
632 // Thickness function T_A
633 // as a function of b
634 //
635 const Double_t b = x[0];
636 fgWSz->SetParameter(4, b);
637 const Double_t y = 2. * fgWSz->Integral(0., fgBMax);
638 return y; //fm^-2
5b3a5a5d 639}
640
5b3a5a5d 641Double_t AliFastGlauber::WStarfi(Double_t* x, Double_t* par)
642{
65aa45f2 643 //
644 // Kernel for overlap function: T_A(s)*T_A(s-b)
645 // as a function of r and phi
646 const Double_t r1 = x[0];
647 const Double_t phi = x[1];
648 const Double_t b = par[0];
649 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
650 const Double_t y = r1 * fgWSta->Eval(r1) * fgWSta->Eval(r2);
651 return y; //fm^-3
652}
653
654Double_t AliFastGlauber::WStaa(Double_t* x, Double_t* par)
655{
656 //
657 // Overlap function
658 // T_{AB}=Int d2s T_A(s)*T_B(s-b)
659 // as a function of b
660 // (normalized to fA*fB)
661 //
662 const Double_t b = x[0];
663 const Double_t A = par[0];
664 fgWStarfi->SetParameter(0, b);
665
666 // root integration seems to fail
667 /*
668 Double_t al[2];
669 Double_t bl[2];
670 al[0] = 1e-6;
671 al[1] = fgBMax;
672 bl[0] = 0.;
673 bl[1] = TMath::Pi();
674 Double_t err;
675
676 Double_t y = 2. * 208. * 208. * fgWStarfi->IntegralMultiple(2, al, bl, 0.001, err);
677 printf("WStaa: %.5e %.5e %.5e\n", b, y, err);
678 */
679
680 //
681 // MC Integration
682 //
683 Double_t y = 0;
684 for (Int_t i = 0; i < fgkMCInts; i++)
685 {
686 const Double_t phi = TMath::Pi() * gRandom->Rndm();
687 const Double_t b1 = fgBMax * gRandom->Rndm();
688 y += fgWStarfi->Eval(b1, phi);
689 }
690 y *= 2. * TMath::Pi() * fgBMax / fgkMCInts; //fm^-2
691 y *= A * A * 0.1; //mbarn^-1
692 return y;
5b3a5a5d 693}
694
1bc228f5 695Double_t AliFastGlauber::WKParticipants(Double_t* x, Double_t* par)
696{
65aa45f2 697 //
698 // Kernel for number of participants
699 // as a function of r and phi
700 //
701 const Double_t r1 = x[0];
702 const Double_t phi = x[1];
703 const Double_t b = par[0]; //fm
704 const Double_t sig = par[1]; //mbarn
705 const Double_t A = par[2]; //mass number
706 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
707 const Double_t xsi = fgWSta->Eval(r2) * sig * 0.1;
708 /*
709 Double_t y=(1-TMath::Power((1-xsi),A))
710 */
711 Double_t a = A;
712 Double_t sum = a * xsi;
713 Double_t y = sum;
714 for (Int_t i = 1; i <= A; i++)
1bc228f5 715 {
65aa45f2 716 a--;
717 sum *= (-xsi) * a / Float_t(i+1);
718 y += sum;
1bc228f5 719 }
65aa45f2 720 y = r1 * fgWSta->Eval(r1) * y;
721 return y; //fm^-1
1bc228f5 722}
723
65aa45f2 724Double_t AliFastGlauber::WParticipants(Double_t* x, Double_t* par)
725{
726 //
727 // Number of Participants as
728 // a function of b
729 //
730 const Double_t b = x[0];
731 const Double_t sig = par[0]; //mbarn
732 const Double_t A = par[1]; //mass number
733 fgWKParticipants->SetParameter(0, b);
734 fgWKParticipants->SetParameter(1, sig);
735 fgWKParticipants->SetParameter(2, A);
736
737 //
738 // MC Integration
739 //
740 Double_t y = 0;
741 for (Int_t i = 0; i < fgkMCInts; i++)
742 {
743 Double_t phi = TMath::Pi() * gRandom->Rndm();
744 Double_t b1 = fgBMax * gRandom->Rndm();
745 y += fgWKParticipants->Eval(b1, phi);
746 }
747 y *= 2. * A * 2. * TMath::Pi() * fgBMax / fgkMCInts;
748 return y; //no units
749}
750
751Double_t AliFastGlauber::WSgeo(Double_t* x, Double_t* par)
752{
753 //
754 // Geometrical Cross-Section
755 // as a function of b
756 //
757 const Double_t b = x[0]; //fm
758 const Double_t sigNN = par[0]; //mbarn
759 const Double_t taa = fgWStaa->Eval(b); //mbarn^-1
760 Double_t y = 2. * TMath::Pi() * b * (1. - TMath::Exp(- sigNN * taa));
761 return y; //fm
762}
763
764Double_t AliFastGlauber::WSbinary(Double_t* x, Double_t* par)
765{
766 //
767 // Number of binary collisions
768 // as a function of b
769 //
770 const Double_t b = x[0]; //fm
771 const Double_t sig = par[0]; //mbarn
772 const Double_t taa = fgWStaa->Eval(b); //mbarn^-1
773 const Double_t y = 2. * TMath::Pi() * b * sig * taa;
774 return y; //fm
775}
776
777Double_t AliFastGlauber::WSN(Double_t* x, Double_t* /*par*/)
778{
779 //
780 // Number of hard processes per event
781 // as a function of b
782 const Double_t b = x[0];
783 const Double_t y = fgWSbinary->Eval(b)/fgWSgeo->Eval(b);
784 return y; //no units
785}
786
787Double_t AliFastGlauber::WEnergyDensity(Double_t* x, Double_t* par)
788{
789 //
790 // Initial energy density
791 // as a function of the impact parameter
792 //
793 const Double_t b = x[0];
794 const Double_t rA = par[0];
795 //
796 // Attention: area of transverse reaction zone in hard-sphere approximation !
797 const Double_t rA2=rA*rA;
798 const Double_t b2=b*b;
799 Double_t saa = (TMath::Pi() - 2. * TMath::ASin(b/ 2./ rA)) * rA2
800 - b * TMath::Sqrt(rA2 - b2/ 4.); //fm^2
801 Double_t taa = fgWStaa->Eval(b); //mbarn^-1
802 Double_t y=taa/saa*10;
803 return y; //fm^-4
804}
5b3a5a5d 805
f3a04204 806Double_t AliFastGlauber::WAlmond(Double_t* x, Double_t* par)
807{
65aa45f2 808 //
809 // Almond shaped interaction region
810 // as a function of cartesian x,y.
811 //
812 const Double_t b = par[0];
813 const Double_t xx = x[0] + b/2.;
814 const Double_t yy = x[1];
815 const Double_t r1 = TMath::Sqrt(xx * xx + yy * yy);
816 const Double_t phi = TMath::ATan2(yy,xx);
817 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
818 //
819 // Interaction probability calculated as product of thicknesses
820 //
821 const Double_t y = fgWSta->Eval(r1) * fgWSta->Eval(r2);
822 return y; //fm^-4
f3a04204 823}
824
825Double_t AliFastGlauber::WIntRadius(Double_t* x, Double_t* par)
826{
65aa45f2 827 //
828 // Average interaction density over radius
829 // at which interaction takes place
830 // as a function of radius
831 //
832 const Double_t r = x[0];
833 const Double_t b = par[0];
834 fgWAlmond->SetParameter(0, b);
835 // Average over phi in small steps
836 const Double_t dphi = 2. * TMath::Pi() / 100.;
837 Double_t phi = 0.;
838 Double_t y = 0.;
839 for (Int_t i = 0; i < 100; i++) {
840 const Double_t xx = r * TMath::Cos(phi);
841 const Double_t yy = r * TMath::Sin(phi);
842 y += fgWAlmond->Eval(xx,yy);
843 phi += dphi;
844 } // phi loop
845 // Result multiplied by Jacobian (2 pi r)
846 y *= 2. * TMath::Pi() * r / 100.;
847 return y; //fm^-3
f3a04204 848}
849
850Double_t AliFastGlauber::WPathLength0(Double_t* x, Double_t* par)
851{
65aa45f2 852 //
853 // Path Length as a function of phi
854 // for interaction point fixed at (0,0)
855 // as a function of phi-direction
856 //
857 // Phi direction in Almond
858 const Double_t phi0 = x[0];
859 const Double_t b = par[0];
860 // Path Length definition
861 const Int_t iopt = Int_t(par[1]);
862
863 // Step along radial direction phi
864 const Int_t kNp = 100; // Steps in r
865 const Double_t kDr = fgBMax/kNp;
866 Double_t r = 0.;
867 Double_t rw = 0.;
868 Double_t w = 0.;
869 for (Int_t i = 0; i < kNp; i++) {
870 //
871 // Transform into target frame
872 //
873 const Double_t xx = r * TMath::Cos(phi0) + b / 2.;
874 const Double_t yy = r * TMath::Sin(phi0);
875 const Double_t phi = TMath::ATan2(yy, xx);
876 const Double_t r1 = TMath::Sqrt(xx * xx + yy * yy);
877 // Radius in projectile frame
878 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
879 const Double_t y = fgWSta->Eval(r1) * fgWSta->Eval(r2);
880
881 rw += y * r;
882 w += y;
883 r += kDr;
884 } // radial steps
885
886 Double_t y=0.;
887 if (!iopt) // My length definition (is exact for hard disk)
888 if(w) y= 2. * rw / w;
889 else {
890 const Double_t norm=fgWSta->Eval(0.01);
891 if(norm) y = TMath::Sqrt(2. * rw * kDr /norm /norm);
892 }
893 return y; //fm
894}
895
896Double_t AliFastGlauber::WPathLength(Double_t* x, Double_t* par)
897{
898 //
899 // Path Length as a function of phi
900 // Interaction point from random distribution
901 // as a function of the phi-direction
902 const Double_t phi0 = x[0];
903 const Double_t b = par[0];
904 fgWAlmond->SetParameter(0, b);
905 const Int_t kNpi = Int_t (par[1]); //Number of interactions
906 const Int_t iopt = Int_t(par[2]); //Path Length definition
907
908 //
909 // r-steps
910 //
911 const Int_t kNp = 100;
912 const Double_t kDr = fgBMax/Double_t(kNp);
913 Double_t l = 0.; // Path length
914 for (Int_t in = 0; in < kNpi; in ++) {
f3a04204 915 Double_t rw = 0.;
916 Double_t w = 0.;
65aa45f2 917 // Interaction point
918 Double_t x0, y0;
919 fgWAlmond->GetRandom2(x0, y0);
920 // Initial radius
921 const Double_t r0 = TMath::Sqrt(x0 * x0 + y0 * y0);
922 const Int_t nps = Int_t ((fgBMax - r0)/kDr) - 1;
f3a04204 923
65aa45f2 924 // Radial steps
925 Double_t r = 0.;
926 for (Int_t i = 0; (i < nps ); i++) {
927 // Transform into target frame
928 const Double_t xx = x0 + r * TMath::Cos(phi0) + b / 2.;
929 const Double_t yy = y0 + r * TMath::Sin(phi0);
930 const Double_t phi = TMath::ATan2(yy, xx);
931 const Double_t r1 = TMath::Sqrt(xx * xx + yy * yy);
932 // Radius in projectile frame
933 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
934 const Double_t y = fgWSta->Eval(r1) * fgWSta->Eval(r2);
935
936 rw += y * r;
937 w += y;
938 r += kDr;
939 } // steps
940 // Average over interactions
8de7e046 941 if (!iopt) {
65aa45f2 942 if(w) l += (2. * rw / w);
8de7e046 943 } else {
65aa45f2 944 const Double_t norm=fgWSta->Eval(0.01);
945 if(norm) l+= 2. * rw * kDr / norm / norm;
8de7e046 946 }
65aa45f2 947 } // interactions
948 Double_t ret=0;
949 if (!iopt)
950 ret= l / kNpi;
951 else
952 ret=TMath::Sqrt( l / kNpi);
953 return ret; //fm
f3a04204 954}
955
65aa45f2 956Double_t AliFastGlauber::CrossSection(Double_t b1, Double_t b2)
f3a04204 957{
65aa45f2 958 //
959 // Return the geometrical cross-section integrated from b1 to b2
960 //
961 return fgWSgeo->Integral(b1, b2)*10.; //mbarn
962}
f3a04204 963
65aa45f2 964Double_t AliFastGlauber::HardCrossSection(Double_t b1, Double_t b2)
5b3a5a5d 965{
65aa45f2 966 //
967 // Return the hard cross-section integrated from b1 to b2
968 //
969 return fgWSbinary->Integral(b1, b2)*10.; //mbarn
5b3a5a5d 970}
971
65aa45f2 972Double_t AliFastGlauber::FractionOfHardCrossSection(Double_t b1, Double_t b2)
1bc228f5 973{
65aa45f2 974 //
975 // Return raction of hard cross-section integrated from b1 to b2
976 //
977 return fgWSbinary->Integral(b1, b2)/fgWSbinary->Integral(0., 100.);
1bc228f5 978}
979
65aa45f2 980Double_t AliFastGlauber::Binaries(Double_t b)
5b3a5a5d 981{
65aa45f2 982 //
983 // Return number of binary collisions normalized to 1 at b=0
984 //
985 if(b==0) b=1e-4;
986 return fgWSN->Eval(b)/fgWSN->Eval(1e-4);
5b3a5a5d 987}
988
65aa45f2 989Double_t AliFastGlauber::GetNumberofBinaries(Double_t b)
5b3a5a5d 990{
65aa45f2 991 //
992 // Return number of binary collisions at b
993 //
994 if(b==0) b=1e-4;
995 return fgWSN->Eval(b);
5b3a5a5d 996}
997
65aa45f2 998Double_t AliFastGlauber::Participants(Double_t b)
5b3a5a5d 999{
65aa45f2 1000 //
1001 // Return the number of participants normalized to 1 at b=0
1002 //
1003 if(b==0) b=1e-4;
1004 return (fgWParticipants->Eval(b)/fgWParticipants->Eval(1e-4));
5b3a5a5d 1005}
1006
65aa45f2 1007Double_t AliFastGlauber::GetNumberOfParticipants(Double_t b)
2a103154 1008{
65aa45f2 1009 //
1010 // Return the number of participants for impact parameter b
1011 //
1012 if(b==0) b=1e-4;
1013 return (fgWParticipants->Eval(b));
2a103154 1014}
1015
5b3a5a5d 1016void AliFastGlauber::SimulateTrigger(Int_t n)
1017{
65aa45f2 1018 //
1019 // Simulates Trigger
1020 //
1021 TH1F* mbtH = new TH1F("mbtH", "MB Trigger b-Distribution", 100, 0., 20.);
1022 TH1F* hdtH = new TH1F("hdtH", "Hard Trigger b-Distribution", 100, 0., 20.);
1023 TH1F* mbmH = new TH1F("mbmH", "MB Trigger Multiplicity Distribution", 100, 0., 8000.);
1024 TH1F* hdmH = new TH1F("hdmH", "Hard Trigger Multiplicity Distribution", 100, 0., 8000.);
5b3a5a5d 1025
65aa45f2 1026 mbtH->SetXTitle("b [fm]");
1027 hdtH->SetXTitle("b [fm]");
1028 mbmH->SetXTitle("Multiplicity");
1029 hdmH->SetXTitle("Multiplicity");
5b3a5a5d 1030
65aa45f2 1031 TCanvas *c0 = new TCanvas("c0","Trigger Simulation",400,10,600,700);
1032 c0->Divide(2,1);
1033 TCanvas *c1 = new TCanvas("c1","Trigger Simulation",400,10,600,700);
1034 c1->Divide(1,2);
5b3a5a5d 1035
65aa45f2 1036 //
1037 //
1038 Init(1);
1039 for (Int_t iev = 0; iev < n; iev++)
5b3a5a5d 1040 {
65aa45f2 1041 Float_t b, p, mult;
1042 GetRandom(b, p, mult);
1043 mbtH->Fill(b,1.);
1044 hdtH->Fill(b, p);
1045 mbmH->Fill(mult, 1.);
1046 hdmH->Fill(mult, p);
1047
1048 c0->cd(1);
1049 mbtH->Draw();
1050 c0->cd(2);
1051 hdtH->Draw();
1052 c0->Update();
1053
1054 c1->cd(1);
1055 mbmH->Draw();
1056 c1->cd(2);
1057 hdmH->Draw();
1058 c1->Update();
5b3a5a5d 1059 }
1060}
1061
1062void AliFastGlauber::GetRandom(Float_t& b, Float_t& p, Float_t& mult)
1063{
65aa45f2 1064 //
1065 // Gives back a random impact parameter, hard trigger probability and multiplicity
1066 //
1067 b = fgWSgeo->GetRandom();
1068 const Float_t mu = fgWSN->Eval(b);
1069 p = 1.-TMath::Exp(-mu);
1070 mult = 6000./fgWSN->Eval(1.) * mu;
5b3a5a5d 1071}
1072
c2140715 1073void AliFastGlauber::GetRandom(Int_t& bin, Bool_t& hard)
1074{
65aa45f2 1075 //
1076 // Gives back a random impact parameter bin, and hard trigger decission
1077 //
1078 const Float_t b = fgWSgeo->GetRandom();
1079 const Float_t mu = fgWSN->Eval(b) * fSigmaHard;
1080 const Float_t p = 1.-TMath::Exp(-mu);
1081 if (b < 5.) {
1082 bin = 1;
1083 } else if (b < 8.6) {
1084 bin = 2;
1085 } else if (b < 11.2) {
1086 bin = 3;
1087 } else if (b < 13.2) {
1088 bin = 4;
1089 } else if (b < 15.0) {
1090 bin = 5;
1091 } else {
1092 bin = 6;
1093 }
1094 hard = kFALSE;
1095 const Float_t r = gRandom->Rndm();
1096 if (r < p) hard = kTRUE;
c2140715 1097}
1098
65aa45f2 1099Double_t AliFastGlauber::GetRandomImpactParameter(Double_t bmin, Double_t bmax)
5b3a5a5d 1100{
65aa45f2 1101 //
1102 // Gives back a random impact parameter in the range bmin .. bmax
1103 //
1104 Float_t b = -1.;
1105 while(b < bmin || b > bmax)
1106 b = fgWSgeo->GetRandom();
1107 return b;
5b3a5a5d 1108}
1109
65aa45f2 1110void AliFastGlauber::StoreFunctions()
5b3a5a5d 1111{
65aa45f2 1112 //
1113 // Store in file functions
1114 //
1115 TFile* ff = new TFile(fName.Data(),"recreate");
1116 fgWStaa->Write("WStaa");
1117 fgWParticipants->Write("WParticipants");
1118 ff->Close();
1119 return;
5b3a5a5d 1120}
1121
65aa45f2 1122//=================== Added by A. Dainese 11/02/04 ===========================
1bc228f5 1123
65aa45f2 1124void AliFastGlauber::PlotAlmonds()
5b3a5a5d 1125{
65aa45f2 1126 //
1127 // Plot almonds for some impact parameters
1128 //
1129 TCanvas *c = new TCanvas("c","Almonds",0,0,500,500);
1130 gStyle->SetPalette(1,0);
1131 c->Divide(2,2);
1132 c->cd(1);
1133 fgWAlmondFixedB[0].Draw("cont1");
1134 c->cd(2);
1135 fgWAlmondFixedB[10].Draw("cont1");
1136 c->cd(3);
1137 fgWAlmondFixedB[20].Draw("cont1");
1138 c->cd(4);
1139 fgWAlmondFixedB[30].Draw("cont1");
1140 return;
5b3a5a5d 1141}
1142
65aa45f2 1143void AliFastGlauber::StoreAlmonds()
5b3a5a5d 1144{
65aa45f2 1145 //
1146 // Store in file
1147 // 40 almonds for b = (0.25+k*0.5) fm (k=0->39)
1148 //
1149 Char_t almondName[100];
1150 TFile* ff = new TFile(fName.Data(),"update");
1151 for(Int_t k=0; k<40; k++) {
1152 sprintf(almondName,"WAlmondFixedB%d",k);
1153 Double_t b = 0.25+k*0.5;
1154 Info("StoreAlmonds"," b = %f\n",b);
1155 fgWAlmond->SetParameter(0,b);
1156 fgWAlmond->Write(almondName);
1157 }
1158 ff->Close();
1159 return;
5b3a5a5d 1160}
a2f2f511 1161
a2f2f511 1162void AliFastGlauber::SetCentralityClass(Double_t xsecFrLow,Double_t xsecFrUp)
1163{
1164 //
65aa45f2 1165 // Set limits of centrality class as fractions
1166 // of the geomtrical cross section
a2f2f511 1167 //
1168 if(xsecFrLow>1. || xsecFrUp>1. || xsecFrLow>xsecFrUp) {
65aa45f2 1169 Error("SetCentralityClass", "Please set 0 <= xsecFrLow <= xsecFrUp <= 1\n");
a2f2f511 1170 return;
1171 }
1172
1173 Double_t bLow=0.,bUp=0.;
1174 Double_t xsecFr=0.;
65aa45f2 1175 const Double_t norm=fgWSgeo->Integral(0.,100.);
a2f2f511 1176 while(xsecFr<xsecFrLow) {
65aa45f2 1177 xsecFr = fgWSgeo->Integral(0.,bLow)/norm;
a2f2f511 1178 bLow += 0.1;
1179 }
1180 bUp = bLow;
1181 while(xsecFr<xsecFrUp) {
65aa45f2 1182 xsecFr = fgWSgeo->Integral(0.,bUp)/norm;
a2f2f511 1183 bUp += 0.1;
1184 }
1185
65aa45f2 1186 Info("SetCentralityClass", "Centrality class: %4.2f-%4.2f; %4.1f < b < %4.1f fm\n",
a2f2f511 1187 xsecFrLow,xsecFrUp,bLow,bUp);
a2f2f511 1188 fgWSbinary->SetRange(bLow,bUp);
a2f2f511 1189 return;
1190}
1191
1192void AliFastGlauber::GetRandomBHard(Double_t& b)
1193{
1194 //
1195 // Get random impact parameter according to distribution of
1196 // hard (binary) cross-section, in the range defined by the centrality class
1197 //
1198 b = fgWSbinary->GetRandom();
1199 Int_t bin = 2*(Int_t)b;
1200 if( (b-(Int_t)b) > 0.5) bin++;
65aa45f2 1201 fgWAlmondCurrent = &fgWAlmondFixedB[bin];
a2f2f511 1202 return;
1203}
1204
1205void AliFastGlauber::GetRandomXY(Double_t& x,Double_t& y)
1206{
1207 //
1208 // Get random position of parton production point according to
1209 // product of thickness functions
1210 //
65aa45f2 1211 fgWAlmondCurrent->GetRandom2(x,y);
a2f2f511 1212 return;
1213}
1214
1215void AliFastGlauber::GetRandomPhi(Double_t& phi)
1216{
1217 //
1218 // Get random parton azimuthal propagation direction
1219 //
1220 phi = 2.*TMath::Pi()*gRandom->Rndm();
1221 return;
1222}
1223
65aa45f2 1224Double_t AliFastGlauber::CalculateLength(Double_t b,Double_t x0,Double_t y0,Double_t phi0)
a2f2f511 1225{
1226 //
1227 // Calculate path length for a parton with production point (x0,y0)
1228 // and propagation direction (ux=cos(phi0),uy=sin(phi0))
1229 // in a collision with impact parameter b
1230 //
1231
1232 // number of steps in l
1233 const Int_t kNp = 100;
1234 const Double_t kDl = fgBMax/Double_t(kNp);
1235
a2f2f511 1236 if(fEllDef==1) {
1237 //
1238 // Definition 1:
1239 //
65aa45f2 1240 // ell = 2 * \int_0^\infty dl*l*(T_A*T_B)(x0+l*ux,y0+l*uy) /
1241 // \int_0^\infty dl*(T_A*T_B)(x0+l*ux,y0+l*uy)
a2f2f511 1242 //
a2f2f511 1243
a2f2f511 1244 // Initial radius
65aa45f2 1245 const Double_t r0 = TMath::Sqrt(x0 * x0 + y0 * y0);
1246 const Int_t nps = Int_t ((fgBMax - r0)/kDl) - 1;
1247 Double_t l = 0.;
1248 Double_t integral1 = 0.;
1249 Double_t integral2 = 0.;
a2f2f511 1250 // Radial steps
65aa45f2 1251 for (Int_t i = 0; i < nps; i++) {
a2f2f511 1252
1253 // Transform into target frame
65aa45f2 1254 const Double_t xx = x0 + l * TMath::Cos(phi0) + b / 2.;
1255 const Double_t yy = y0 + l * TMath::Sin(phi0);
1256 const Double_t phi = TMath::ATan2(yy, xx);
1257 const Double_t r1 = TMath::Sqrt(xx * xx + yy * yy);
a2f2f511 1258 // Radius in projectile frame
65aa45f2 1259 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
1260 const Double_t prodTATB = fgWSta->Eval(r1) * fgWSta->Eval(r2);
a2f2f511 1261
65aa45f2 1262 integral1 += prodTATB * l * kDl;
1263 integral2 += prodTATB * kDl;
a2f2f511 1264 l += kDl;
1265 } // steps
1266
65aa45f2 1267 Double_t ell=0.;
1268 if(integral2)
1269 ell = (2. * integral1 / integral2);
a2f2f511 1270 return ell;
a2f2f511 1271 } else if(fEllDef==2) {
1272 //
1273 // Definition 2:
1274 //
1275 // ell = \int_0^\infty dl*
65aa45f2 1276 // \Theta((T_A*T_B)(x0+l*ux,y0+l*uy)-0.5*(T_A*T_B)(0,0))
a2f2f511 1277 //
1278
a2f2f511 1279 // Initial radius
65aa45f2 1280 const Double_t r0 = TMath::Sqrt(x0 * x0 + y0 * y0);
1281 const Int_t nps = Int_t ((fgBMax - r0)/kDl) - 1;
1282 const Double_t prodTATBHalfMax = 0.5*fgWAlmondCurrent->Eval(0.,0.);
a2f2f511 1283 // Radial steps
65aa45f2 1284 Double_t l = 0.;
1285 Double_t integral = 0.;
1286 for (Int_t i = 0; i < nps; i++) {
a2f2f511 1287 // Transform into target frame
65aa45f2 1288 const Double_t xx = x0 + l * TMath::Cos(phi0) + b / 2.;
1289 const Double_t yy = y0 + l * TMath::Sin(phi0);
1290 const Double_t phi = TMath::ATan2(yy, xx);
1291 const Double_t r1 = TMath::Sqrt(xx * xx + yy * yy);
a2f2f511 1292 // Radius in projectile frame
65aa45f2 1293 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
1294 const Double_t prodTATB = fgWSta->Eval(r1) * fgWSta->Eval(r2);
1295 if(prodTATB>prodTATBHalfMax) integral += kDl;
a2f2f511 1296 l += kDl;
1297 } // steps
65aa45f2 1298 Double_t ell = integral;
a2f2f511 1299 return ell;
a2f2f511 1300 } else {
65aa45f2 1301 Error("CalculateLength","Wrong length definition setting: %d !\n",fEllDef);
a2f2f511 1302 return -1.;
1303 }
1304}
1305
1306void AliFastGlauber::GetLength(Double_t& ell,Double_t b)
1307{
1308 //
1309 // Return length from random b, x0, y0, phi0
1310 //
1311 Double_t x0,y0,phi0;
1312 if(b<0.) GetRandomBHard(b);
1313 GetRandomXY(x0,y0);
1314 GetRandomPhi(phi0);
a2f2f511 1315 ell = CalculateLength(b,x0,y0,phi0);
a2f2f511 1316 return;
1317}
1318
65aa45f2 1319void AliFastGlauber::GetLengthsBackToBack(Double_t& ell1,Double_t& ell2,Double_t b)
a2f2f511 1320{
1321 //
1322 // Return 2 lengths back to back from random b, x0, y0, phi0
1323 //
1324 Double_t x0,y0,phi0;
1325 if(b<0.) GetRandomBHard(b);
1326 GetRandomXY(x0,y0);
1327 GetRandomPhi(phi0);
65aa45f2 1328 const Double_t phi0plusPi = phi0+TMath::Pi();
a2f2f511 1329 ell1 = CalculateLength(b,x0,y0,phi0);
1330 ell2 = CalculateLength(b,x0,y0,phi0plusPi);
a2f2f511 1331 return;
1332}
1333
1bc228f5 1334void AliFastGlauber::GetLengthsForPythia(Int_t n,Double_t* phi,Double_t* ell, Double_t b)
a2f2f511 1335{
1336 //
1337 // Returns lenghts for n partons with azimuthal angles phi[n]
1338 // from random b, x0, y0
1339 //
1bc228f5 1340 Double_t x0, y0;
1341 if(b < 0.) GetRandomBHard(b);
a2f2f511 1342 GetRandomXY(x0,y0);
1bc228f5 1343 for(Int_t i = 0; i< n; i++) ell[i] = CalculateLength(b,x0,y0,phi[i]);
a2f2f511 1344 return;
1345}
1346
1347void AliFastGlauber::PlotBDistr(Int_t n)
65aa45f2 1348{
a2f2f511 1349 //
1350 // Plot distribution of n impact parameters
1351 //
1352 Double_t b;
1353 TH1F *hB = new TH1F("hB","dN/db",100,0,fgBMax);
1354 hB->SetXTitle("b [fm]");
1355 hB->SetYTitle("dN/db [a.u.]");
1356 hB->SetFillColor(3);
a2f2f511 1357 for(Int_t i=0; i<n; i++) {
1358 GetRandomBHard(b);
1359 hB->Fill(b);
1360 }
a2f2f511 1361 TCanvas *cB = new TCanvas("cB","Impact parameter distribution",0,0,500,500);
1362 cB->cd();
1363 hB->Draw();
a2f2f511 1364 return;
1365}
1366
1367void AliFastGlauber::PlotLengthDistr(Int_t n,Bool_t save,Char_t *fname)
1368{
1369 //
1370 // Plot length distribution
1371 //
1372 Double_t ell;
1373 TH1F *hEll = new TH1F("hEll","Length distribution",16,-0.5,15.5);
1374 hEll->SetXTitle("Transverse path length, L [fm]");
1375 hEll->SetYTitle("Probability");
1376 hEll->SetFillColor(2);
a2f2f511 1377 for(Int_t i=0; i<n; i++) {
1378 GetLength(ell);
1379 hEll->Fill(ell);
1380 }
1381 hEll->Scale(1/(Double_t)n);
a2f2f511 1382 TCanvas *cL = new TCanvas("cL","Length distribution",0,0,500,500);
1383 cL->cd();
1384 hEll->Draw();
1385
1386 if(save) {
1387 TFile *f = new TFile(fname,"recreate");
1388 hEll->Write();
1389 f->Close();
1390 }
1391 return;
1392}
1393
1394void AliFastGlauber::PlotLengthB2BDistr(Int_t n,Bool_t save,Char_t *fname)
1395{
1396 //
1397 // Plot lengths back-to-back distributions
1398 //
1399 Double_t ell1,ell2;
1400 TH2F *hElls = new TH2F("hElls","Lengths back-to-back",100,0,15,100,0,15);
1401 hElls->SetXTitle("Transverse path length, L [fm]");
1402 hElls->SetYTitle("Transverse path length, L [fm]");
a2f2f511 1403 for(Int_t i=0; i<n; i++) {
1404 GetLengthsBackToBack(ell1,ell2);
1405 hElls->Fill(ell1,ell2);
1406 }
1407 hElls->Scale(1/(Double_t)n);
a2f2f511 1408 TCanvas *cLs = new TCanvas("cLs","Length back-to-back distribution",0,0,500,500);
1409 gStyle->SetPalette(1,0);
1410 cLs->cd();
1411 hElls->Draw("col,Z");
a2f2f511 1412 if(save) {
1413 TFile *f = new TFile(fname,"recreate");
1414 hElls->Write();
1415 f->Close();
1416 }
1417 return;
1418}
1419
65aa45f2 1420//=================== Added by A. Dainese 05/03/04 ===========================
1421
1422void AliFastGlauber::CalculateI0I1(Double_t& integral0,Double_t& integral1,
1423 Double_t b,Double_t x0,Double_t y0,
1424 Double_t phi0,Double_t ellCut)
a2f2f511 1425{
65aa45f2 1426 //
1427 // Calculate integrals:
1428 // integral0 = \int_0^ellCut dl*(T_A*T_B)(x0+l*ux,y0+l*uy)
1429 // integral1 = \int_0^ellCut dl*l*(T_A*T_B)(x0+l*ux,y0+l*uy)
a2f2f511 1430 //
65aa45f2 1431 // for a parton with production point (x0,y0)
1432 // and propagation direction (ux=cos(phi0),uy=sin(phi0))
1433 // in a collision with impact parameter b
1434 //
1435
1436 // number of steps in l
1437 const Int_t kNp = 100;
1438 const Double_t kDl = fgBMax/Double_t(kNp);
1439
1440 // Initial radius
1441 const Double_t r0 = TMath::Sqrt(x0 * x0 + y0 * y0);
1442 const Int_t nps = Int_t ((fgBMax - r0)/kDl) - 1;
1443
1444 // Radial steps
1445 Double_t l = 0.;
1446 integral0 = 0.;
1447 integral1 = 0.;
1448 Int_t i = 0;
1449 while((i < nps) && (l < ellCut)) {
1450 // Transform into target frame
1451 const Double_t xx = x0 + l * TMath::Cos(phi0) + b / 2.;
1452 const Double_t yy = y0 + l * TMath::Sin(phi0);
1453 const Double_t phi = TMath::ATan2(yy, xx);
1454 const Double_t r1 = TMath::Sqrt(xx * xx + yy * yy);
1455 // Radius in projectile frame
1456 const Double_t r2 = TMath::Sqrt(r1 * r1 + b * b - 2. * r1 * b * TMath::Cos(phi));
1457 const Double_t prodTATB = fgWSta->Eval(r1) * fgWSta->Eval(r2);
1458 integral0 += prodTATB * kDl;
1459 integral1 += prodTATB * l * kDl;
1460 l += kDl;
1461 i++;
1462 } // steps
1463 return;
1464}
1465
1466void AliFastGlauber::GetI0I1(Double_t& integral0,Double_t& integral1,
1467 Double_t ellCut,Double_t b)
1468{
a2f2f511 1469 //
65aa45f2 1470 // Return I0 and I1 from random b, x0, y0, phi0
1471 //
1472 Double_t x0,y0,phi0;
1473 if(b<0.) GetRandomBHard(b);
1474 GetRandomXY(x0,y0);
1475 GetRandomPhi(phi0);
1476 CalculateI0I1(integral0,integral1,b,x0,y0,phi0,ellCut);
1477 return;
1478}
a2f2f511 1479
65aa45f2 1480void AliFastGlauber::GetI0I1BackToBack(Double_t& integral01,Double_t& integral11,
1481 Double_t& integral02,Double_t& integral12,
1482 Double_t ellCut,Double_t b)
1483{
1484 //
1485 // Return 2 pairs of I0 and I1 back to back from random b, x0, y0, phi0
1486 //
1487 Double_t x0,y0,phi0;
1488 if(b<0.) GetRandomBHard(b);
1489 GetRandomXY(x0,y0);
1490 GetRandomPhi(phi0);
1491 const Double_t phi0plusPi = phi0+TMath::Pi();
1492 CalculateI0I1(integral01,integral11,b,x0,y0,phi0,ellCut);
1493 CalculateI0I1(integral02,integral12,b,x0,y0,phi0plusPi,ellCut);
1494 return;
1495}
a2f2f511 1496
65aa45f2 1497void AliFastGlauber::GetI0I1ForPythia(Int_t n,Double_t* phi,
1498 Double_t* integral0,Double_t* integral1,
1499 Double_t ellCut,Double_t b)
1500{
1501 //
1502 // Returns I0 and I1 pairs for n partons with azimuthal angles phi[n]
1503 // from random b, x0, y0
1504 //
1505 Double_t x0,y0;
1506 if(b<0.) GetRandomBHard(b);
1507 GetRandomXY(x0,y0);
1508 for(Int_t i=0; i<n; i++)
1509 CalculateI0I1(integral0[i],integral1[i],b,x0,y0,phi[i],ellCut);
1510 return;
1511}
1512
1513void AliFastGlauber::PlotI0I1Distr(Int_t n,Double_t ellCut,
1514 Bool_t save,Char_t *fname)
1515{
1516 //
1517 // Plot length distribution
1518 //
1519 Double_t i0,i1;
1520 TH1F *hI0 = new TH1F("hI0","I_{0} = #hat{q}L / k",
1521 100,0,0.001);
1522 hI0->SetXTitle("I_{0} [fm^{-3}]");
1523 hI0->SetYTitle("Probability");
1524 hI0->SetFillColor(3);
1525 TH1F *hI1 = new TH1F("hI1","I_{1} = #omega_{c} / k",
1526 100,0,0.01);
1527 hI1->SetXTitle("I_{1} [fm^{-2}]");
1528 hI1->SetYTitle("Probability");
1529 hI1->SetFillColor(4);
1530 TH1F *h2 = new TH1F("h2","2 I_{1}^{2}/I_{0} = R / k",
1531 100,0,0.02);
1532 h2->SetXTitle("2 I_{1}^{2}/I_{0} [fm^{-1}]");
1533 h2->SetYTitle("Probability");
1534 h2->SetFillColor(2);
1535 TH1F *h3 = new TH1F("h3","2 I_{1}/I_{0} = L",
1536 100,0,15);
1537 h3->SetXTitle("2 I_{1}/I_{0} [fm]");
1538 h3->SetYTitle("Probability");
1539 h3->SetFillColor(5);
1540 TH1F *h4 = new TH1F("h4","I_{0}^{2}/(2 I_{1}) = #hat{q} / k",
1541 100,0,0.00015);
1542 h4->SetXTitle("I_{0}^{2}/(2 I_{1}) [fm^{-4}]");
1543 h4->SetYTitle("Probability");
1544 h4->SetFillColor(7);
1545
1546 for(Int_t i=0; i<n; i++) {
1547 GetI0I1(i0,i1,ellCut);
1548 hI0->Fill(i0);
1549 hI1->Fill(i1);
1550 h2->Fill(2.*i1*i1/i0);
1551 h3->Fill(2.*i1/i0);
1552 h4->Fill(i0*i0/2./i1);
a2f2f511 1553 }
65aa45f2 1554 hI0->Scale(1/(Double_t)n);
1555 hI1->Scale(1/(Double_t)n);
1556
1557 TCanvas *cI0I1 = new TCanvas("cI0I1","I0 and I1",0,0,900,700);
1558 cI0I1->Divide(3,2);
1559 cI0I1->cd(1);
1560 hI0->Draw();
1561 cI0I1->cd(2);
1562 hI1->Draw();
1563 cI0I1->cd(3);
1564 h2->Draw();
1565 cI0I1->cd(4);
1566 h3->Draw();
1567 cI0I1->cd(5);
1568 h4->Draw();
a2f2f511 1569
65aa45f2 1570 if(save) {
1571 TFile *f = new TFile(fname,"recreate");
1572 hI0->Write();
1573 hI1->Write();
1574 h2->Write();
1575 h3->Write();
1576 h4->Write();
1577 f->Close();
1578 }
a2f2f511 1579 return;
1580}
1581
65aa45f2 1582void AliFastGlauber::PlotI0I1B2BDistr(Int_t n,Double_t ellCut,
1583 Bool_t save,Char_t *fname)
a2f2f511 1584{
1585 //
65aa45f2 1586 // Plot lengths back-to-back distributions
a2f2f511 1587 //
65aa45f2 1588 Double_t i01,i11,i02,i12;
1589 TH2F *hI0s = new TH2F("hI0s","I_{0}'s back-to-back",100,0,100,100,0,100);
1590 hI0s->SetXTitle("I_{0} [fm^{-3}]");
1591 hI0s->SetYTitle("I_{0} [fm^{-3}]");
1592 TH2F *hI1s = new TH2F("hI1s","I_{1}'s back-to-back",100,0,100,100,0,100);
1593 hI1s->SetXTitle("I_{1} [fm^{-2}]");
1594 hI1s->SetYTitle("I_{1} [fm^{-2}]");
a2f2f511 1595
65aa45f2 1596 for(Int_t i=0; i<n; i++) {
1597 GetI0I1BackToBack(i01,i11,i02,i12,ellCut);
1598 hI0s->Fill(i01,i02);
1599 hI1s->Fill(i11,i12);
1600 }
1601 hI0s->Scale(1/(Double_t)n);
1602 hI1s->Scale(1/(Double_t)n);
1603
1604 TCanvas *cI0I1s = new TCanvas("cI0I1s","I0 and I1 back-to-back distributions",0,0,800,400);
a2f2f511 1605 gStyle->SetPalette(1,0);
65aa45f2 1606 cI0I1s->Divide(2,1);
1607 cI0I1s->cd(1);
1608 hI0s->Draw("col,Z");
1609 cI0I1s->cd(2);
1610 hI1s->Draw("col,Z");
a2f2f511 1611
65aa45f2 1612 if(save) {
1613 TFile *f = new TFile(fname,"recreate");
1614 hI0s->Write();
1615 hI1s->Write();
1616 f->Close();
1617 }
a2f2f511 1618 return;
1619}