//
////////////////////////////////////////////////////////////////////////////////////////////////////
-#include <iostream.h>
+#include <Riostream.h>
#include "TParticle.h"
#include "TLorentzVector.h"
#include "AliStack.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
AliGenAfterBurnerFlow::AliGenAfterBurnerFlow() {
+ //
// Deafult Construction
-
+ //
+
fReactionPlane = 0;
fCounter = 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
AliGenAfterBurnerFlow::AliGenAfterBurnerFlow(Float_t reactionPlane) {
+ //
// Standard Construction
//
- // reactionPlane - Reaction Plane Angle in Deg
+ // reactionPlane - Reaction Plane Angle in Deg [0-360]
+ //
if (reactionPlane < 0 || reactionPlane > 360)
Error("AliGenAfterBurnerFlow",
////////////////////////////////////////////////////////////////////////////////////////////////////
-void AliGenAfterBurnerFlow::SetDirected(Int_t pdg, Float_t v11, Float_t v12, Float_t v13, Float_t v14) {
+void AliGenAfterBurnerFlow::SetDirectedSimple(Int_t pdg, Float_t v1) {
+ //
+ // Set Directed Flow
+ // The same directed flow is applied to all specified particles
+ // independently on transverse momentum or rapidity
+ //
+ // PDG - particle type to apply directed flow
+ // if (PDG == 0) use as default
+ //
+
+ SetFlowParameters(pdg, 1, 0, v1, 0, 0, 0);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void AliGenAfterBurnerFlow::SetDirectedParam
+(Int_t pdg, Float_t v11, Float_t v12, Float_t v13, Float_t v14) {
+ //
+ // Set Directed Flow
+ // Directed flow is parameterised as follows
//
- // Set Directed Flow parameters for a given particle type.
- // Actual flow coefficient depends on Pt and Y and is caculated by
- //
// V1(Pt,Y) = (V11 + V12*Pt) * sign(Y) * (V13 + V14 * Y^3)
//
// where sign = 1 for Y > 0 and -1 for Y < 0
// Defaults values
// v12 = v14 = 0
// v13 = 1
- //
- // In many cases it is sufficient to set v11 only.
- // Note: be carefull with parameter v14
- //
-
- SetFlowParameters(pdg, 1, v11, v12, v13, v14);
+ //
+ // PDG - particle type to apply directed flow
+ // if (PDG == 0) use as default
+ //
+
+ SetFlowParameters(pdg, 1, 1, v11, v12, v13, v14);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
-void AliGenAfterBurnerFlow::SetElliptic(Int_t pdg, Float_t v21, Float_t v22, Float_t v23) {
+void AliGenAfterBurnerFlow::SetEllipticSimple(Int_t pdg, Float_t v2) {
//
- // Set Elliptic Flow parameters for a given particle type.
- // Actual flow coefficient depends on Pt and Y and is caculated by
+ // Set Elliptic Flow
+ // The same Elliptic flow is applied to all specified particles
+ // independently on transverse momentum or rapidity
//
- // V2 = (V21 + V22 * Pt^2) * exp( -V23 * Y^2)
- //
- // Default values:
- // v22 = v23 = 0
+ // PDG - particle type to apply directed flow
+ // if (PDG == 0) use as default
//
- // In many cases it is sufficient to set v21 only
+ // V2 - flow coefficient
+ //
+ // NOTE: for starting playing with FLOW
+ // start with this function and values 0.05 - 0.1
//
- SetFlowParameters(pdg, 2, v21, v22, v23, 0);
+ SetFlowParameters(pdg, 2, 0, v2, 0, 0, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
-void AliGenAfterBurnerFlow::SetDefDirected(Float_t v11, Float_t v12, Float_t v13, Float_t v14) {
+void AliGenAfterBurnerFlow::SetEllipticParamPion
+(Int_t pdg, Float_t v21, Float_t pTmax, Float_t v22) {
+ //
+ // Set Elliptic Flow
+ //
+ // Elliptic flow is parametrised to reproduce
+ // V2 of Pions at RHIC energies and is given by:
//
- // Set Directed Flow parameters for all particles.
- // These parameters can be overriden for a specific type by calling
- // SetDirected() function.
+ // V2 = v21 * (pT/pTMax ) * exp (-v22 * y^2) where pT <= pTmax
+ // v21 * exp (-v22 * y^2) where pT > pTmax
//
- // For explanation of parameters refer to SetDirected()
+ // v21 - value at saturation
+ // pTmax - saturation transverse momentum
+ // v22 - rapidity decrising
//
- SetFlowParameters(0, 1, v11, v12, v13, v14);
+ SetFlowParameters(pdg, 2, 1, v21, pTmax, v22, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
-void AliGenAfterBurnerFlow::SetDefElliptic(Float_t v21, Float_t v22, Float_t v23) {
- //
- // Set Elliptic Flow parameters for all particles.
- // These parameters can be overriden for a specific type by calling
- // SetElliptic() function.
+void AliGenAfterBurnerFlow::SetEllipticParamOld
+(Int_t pdg, Float_t v21, Float_t v22, Float_t v23) {
+ //
+ // Set Elliptic Flow
//
- // For explanation of parameters refer to SetElliptic()
+ // Elliptic flow is parameterised using
+ // old MevSim parameterisation
+ //
+ // V2 = (V21 + V22 pT^2) * exp (-v22 * y^2)
//
- SetFlowParameters(0, 2, v21, v22, v23, 0);
+ SetFlowParameters(pdg, 2, 2, v21, v22, v23, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void AliGenAfterBurnerFlow::SetFlowParameters
-(Int_t pdg, Int_t order, Float_t v1, Float_t v2,Float_t v3,Float_t v4) {
+(Int_t pdg, Int_t order, Int_t type, Float_t v1, Float_t v2,Float_t v3,Float_t v4) {
//
// private function
//
Int_t index = 0;
- Int_t newEntry = 1;
+ Bool_t newEntry = kTRUE;
// Defaults
if (pdg == 0) {
index = kN - order;
- newEntry = 0;
+ newEntry = kFALSE;
}
// try to find existing entry
order == (Int_t)fParams[i][1]) {
index = i;
- newEntry = 0;
+ newEntry = kFALSE;
}
}
fParams[index][0] = pdg;
fParams[index][1] = order;
- fParams[index][2] = v1;
- fParams[index][3] = v2;
- fParams[index][4] = v3;
- fParams[index][5] = v4;
+ fParams[index][2] = type;
+ fParams[index][3] = v1;
+ fParams[index][4] = v2;
+ fParams[index][5] = v3;
+ fParams[index][6] = v4;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
-Float_t AliGenAfterBurnerFlow::GetCoeff
+Float_t AliGenAfterBurnerFlow::GetCoefficient
(Int_t pdg, Int_t n, Float_t Pt, Float_t Y) {
//
// private function
// calculate v
+ Int_t type = (Int_t)fParams[index][2];
+
if ((Int_t)fParams[index][1] == 1) { // Directed
-
- v = (fParams[index][2] + fParams[index][3] * Pt) * TMath::Sign(1.,Y) *
- (fParams[index][4] + fParams[index][5] * TMath::Abs(Y*Y*Y) );
+
+ if (type == 0 )
+ v = fParams[index][3];
+ else
+ v = (fParams[index][3] + fParams[index][4] * Pt) * TMath::Sign((Float_t)1.,Y) *
+ (fParams[index][5] + fParams[index][6] * TMath::Abs(Y*Y*Y) );
} else { // Elliptic
- v = (fParams[index][2] + fParams[index][3] * Pt * Pt) *
- TMath::Exp( - fParams[index][4] * Y * Y);
+ if (type == 0) v = fParams[index][3];
+
+ // Pion parameterisation
+
+ if (type == 1) {
+ if (Pt < fParams[index][4])
+ v = fParams[index][3] * (Pt / fParams[index][4]) ;
+ else
+ v = fParams[index][3];
+
+ v *= TMath::Exp( - fParams[index][5] * Y * Y);
+ }
+
+ // Old parameterisation
+
+ if (type == 2)
+ v = (fParams[index][3] + fParams[index][4] * Pt * Pt) *
+ TMath::Exp( - fParams[index][5] * Y * Y);
}
return v;
// Calculate Delta Phi for Directed and Elliptic Flow
- dPhi = -2 * GetCoeff(pdg, 1, pt, y) * TMath::Sin( phi - fReactionPlane );
- dPhi -= GetCoeff(pdg, 2, pt, y) * TMath::Sin( 2 * (phi - fReactionPlane));
-
+ dPhi = -2 * GetCoefficient(pdg, 1, pt, y) * TMath::Sin( phi - fReactionPlane );
+ dPhi -= GetCoefficient(pdg, 2, pt, y) * TMath::Sin( 2 * (phi - fReactionPlane));
- // cout << i << "\t" << pt << "\t" << y << "\t" << (GetCoeff(pdg, 1, pt, y)) << "\t"
- // << (GetCoeff(pdg, 2, pt, y)) << "\t" << dPhi << endl;
-
// Set new phi
phi += dPhi;
particle->SetMomentum(momentum);
}
- cout << "Flow After Burner: DONE" << endl;
-
+ Info("Generate","Flow After Burner: DONE");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff