#include "AliDecayerPolarized.h"
#include "AliLog.h"
-ClassImp(AliDecayerPolarized)
+ClassImp(AliDecayerPolarized);
+
+
//____________________________________________________________
-AliDecayerPolarized::AliDecayerPolarized()
+AliDecayerPolarized::AliDecayerPolarized():
+ fAlpha(0),
+ fSystRef(kHelicity),
+ fDecProd(kMuon),
+ fPol(new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.)),
+ fMother(0),
+ fDaughter1(0),
+ fDaughter2(0)
{
// Default constructor
- fAlpha=0;
- fSystRef=kHelicity;
- fDecProd=kMuon;
- fMother=0;
- fDaughter1=0;
- fDaughter2=0;
- fPol = new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.);
fPol->SetParameter(0,fAlpha);
}
//____________________________________________________________
-AliDecayerPolarized::AliDecayerPolarized(Double_t alpha, Polar_t systref, FinState_t decprod)
+AliDecayerPolarized::AliDecayerPolarized(Double_t alpha, Polar_t systref, FinState_t decprod):
+ fAlpha(alpha),
+ fSystRef(systref),
+ fDecProd(decprod),
+ fPol(new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.)),
+ fMother(0),
+ fDaughter1(0),
+ fDaughter2(0)
{
// Another constructor
- fAlpha=alpha;
- fSystRef=systref;
- fDecProd=decprod;
- fMother=0;
- fDaughter1=0;
- fDaughter2=0;
- fPol = new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.);
fPol->SetParameter(0,fAlpha);
if(fDecProd!=kMuon && fDecProd!=kElectron)
- AliFatal("Only polarized decay into muons or electrons is implemented!");
+ AliFatal("Only polarized decay into muons or electrons is implemented!");
+}
+
+AliDecayerPolarized::AliDecayerPolarized(const AliDecayerPolarized &decayer):
+ AliDecayer(decayer),
+ fAlpha(0),
+ fSystRef(kHelicity),
+ fDecProd(kMuon),
+ fPol(new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.)),
+ fMother(0),
+ fDaughter1(0),
+ fDaughter2(0)
+{
+ // Copy Constructor
+ decayer.Copy(*this);
}
//____________________________________________________________
typedef enum { kElectron = 1, kMuon = 2} FinState_t;
AliDecayerPolarized();
AliDecayerPolarized(Double_t alpha, Polar_t systref, FinState_t decprod);
- AliDecayerPolarized(const AliDecayerPolarized &decayer):AliDecayer(decayer)
- {decayer.Copy(*this);}
+ AliDecayerPolarized(const AliDecayerPolarized &decayer);
virtual ~AliDecayerPolarized();
void SetPolDec(Double_t alpha=0) {fAlpha=alpha;}
void SetPolRefSys(Polar_t systref=kColSop) {fSystRef=systref;}
-/**************************************************************************
+ /**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
//
ClassImp(AliDimuCombinator)
- AliDimuCombinator::AliDimuCombinator()
+
+AliDimuCombinator::AliDimuCombinator():
+ fNParticle((Int_t) (gAlice->TreeK())->GetEntries()),
+ fImuon1(0),
+ fImuon2(0),
+ fImin1(0),
+ fImin2(0),
+ fImax1(fNParticle),
+ fImax2(fNParticle),
+ fRate1(1.),
+ fRate2(1.),
+ fMuon1(0),
+ fMuon2(0),
+ fPtMin(0.),
+ fEtaMin(-10.),
+ fEtaMax(10.)
{
// Constructor
fNParticle = (Int_t) (gAlice->TreeK())->GetEntries();
- fImuon1 = 0;
- fImuon2 = 0;
- fMuon1 = 0;
- fMuon2 = 0;
- fImin1 = 0;
- fImin2 = 0;
- fImax1 = fNParticle;
- fImax2 = fNParticle;
- fPtMin = 0;
- fEtaMin = -10;
- fEtaMax = -10;
- fRate1 = 1.;
- fRate2 = 1.;
}
AliDimuCombinator::AliDimuCombinator(const AliDimuCombinator & combinator)
- :TObject(combinator)
+ :TObject(combinator),
+ fNParticle(0),
+ fImuon1(0),
+ fImuon2(0),
+ fImin1(0),
+ fImin2(0),
+ fImax1(0),
+ fImax2(0),
+ fRate1(0),
+ fRate2(0),
+ fMuon1(0),
+ fMuon2(0),
+ fPtMin(0.),
+ fEtaMin(0.),
+ fEtaMax(0.)
{
// Dummy copy constructor
combinator.Copy(*this);
ClassImp(AliGeVSimParticle)
+
////////////////////////////////////////////////////////////////////////////////////////////////////
+AliGeVSimParticle::AliGeVSimParticle():
+ fPDG(0),
+ fModel(0),
+ fN(0),
+ fMultTotal(kTRUE),
+ fIsSetMult(kFALSE),
+ fT(0.),
+ fSigmaY(0.),
+ fExpansion(0.),
+ fIsDirectedSimple(kTRUE),
+ fIsEllipticSimple(kTRUE),
+ fIsEllipticOld(kFALSE)
+{
+ // Default constructor
+}
AliGeVSimParticle::AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity,
- Float_t T, Float_t dY, Float_t exp) {
+ Float_t T, Float_t dY, Float_t exp):
+ fPDG(pdg),
+ fModel(model),
+ fN(multiplicity),
+ fMultTotal(kTRUE),
+ fIsSetMult(kFALSE),
+ fT(T),
+ fSigmaY(dY),
+ fExpansion(exp),
+ fIsDirectedSimple(kTRUE),
+ fIsEllipticSimple(kTRUE),
+ fIsEllipticOld(kFALSE)
+{
//
// pdg - Particle type code in PDG standard (see: http://pdg.lbl.gov)
// model - momentum distribution model (1 - 7)
// T - Inverse slope parameter ("temperature")
// dY - Raridity Width (only for model 1)
// exp - expansion velocity (only for model 4)
-
- fPDG = pdg;
- fT = T;
- fSigmaY = dY;
- fExpansion = exp;
-
- fN = multiplicity;
- fMultTotal = kTRUE;
- fIsSetMult = kFALSE;
-
- SetModel(model);
-
fV1[0] = fV1[1] = fV1[2] = fV1[3] = 0.;
fV2[0] = fV2[1] = fV2[2] = 0.;
-
- fIsEllipticSimple = fIsDirectedSimple = kTRUE;
- fIsEllipticOld = kFALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
-AliGeVSimParticle::AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity) {
+AliGeVSimParticle::AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity):
+ fPDG(pdg),
+ fModel(model),
+ fN(multiplicity),
+ fMultTotal(kTRUE),
+ fIsSetMult(kFALSE),
+ fT(0.),
+ fSigmaY(0.),
+ fExpansion(0.),
+ fIsDirectedSimple(kTRUE),
+ fIsEllipticSimple(kTRUE),
+ fIsEllipticOld(kFALSE)
+ {
//
// pdg - Particle type code in PDG standard (see: http://pdg.lbl.gov)
//
// Note that multiplicity can be interpreted by GeVSim
// either as Total multiplicity in the acceptance or dN/dY
//
-
- fPDG = pdg;
- fN = multiplicity;
- fMultTotal = kTRUE;
- fIsSetMult = kFALSE;
-
- SetModel(model);
-
- fT = 0.;
- fSigmaY = 0.;
- fExpansion = 0.;
-
fV1[0] = fV1[1] = fV1[2] = fV1[3] = 0.;
fV2[0] = fV2[1] = fV2[2] = 0.;
-
- fIsEllipticSimple = fIsDirectedSimple = kTRUE;
- fIsEllipticOld = kFALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
public:
////////////////////////////////////////////////////////////////////////////
-
- AliGeVSimParticle() {}
- AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity);
- AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity,
+
+ AliGeVSimParticle();
+ AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity);
+ AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity,
Float_t T, Float_t dY = 1., Float_t exp=0.);
- ~AliGeVSimParticle() {}
+ ~AliGeVSimParticle() {}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
-AliGenAfterBurnerFlow::AliGenAfterBurnerFlow() {
- //
- // Deafult Construction
- //
-
- fReactionPlane = 0;
- fCounter = 0;
+ AliGenAfterBurnerFlow::AliGenAfterBurnerFlow():
+ fReactionPlane(0),
+ fCounter(0)
+{
+ //
+ // Default Construction
+ //
}
////////////////////////////////////////////////////////////////////////////////////////////////////
-AliGenAfterBurnerFlow::AliGenAfterBurnerFlow(Float_t reactionPlane) {
+AliGenAfterBurnerFlow::AliGenAfterBurnerFlow(Float_t reactionPlane):
+ fReactionPlane(reactionPlane),
+ fCounter(0)
+{
//
// Standard Construction
//
ClassImp(AliGenBeamGas)
AliGenBeamGas::AliGenBeamGas()
- :AliGenExtFile()
+ :AliGenExtFile(),
+ fInteractions(1)
{
// Constructor
//
- fInteractions = 1;
fOsigma[0] = 0.;
fOsigma[1] = 0.;
fOsigma[2] = 2000.;
}
AliGenBeamGas::AliGenBeamGas(const AliGenBeamGas & beamgas):
- AliGenExtFile(beamgas)
+ AliGenExtFile(beamgas),
+ fInteractions(1)
{
// Copy constructor
beamgas.Copy(*this);
//_____________________________________________________________________________
AliGenBox::AliGenBox()
- :AliGenerator()
+ :AliGenerator(),
+ fIpart(0)
{
//
// Default constructor
//
- fIpart=0;
}
//_____________________________________________________________________________
AliGenBox::AliGenBox(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fIpart(kProton)
{
//
// Standard constructor
//
fName = "Box";
fTitle = "Box particle generator";
- // Generate Proton by default
- fIpart=kProton;
}
//_____________________________________________________________________________
ClassImp(AliGenCocktail)
AliGenCocktail::AliGenCocktail()
- :AliGenerator()
+ :AliGenerator(),
+ fNGenerators(0),
+ fRandom(kFALSE),
+ fUsePerEventRate(kFALSE),
+ fProb(0),
+ fEntries(0),
+ flnk1(0),
+ flnk2(0),
+ fHeader(0)
{
// Constructor
fName = "Cocktail";
fTitle= "Particle Generator using cocktail of generators";
- flnk1 = 0;
- flnk2 = 0;
- fNGenerators = 0;
- fEntries = 0;
- fHeader = 0;
- fRandom = kFALSE;
- fUsePerEventRate = kFALSE;
}
AliGenCocktail::AliGenCocktail(const AliGenCocktail & cocktail):
- AliGenerator(cocktail)
+ AliGenerator(cocktail),
+ fNGenerators(0),
+ fRandom(kFALSE),
+ fUsePerEventRate(kFALSE),
+ fProb(0),
+ fEntries(0),
+ flnk1(0),
+ flnk2(0),
+ fHeader(0)
{
// Copy constructor
cocktail.Copy(*this);
// Loop over generators and generate events
Int_t igen=0;
while((entry = (AliGenCocktailEntry*)next())) {
-
if (fUsePerEventRate && (gRandom->Rndm() > entry->Rate())) continue;
igen++;
/*********************************************************************/
/*********************************************************************/
-AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()
+ AliGenCocktailAfterBurner::AliGenCocktailAfterBurner():
+ fNAfterBurners(0),
+ fAfterBurnerEntries(new TList()),
+ fGenerationDone(kFALSE),
+ fInternalStacks(0),
+ fCollisionGeometries(0),
+ fCurrentEvent(0),
+ fActiveStack(0),
+ fActiveEvent(-1),
+ fCurrentGenerator(0),
+ fNBgEvents(0)
{
// Constructor
if (gDebug > 0)
- cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
+ cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
SetName("AliGenCocktailAfterBurner");
SetTitle("AliGenCocktailAfterBurner");
- fInternalStacks = 0;
- fCollisionGeometries = 0;
- fActiveStack = 0;
- fCurrentGenerator = 0;
- fCurrentEvent =0;
- fAfterBurnerEntries = new TList();
- fNAfterBurners = 0;
- fGenerationDone = kFALSE;
-
- fActiveEvent = -1;
- fNBgEvents = 0;
}
/*********************************************************************/
AliGenCocktailAfterBurner::AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& cocktail):
- AliGenCocktail(cocktail)
-
+ AliGenCocktail(cocktail),
+ fNAfterBurners(0),
+ fAfterBurnerEntries(new TList()),
+ fGenerationDone(kFALSE),
+ fInternalStacks(0),
+ fCollisionGeometries(0),
+ fCurrentEvent(0),
+ fActiveStack(0),
+ fActiveEvent(-1),
+ fCurrentGenerator(0),
+ fNBgEvents(0)
{
//Copy constructor
cocktail.Copy(*this);
#include "AliGenerator.h"
-ClassImp(AliGenCocktailEntry)
+ClassImp(AliGenCocktailEntry);
-
-
-AliGenCocktailEntry::AliGenCocktailEntry()
+AliGenCocktailEntry::AliGenCocktailEntry():
+ fGenerator(0),
+ fNGenerated(0),
+ fFirst(-1),
+ fLast(-1),
+ fRate(0),
+ fKineBias(1),
+ fBias(1)
{
// Default constructor
- fGenerator =0;
- fNGenerated=0;
- fFirst=-1;
- fLast=-1;
- fRate=0;
- fKineBias=1;
- fBias=1;
+
}
AliGenCocktailEntry:: AliGenCocktailEntry
-(AliGenerator* Generator, const char * Name, Float_t RateExp):TNamed(Name, "Generator Cocktail Entry")
+(AliGenerator* Generator, const char * Name, Float_t RateExp):TNamed(Name, "Generator Cocktail Entry"),
+ fGenerator(Generator),
+ fNGenerated(0),
+ fFirst(-1),
+ fLast(-1),
+ fRate(RateExp),
+ fKineBias(1),
+ fBias(1)
{
-// Constructor using generator type, name and rate per event
- fGenerator=Generator;
- fNGenerated=0;
- fFirst=-1;
- fLast=-1;
- fRate=RateExp;
-//
- fKineBias=1;
- fBias=1;
+ // Constructor
}
AliGenCocktailEntry::AliGenCocktailEntry(const AliGenCocktailEntry &entry):
- TNamed(entry)
+ TNamed(entry),
+ fGenerator(0),
+ fNGenerated(0),
+ fFirst(-1),
+ fLast(-1),
+ fRate(0),
+ fKineBias(1),
+ fBias(1)
{
// Dummy copy constructor
entry.Copy(*this);
#include "AliGenEventHeader.h"
#include <TList.h>
-ClassImp(AliGenCocktailEventHeader)
+ClassImp(AliGenCocktailEventHeader);
-
-AliGenCocktailEventHeader::AliGenCocktailEventHeader()
+AliGenCocktailEventHeader::AliGenCocktailEventHeader():
+ fHeaders(0)
{
// Default Constructor
- fHeaders = 0x0;
}
-AliGenCocktailEventHeader::AliGenCocktailEventHeader(const char* name):AliGenEventHeader(name)
+AliGenCocktailEventHeader::AliGenCocktailEventHeader(const char* name):AliGenEventHeader(name),
+ fHeaders(0)
{
// Constructor
- fHeaders = 0x0;
}
AliGenCocktailEventHeader::AliGenCocktailEventHeader(const AliGenCocktailEventHeader &header):
-AliGenEventHeader(header)
+ AliGenEventHeader(header),
+ fHeaders(0)
{
// Copy Constructor
header.Copy(*this);
ClassImp(AliGenDoubleScan)
AliGenDoubleScan::AliGenDoubleScan()
- :AliGenScan(-1)
+ :AliGenScan(-1),
+ fDistance(0.)
{
+ // Default constructor
}
AliGenDoubleScan::AliGenDoubleScan(Int_t npart)
- :AliGenScan(npart)
+ :AliGenScan(npart),
+ fDistance(0.)
{
// Constructor
fName = "Double Scan";
ClassImp(AliGenExtFile)
AliGenExtFile::AliGenExtFile()
- :AliGenMC()
+ :AliGenMC(),
+ fFileName(0),
+ fReader(0)
{
// Constructor
//
// Read all particles
fNpart =- 1;
- fReader = 0;
}
AliGenExtFile::AliGenExtFile(Int_t npart)
- :AliGenMC(npart)
+ :AliGenMC(npart),
+ fFileName(0),
+ fReader(0)
{
// Constructor
fName = "ExtFile";
fTitle = "Primaries from ext. File";
- fReader = 0;
}
AliGenExtFile::AliGenExtFile(const AliGenExtFile & ExtFile):
- AliGenMC(ExtFile)
+ AliGenMC(ExtFile),
+ fFileName(0),
+ fReader(0)
{
// Copy constructor
ExtFile.Copy(*this);
ClassImp(AliGenFLUKAsource)
AliGenFLUKAsource::AliGenFLUKAsource()
- :AliGenerator(-1)
+ :AliGenerator(-1),
+ fIkine(6),
+ fAgeMax(1.e-5),
+ fAddWeight(1.),
+ fZshift(0.),
+ fFrac(0.),
+ fSourceId(-1),
+ fFileName(0),
+ fTreeChain(0),
+ fTreeFluka(0),
+ fIp(0.),
+ fIpp(0.),
+ fXi(0.),
+ fYi(0.),
+ fZi(0.),
+ fPx(0.),
+ fPy(0.),
+ fPz(0.),
+ fEkin(0.),
+ fZv(0.),
+ fRv(0.),
+ fItra(0.),
+ fIgas(0.),
+ fWgt(0.),
+ fEtag(0.),
+ fPtg(0.),
+ fAge(0.)
{
// Constructor
fName="FLUKA";
fTitle="FLUKA Boundary Source";
// Read in all particle types by default
- fIkine=6;
// Set maximum admitted age of particles to 1.e-05 by default
- fAgeMax=1.e-05;
// Do not add weight
- fAddWeight=1.;
// Shift the z-coordinate of the impact point by 4.5 cm only if it reads
// from specific boundary source to the chamber (fZshift=4.5;),else there
// is no need to shift as it reads boundary source for the whole volume of
// the Muon Arm; the default value corresponds to boundary source for the
// whole volume of the MUON Arm
- fZshift=0;
// Set the default file
- fFileName="";
-
- fTreeFluka=0;
fTreeChain = new TChain("h1");
//
// Read all particles
}
AliGenFLUKAsource::AliGenFLUKAsource(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fIkine(6),
+ fAgeMax(1.e-5),
+ fAddWeight(1.),
+ fZshift(0.),
+ fFrac(0.),
+ fSourceId(-1),
+ fFileName(""),
+ fTreeChain(new TChain("h1")),
+ fTreeFluka(0),
+ fIp(0.),
+ fIpp(0.),
+ fXi(0.),
+ fYi(0.),
+ fZi(0.),
+ fPx(0.),
+ fPy(0.),
+ fPz(0.),
+ fEkin(0.),
+ fZv(0.),
+ fRv(0.),
+ fItra(0.),
+ fIgas(0.),
+ fWgt(0.),
+ fEtag(0.),
+ fPtg(0.),
+ fAge(0.)
{
// Constructor
fName = "FLUKA";
fTitle = "FLUKA Boundary Source";
- // Read in all particle types by default
- fIkine=6;
- // Set maximum admitted age of particles to 1.e-05 by default
- fAgeMax=1.e-05;
- // Do not add weight
- fAddWeight=1.;
- // Shift the z-coordinate of the impact point by 4.5 cm only if it reads
- // from specific boundary source to the chamber (fZshift=4.5;),else there
- // is no need to shift as it reads boundary source for the whole volume of
- // the Muon Arm; the default value corresponds to boundary source for the
- // whole volume of the MUON Arm
- fZshift=0;
- // Set the default file
- fFileName="";
-
- fTreeFluka=0;
- fTreeChain = new TChain("h1");
- fSourceId=-1;
}
AliGenFLUKAsource::AliGenFLUKAsource(const AliGenFLUKAsource & FLUKAsource):
- AliGenerator(FLUKAsource)
+ AliGenerator(FLUKAsource),
+ fIkine(6),
+ fAgeMax(1.e-5),
+ fAddWeight(1.),
+ fZshift(0.),
+ fFrac(0.),
+ fSourceId(-1),
+ fFileName(0),
+ fTreeChain(0),
+ fTreeFluka(0),
+ fIp(0.),
+ fIpp(0.),
+ fXi(0.),
+ fYi(0.),
+ fZi(0.),
+ fPx(0.),
+ fPy(0.),
+ fPz(0.),
+ fEkin(0.),
+ fZv(0.),
+ fRv(0.),
+ fItra(0.),
+ fIgas(0.),
+ fWgt(0.),
+ fEtag(0.),
+ fPtg(0.),
+ fAge(0.)
{
// Copy constructor
FLUKAsource.Copy(*this);
//_____________________________________________________________________________
AliGenFixed::AliGenFixed()
- :AliGenerator()
+ :AliGenerator(),
+ fIpart(0),
+ fExplicit(kFALSE)
{
//
// Default constructor
//
- fIpart = 0;
- fExplicit = kFALSE;
}
//_____________________________________________________________________________
AliGenFixed::AliGenFixed(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fIpart(kProton),
+ fExplicit(kFALSE)
{
//
// Standard constructor
//
fName="Fixed";
fTitle="Fixed Particle Generator";
- // Generate Proton by default
- fIpart=kProton;
- fExplicit = kFALSE;
}
//_____________________________________________________________________________
}
Int_t i, nt;
//
+ Float_t o[3];
+ o[0] = fOrigin[0];
+ o[1] = fOrigin[1];
+ o[2] = fOrigin[2];
+
+ printf("Origin %f %f %f \n", o[0], o[1], o[2]);
+
+
for(i=0;i<fNpart;i++)
- PushTrack(fTrackIt,-1,fIpart,fP,fOrigin.GetArray(),polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,fP,o ,polar,0,kPPrimary,nt);
}
//_____________________________________________________________________________
fPhiFormula(0),
fCurrentForm(0),
fPtYHist(0),
- fPartTypes(0) {
+ fPartTypes(0)
+{
//
// Default constructor
//
//////////////////////////////////////////////////////////////////////////////////
-AliGenGeVSim::AliGenGeVSim(Float_t psi, Bool_t isMultTotal) : AliGenerator(-1) {
+AliGenGeVSim::AliGenGeVSim(Float_t psi, Bool_t isMultTotal)
+ : AliGenerator(-1),
+ fModel(0),
+ fPsi(psi),
+ fIsMultTotal(isMultTotal),
+ fPtFormula(0),
+ fYFormula(0),
+ fPhiFormula(0),
+ fCurrentForm(0),
+ fPtYHist(0),
+ fPartTypes(0)
+ {
//
// Standard Constructor.
//
fPsi = psi * TMath::Pi() / 180. ;
fIsMultTotal = isMultTotal;
- // initialization
+ // Initialization
fPartTypes = new TObjArray();
InitFormula();
}
+AliGenGeVSim::AliGenGeVSim(const AliGenGeVSim & ggs)
+ : AliGenerator(ggs),
+ fModel(0),
+ fPsi(0),
+ fIsMultTotal(0),
+ fPtFormula(0),
+ fYFormula(0),
+ fPhiFormula(0),
+ fCurrentForm(0),
+ fPtYHist(0),
+ fPartTypes(0)
+{
+ Fatal("copy ctor","Not implemented\n");
+}
+
+
//////////////////////////////////////////////////////////////////////////////////
AliGenGeVSim::~AliGenGeVSim() {
private:
- AliGenGeVSim(const AliGenGeVSim & ggs): AliGenerator(ggs)
- {Fatal("copy ctor","Not implemented\n");}
+ AliGenGeVSim(const AliGenGeVSim & ggs);
AliGenGeVSim & operator=(const AliGenGeVSim & /*ggs*/)
- {Fatal("= operator","Not implemented\n"); return *this;}
+ {Fatal("= operator","Not implemented\n"); return *this;}
Int_t fModel; // Selected model (1-7)
Float_t fPsi; // Reaction Plane angle (0-2pi)
////////////////////////////////////////////////////////////////////////////////
AliGenGeVSimEventHeader::AliGenGeVSimEventHeader()
- :AliGenEventHeader() {
+ :AliGenEventHeader(),
+ fEventPlane(0),
+ fEllipticFlow(0)
+{
//
// Default Constructor
//
-
- fEventPlane = 0;
- fEllipticFlow = 0;
}
////////////////////////////////////////////////////////////////////////////////
AliGenGeVSimEventHeader::AliGenGeVSimEventHeader(const char *name)
- :AliGenEventHeader(name) {
+ :AliGenEventHeader(name),
+ fEventPlane(0),
+ fEllipticFlow(0)
+ {
//
// Standard constructor
//
-
- fEventPlane = 0;
- fEllipticFlow = 0;
}
////////////////////////////////////////////////////////////////////////////////
fQRange(0.06),
fQNBins(60),
fGenerator(0x0),
+ fStackBuffer(0),
fBufferSize(5),
fNBinsToScale(Int_t(fQNBins*0.1)),
fDebug(0),
+ fSignalShapeCreated(0),
fMaxIterations(1000),
fMaxChiSquereChange(0.01),
fMaxChiSquerePerNDF(1.5),
fSamplePhiMax(TMath::TwoPi()+0.01),
fSignalRegion(0.0),
fMinFill(1000),
+ fSwapped(0),
fLogFile(0x0)
{
//default constructor
fQRange(0.06),
fQNBins(60),
fGenerator(0x0),
+ fStackBuffer(0),
fBufferSize(5),
fNBinsToScale(Int_t(fQNBins*0.1)),
fDebug(0),
fSamplePhiMax(TMath::TwoPi()+0.01),
fSignalRegion(0.0),
fMinFill(1000),
+ fSwapped(0),
fLogFile(0x0)
{
//default constructor
}
+
+AliGenHBTosl::AliGenHBTosl(const AliGenHBTosl & hbt):
+ AliGenerator(-1),
+ fQCoarseBackground(0x0),
+ fQCoarseSignal(0x0),
+ fQSignal(0x0),
+ fQBackground(0x0),
+ fQSecondSignal(0x0),
+ fQSecondBackground(0x0),
+ fQRange(0.06),
+ fQNBins(60),
+ fGenerator(0x0),
+ fStackBuffer(0),
+ fBufferSize(5),
+ fNBinsToScale(Int_t(fQNBins*0.1)),
+ fDebug(0),
+ fSignalShapeCreated(kFALSE),
+ fMaxIterations(1000),
+ fMaxChiSquereChange(0.01),
+ fMaxChiSquerePerNDF(1.5),
+ fQRadius(8.0),
+ fPID(kPiPlus),
+ fSamplePhiMin(-0.01),
+ fSamplePhiMax(TMath::TwoPi()+0.01),
+ fSignalRegion(0.0),
+ fMinFill(1000),
+ fSwapped(0),
+ fLogFile(0x0)
+{
+// Copy constructor
+ hbt.Copy(*this);
+}
/***********************************************************/
AliGenHBTosl::~AliGenHBTosl()
fSwapped = kTRUE;
}
+
+AliGenHBTosl& AliGenHBTosl::operator=(const AliGenHBTosl& rhs)
+{
+// Assignment operator
+ rhs.Copy(*this);
+ return *this;
+}
+
+void AliGenHBTosl::Copy(TObject&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
public:
AliGenHBTosl();
AliGenHBTosl(Int_t n,Int_t pid = 211);
+ AliGenHBTosl(const AliGenHBTosl& hbt);
virtual ~AliGenHBTosl();
void Init();
void TestCoarseSignal();
Bool_t CheckParticle(TParticle* p, TParticle* aupair,AliStack* stack);
+ void Copy(TObject&) const;
+ AliGenHBTosl & operator=(const AliGenHBTosl & rhs);
private:
TH3D* fQCoarseBackground;//Initial Background
TH3D* fQCoarseSignal;//signal calculated by multiplying coarse background and model function
ClassImp(AliGenHIJINGpara)
-AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para):
- AliGenerator(para)
-{
-// Copy constructor
- para.Copy(*this);
-}
//_____________________________________________________________________________
static Double_t ptpi(Double_t *px, Double_t *)
//_____________________________________________________________________________
AliGenHIJINGpara::AliGenHIJINGpara()
- :AliGenerator()
+ :AliGenerator(),
+ fNt(-1),
+ fNpartProd(0),
+ fPi0Decays(kFALSE),
+ fPtWgtPi(0.),
+ fPtWgtKa(0.),
+ fPtpi(0),
+ fPtka(0),
+ fETApic(0),
+ fETAkac(0),
+ fDecayer(0)
{
//
// Default constructor
//
- fPtpi = 0;
- fPtka = 0;
- fETApic = 0;
- fETAkac = 0;
- fDecayer = 0;
- fNt = -1;
- fNpartProd = 0;
SetCutVertexZ();
SetPtRange();
- SetPi0Decays();
}
//_____________________________________________________________________________
AliGenHIJINGpara::AliGenHIJINGpara(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fNt(-1),
+ fNpartProd(npart),
+ fPi0Decays(kFALSE),
+ fPtWgtPi(0.),
+ fPtWgtKa(0.),
+ fPtpi(0),
+ fPtka(0),
+ fETApic(0),
+ fETAkac(0),
+ fDecayer(0)
{
//
// Standard constructor
//
fName="HIJINGpara";
fTitle="HIJING Parametrisation Particle Generator";
- fPtpi = 0;
- fPtka = 0;
- fETApic = 0;
- fETAkac = 0;
- fDecayer = 0;
- fNt = -1;
- fNpartProd = npart;
SetCutVertexZ();
SetPtRange();
- SetPi0Decays();
+}
+
+AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para):
+ AliGenerator(para),
+ fNt(-1),
+ fNpartProd(0),
+ fPi0Decays(kFALSE),
+ fPtWgtPi(0.),
+ fPtWgtKa(0.),
+ fPtpi(0),
+ fPtka(0),
+ fETApic(0),
+ fETAkac(0),
+ fDecayer(0)
+{
+// Copy constructor
+ para.Copy(*this);
}
//_____________________________________________________________________________
}
AliGenHIJINGparaBa::AliGenHIJINGparaBa()
- :AliGenHIJINGpara()
+ :AliGenHIJINGpara(),
+ fPtba(0),
+ fETAba(0)
{
//
// Default constructor
//
fName="HIGINGparaBa";
fTitle="HIJING Parametrisation Particle Generator with Baryons";
- fETAba = 0;
- fPtba = 0;
}
//_____________________________________________________________________________
AliGenHIJINGparaBa::AliGenHIJINGparaBa(Int_t npart)
- :AliGenHIJINGpara(npart)
+ :AliGenHIJINGpara(npart),
+ fPtba(0),
+ fETAba(0)
{
//
// Standard constructor
//
fName="HIGINGparaBa";
fTitle="HIJING Parametrisation Particle Generator with Baryons";
- fETAba = 0;
- fPtba = 0;
}
-AliGenHIJINGparaBa::AliGenHIJINGparaBa(const AliGenHIJINGparaBa& para) : AliGenHIJINGpara(para)
+AliGenHIJINGparaBa::AliGenHIJINGparaBa(const AliGenHIJINGparaBa& para) :
+ AliGenHIJINGpara(para),
+ fPtba(0),
+ fETAba(0)
{
// Copy constructor
para.Copy(*this);
ClassImp(AliGenHalo)
AliGenHalo::AliGenHalo()
- :AliGenerator(-1)
+ :AliGenerator(-1),
+ fp(0),
+ fFileName(0)
{
// Constructor
fName="Halo";
//
// Read all particles
fNpart=-1;
- fp=0;
}
AliGenHalo::AliGenHalo(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fp(0),
+ fFileName(0)
{
// Constructor
fName="Halo";
//
// Read all particles
fNpart=-1;
- fp=0;
}
AliGenHalo::AliGenHalo(const AliGenHalo & Halo)
- :AliGenerator(Halo)
+ :AliGenerator(Halo),
+ fp(0),
+ fFileName(0)
{
// Copy constructor
Halo.Copy(*this);
ClassImp(AliGenHaloProtvino)
AliGenHaloProtvino::AliGenHaloProtvino()
- :AliGenerator(-1)
+ :AliGenerator(-1),
+ fFile(0),
+ fFileName(0),
+ fSide(1),
+ fRunPeriod(kY3D90),
+ fTimePerEvent(1.e-4),
+ fNskip(0),
+ fZ1(0),
+ fZ2(0),
+ fG1(0),
+ fG2(0),
+ fGPASize(0)
{
// Constructor
//
// Read all particles
fNpart = -1;
- fFile = 0;
- fSide = 1;
-//
- SetRunPeriod();
- SetTimePerEvent();
SetAnalog(0);
}
AliGenHaloProtvino::AliGenHaloProtvino(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fFile(0),
+ fFileName(0),
+ fSide(1),
+ fRunPeriod(kY3D90),
+ fTimePerEvent(1.e-4),
+ fNskip(0),
+ fZ1(0),
+ fZ2(0),
+ fG1(0),
+ fG2(0),
+ fGPASize(0)
{
// Constructor
fName = "Halo";
fTitle= "Halo from LHC Tunnel";
//
fNpart = npart;
- fFile = 0;
- fSide = 1;
//
- SetRunPeriod();
- SetTimePerEvent();
SetAnalog(0);
}
AliGenHaloProtvino::AliGenHaloProtvino(const AliGenHaloProtvino & HaloProtvino):
- AliGenerator(HaloProtvino)
+ AliGenerator(HaloProtvino),
+ fFile(0),
+ fFileName(0),
+ fSide(1),
+ fRunPeriod(kY3D90),
+ fTimePerEvent(1.e-4),
+ fNskip(0),
+ fZ1(0),
+ fZ2(0),
+ fG1(0),
+ fG2(0),
+ fGPASize(0)
{
// Copy constructor
HaloProtvino.Copy(*this);
ClassImp(AliGenMC)
AliGenMC::AliGenMC()
- :AliGenerator()
+ :AliGenerator(),
+ fParticles(0),
+ fParentSelect(8),
+ fChildSelect(8),
+ fCutOnChild(0),
+ fChildPtMin(0.),
+ fChildPtMax(1.e10),
+ fChildPMin(0.),
+ fChildPMax(1.e10),
+ fChildPhiMin(0.),
+ fChildPhiMax(2. * TMath::Pi()),
+ fChildThetaMin(0.),
+ fChildThetaMax(TMath::Pi()),
+ fChildYMin(-12.),
+ fChildYMax(12.),
+ fXingAngleX(0.),
+ fXingAngleY(0.),
+ fForceDecay(kAll),
+ fMaxLifeTime(1.e-15),
+ fAProjectile(1),
+ fZProjectile(1),
+ fATarget(1),
+ fZTarget(1),
+ fProjectile("P"),
+ fTarget("P"),
+ fDyBoost(0.),
+ fGeometryAcceptance(0),
+ fPdgCodeParticleforAcceptanceCut(0),
+ fNumberOfAcceptedParticles(2)
{
// Default Constructor
- SetCutOnChild();
- SetChildMomentumRange();
- SetChildPtRange();
- SetChildPhiRange();
- SetChildThetaRange();
- SetChildYRange();
- SetMaximumLifetime();
- SetGeometryAcceptance();
- SetPdgCodeParticleforAcceptanceCut();
- SetNumberOfAcceptedParticles();
- SetTarget();
- SetProjectile();
- fParentSelect.Set(8);
- fChildSelect.Set(8);
- fForceDecay = kAll;
}
AliGenMC::AliGenMC(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fParticles(0),
+ fParentSelect(8),
+ fChildSelect(8),
+ fCutOnChild(0),
+ fChildPtMin(0.),
+ fChildPtMax(1.e10),
+ fChildPMin(0.),
+ fChildPMax(1.e10),
+ fChildPhiMin(0.),
+ fChildPhiMax(2. * TMath::Pi()),
+ fChildThetaMin(0.),
+ fChildThetaMax(TMath::Pi()),
+ fChildYMin(-12.),
+ fChildYMax(12.),
+ fXingAngleX(0.),
+ fXingAngleY(0.),
+ fForceDecay(kAll),
+ fMaxLifeTime(1.e-15),
+ fAProjectile(1),
+ fZProjectile(1),
+ fATarget(1),
+ fZTarget(1),
+ fProjectile("P"),
+ fTarget("P"),
+ fDyBoost(0.),
+ fGeometryAcceptance(0),
+ fPdgCodeParticleforAcceptanceCut(0),
+ fNumberOfAcceptedParticles(2)
{
// Constructor
- SetCutOnChild();
- SetChildMomentumRange();
- SetChildPtRange();
- SetChildPhiRange();
- SetChildThetaRange();
- SetChildYRange();
//
- fParentSelect.Set(8);
- fChildSelect.Set(8);
for (Int_t i=0; i<8; i++) fParentSelect[i]=fChildSelect[i]=0;
- SetMaximumLifetime();
- SetGeometryAcceptance();
- SetPdgCodeParticleforAcceptanceCut();
- SetNumberOfAcceptedParticles();
- SetTarget();
- SetProjectile();
- fForceDecay = kAll;
}
AliGenMC::AliGenMC(const AliGenMC & mc):
- AliGenerator(mc)
+ AliGenerator(mc),
+ fParticles(0),
+ fParentSelect(8),
+ fChildSelect(8),
+ fCutOnChild(0),
+ fChildPtMin(0.),
+ fChildPtMax(1.e10),
+ fChildPMin(0.),
+ fChildPMax(1.e10),
+ fChildPhiMin(0.),
+ fChildPhiMax(2. * TMath::Pi()),
+ fChildThetaMin(0.),
+ fChildThetaMax(TMath::Pi()),
+ fChildYMin(-12.),
+ fChildYMax(12.),
+ fXingAngleX(0.),
+ fXingAngleY(0.),
+ fForceDecay(kAll),
+ fMaxLifeTime(1.e-15),
+ fAProjectile(1),
+ fZProjectile(1),
+ fATarget(1),
+ fZTarget(1),
+ fProjectile("P"),
+ fTarget("P"),
+ fDyBoost(0.),
+ fGeometryAcceptance(0),
+ fPdgCodeParticleforAcceptanceCut(0),
+ fNumberOfAcceptedParticles(2)
{
// Copy constructor
mc.Copy(*this);
virtual void SetProjectile(TString proj="P", Int_t a = 1, Int_t z = 1)
{fProjectile = proj; fAProjectile = a; fZProjectile = z;}
virtual void SetTarget(TString tar="P", Int_t a = 1, Int_t z = 1)
- {fTarget = tar; fATarget = a; fZTarget = z;}
+ {fTarget = tar; fATarget = a; fZTarget = z;}
+ virtual void SetCrossingAngle(Float_t phiX, Float_t phiY) {fXingAngleX = phiX; fXingAngleY = phiY;}
virtual void Boost();
protected:
Float_t fChildThetaMax; // Children maximum theta
Float_t fChildYMin; // Children minimum y
Float_t fChildYMax; // Children maximum y
+ Float_t fXingAngleX; // Crossing angle X
+ Float_t fXingAngleY; // Crossing angle Y
Decay_t fForceDecay; // Decay channel forced
Float_t fMaxLifeTime; // Maximum lifetime for unstable particles
Int_t fAProjectile; // Projectile A
//________________________________________________________________________
AliGenMUONCocktail::AliGenMUONCocktail()
- :AliGenCocktail()
+ :AliGenCocktail(),
+ fFastGlauber (0x0),
+ fTotalRate(0),
+ fMuonMultiplicity(1),
+ fMuonPtCut(1.),
+ fMuonThetaMinCut(171.),
+ fMuonThetaMaxCut(178.),
+ fNSucceded(0),
+ fNGenerated(0),
+ fLowImpactParameter(0.),
+ fHighImpactParameter(5.),
+ fAverageImpactParameter(0.),
+ fNumberOfCollisions(0.),
+ fNumberOfParticipants(0.),
+ fHadronicMuons(kTRUE),
+ fInvMassCut (kFALSE),
+ fInvMassMinCut (0.),
+ fInvMassMaxCut (100.)
{
// Constructor
- fFastGlauber =0x0;
- fTotalRate =0;
- fNSucceded=0;
- fNGenerated=0;
- fMuonMultiplicity=1;
- fMuonPtCut= 1.;
- fMuonThetaMinCut=171.;
- fMuonThetaMaxCut=178.;
- fLowImpactParameter = 0.;
- fHighImpactParameter = 5.;
- fAverageImpactParameter =0.;
- fNumberOfCollisions = 0.;
- fNumberOfParticipants = 0.;
- fHadronicMuons = kTRUE;
- fInvMassCut = kFALSE;
- fInvMassMinCut = 0.;
- fInvMassMaxCut = 100.;
}
//_________________________________________________________________________
AliGenMUONCocktail::AliGenMUONCocktail(const AliGenMUONCocktail & cocktail):
- AliGenCocktail(cocktail)
+ AliGenCocktail(cocktail),
+ fFastGlauber(0x0),
+ fTotalRate(0),
+ fMuonMultiplicity(1),
+ fMuonPtCut(1.),
+ fMuonThetaMinCut(171.),
+ fMuonThetaMaxCut(178.),
+ fNSucceded(0),
+ fNGenerated(0),
+ fLowImpactParameter(0.),
+ fHighImpactParameter(5.),
+ fAverageImpactParameter(0.),
+ fNumberOfCollisions(0.),
+ fNumberOfParticipants(0.),
+ fHadronicMuons(kTRUE),
+ fInvMassCut (kFALSE),
+ fInvMassMinCut (0.),
+ fInvMassMaxCut (100.)
{
// Copy constructor
- fFastGlauber =0x0;
- fTotalRate =0;
- fNSucceded=0;
- fNGenerated=0;
- fMuonMultiplicity=1;
- fMuonPtCut= 1.;
- fMuonThetaMinCut=171.;
- fMuonThetaMaxCut=178.;
- fLowImpactParameter = 0.;
- fHighImpactParameter = 5.;
- fAverageImpactParameter =0.;
- fNumberOfCollisions = 0.;
- fNumberOfParticipants = 0.;
- fHadronicMuons = kTRUE;
- fInvMassCut = kFALSE;
- fInvMassMinCut = 0.;
- fInvMassMaxCut = 100.;
}
+
//_________________________________________________________________________
AliGenMUONCocktail::~AliGenMUONCocktail()
{
}
+AliGenMUONCocktail& AliGenMUONCocktail::operator=(const AliGenMUONCocktail& rhs)
+{
+// Assignment operator
+ rhs.Copy(*this);
+ return *this;
+}
+void AliGenMUONCocktail::Copy(TObject &) const
+{
+ Fatal("Copy","Not implemented!\n");
+}
{ fInvMassMinCut=MassMin;
fInvMassMaxCut=MassMax;
fInvMassCut = kTRUE; }
-
- protected:
-
+ private:
+ AliGenMUONCocktail& operator=(const AliGenMUONCocktail & rhs);
+ void Copy(TObject &cocktail) const;
//
private:
AliFastGlauber * fFastGlauber; //! Fast glauber calculations
//________________________________________________________________________
AliGenMUONCocktailpp::AliGenMUONCocktailpp()
- :AliGenCocktail()
+ :AliGenCocktail(),
+ fTotalRate(0),
+ fMuonMultiplicity(0),
+ fMuonPtCut(0.),
+ fMuonThetaMinCut(0.),
+ fMuonThetaMaxCut(0.),
+ fNSucceded(0),
+ fNGenerated(0)
{
// Constructor
- fTotalRate =0;
- fNSucceded=0;
- fNGenerated=0;
- fMuonMultiplicity=0;
- fMuonPtCut= 0.;
- fMuonThetaMinCut=0.;
- fMuonThetaMaxCut=0.;
}
//_________________________________________________________________________
AliGenMUONCocktailpp::AliGenMUONCocktailpp(const AliGenMUONCocktailpp & cocktail):
- AliGenCocktail(cocktail)
+ AliGenCocktail(cocktail),
+ fTotalRate(0),
+ fMuonMultiplicity(0),
+ fMuonPtCut(0.),
+ fMuonThetaMinCut(0.),
+ fMuonThetaMaxCut(0.),
+ fNSucceded(0),
+ fNGenerated(0)
{
// Copy constructor
- fTotalRate =0;
- fNSucceded=0;
- fNGenerated=0;
- fMuonMultiplicity=0;
- fMuonPtCut=0.;
- fMuonThetaMinCut=0.;
- fMuonThetaMaxCut=0.;
}
//_________________________________________________________________________
AliGenMUONCocktailpp::~AliGenMUONCocktailpp()
//End_Html
//____________________________________________________________
-AliGenParam::AliGenParam()
+ AliGenParam::AliGenParam():
+ fPtParaFunc(0),
+ fYParaFunc(0),
+ fIpParaFunc(0),
+ fPtPara(0),
+ fYPara(0),
+ fParam(0),
+ fdNdy0(0.),
+ fYWgt(0.),
+ fPtWgt(0.),
+ fBias(0.),
+ fTrials(0),
+ fDeltaPt(0.01),
+ fDecayer(0)
{
-// Deafault constructor
- fPtPara = 0;
- fYPara = 0;
- fParam = 0;
- fAnalog = kAnalog;
- SetDeltaPt();
- fDecayer = 0;
-
-
+// Default constructor
}
//____________________________________________________________
-AliGenParam::AliGenParam(Int_t npart, AliGenLib * Library, Int_t param, char* tname):AliGenMC(npart)
+AliGenParam::AliGenParam(Int_t npart, AliGenLib * Library, Int_t param, char* tname)
+ :AliGenMC(npart),
+ fPtParaFunc(Library->GetPt(param, tname)),
+ fYParaFunc (Library->GetY (param, tname)),
+ fIpParaFunc(Library->GetIp(param, tname)),
+ fPtPara(0),
+ fYPara(0),
+ fParam(param),
+ fdNdy0(0.),
+ fYWgt(0.),
+ fPtWgt(0.),
+ fBias(0.),
+ fTrials(0),
+ fDeltaPt(0.01),
+ fDecayer(0)
{
// Constructor using number of particles parameterisation id and library
fName = "Param";
fTitle= "Particle Generator using pT and y parameterisation";
-
- fPtParaFunc = Library->GetPt(param, tname);
- fYParaFunc = Library->GetY (param, tname);
- fIpParaFunc = Library->GetIp(param, tname);
-
- fPtPara = 0;
- fYPara = 0;
- fParam = param;
fAnalog = kAnalog;
SetForceDecay();
- SetDeltaPt();
}
//____________________________________________________________
-AliGenParam::AliGenParam(Int_t npart, Int_t param, const char* tname, const char* name):AliGenMC(npart)
+AliGenParam::AliGenParam(Int_t npart, Int_t param, const char* tname, const char* name):
+ AliGenMC(npart),
+ fPtParaFunc(0),
+ fYParaFunc (0),
+ fIpParaFunc(0),
+ fPtPara(0),
+ fYPara(0),
+ fParam(param),
+ fdNdy0(0.),
+ fYWgt(0.),
+ fPtWgt(0.),
+ fBias(0.),
+ fTrials(0),
+ fDeltaPt(0.01),
+ fDecayer(0)
{
// Constructor using parameterisation id and number of particles
//
- fName = name;
- fTitle= "Particle Generator using pT and y parameterisation";
+ fName = name;
+ fTitle= "Particle Generator using pT and y parameterisation";
AliGenLib* pLibrary = new AliGenMUONlib();
-
fPtParaFunc = pLibrary->GetPt(param, tname);
fYParaFunc = pLibrary->GetY (param, tname);
fIpParaFunc = pLibrary->GetIp(param, tname);
- fPtPara = 0;
- fYPara = 0;
- fParam = param;
fAnalog = kAnalog;
fChildSelect.Set(5);
for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
SetChildPtRange();
SetChildPhiRange();
SetChildThetaRange();
- SetDeltaPt();
}
//____________________________________________________________
Double_t (*PtPara) (Double_t*, Double_t*),
Double_t (*YPara ) (Double_t* ,Double_t*),
Int_t (*IpPara) (TRandom *))
- :AliGenMC(npart)
+ :AliGenMC(npart),
+
+ fPtParaFunc(PtPara),
+ fYParaFunc(YPara),
+ fIpParaFunc(IpPara),
+ fPtPara(0),
+ fYPara(0),
+ fParam(param),
+ fdNdy0(0.),
+ fYWgt(0.),
+ fPtWgt(0.),
+ fBias(0.),
+ fTrials(0),
+ fDeltaPt(0.01),
+ fDecayer(0)
{
// Constructor
// Gines Martinez 1/10/99
fName = "Param";
fTitle= "Particle Generator using pT and y parameterisation";
- fPtParaFunc = PtPara;
- fYParaFunc = YPara;
- fIpParaFunc = IpPara;
-//
- fPtPara = 0;
- fYPara = 0;
- fParam = param;
fAnalog = kAnalog;
fChildSelect.Set(5);
for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
SetChildPtRange();
SetChildPhiRange();
SetChildThetaRange();
- SetDeltaPt();
}
AliGenParam::AliGenParam(const AliGenParam & Param)
- :AliGenMC(Param)
+ :AliGenMC(Param),
+ fPtParaFunc(0),
+ fYParaFunc(0),
+ fIpParaFunc(0),
+ fPtPara(0),
+ fYPara(0),
+ fParam(0),
+ fdNdy0(0.),
+ fYWgt(0.),
+ fPtWgt(0.),
+ fBias(0.),
+ fTrials(0),
+ fDeltaPt(0.01),
+ fDecayer(0)
{
// Copy constructor
Param.Copy(*this);
#include "AliGenReaderCwn.h"
-ClassImp(AliGenReaderCwn)
-
-
-AliGenReaderCwn::AliGenReaderCwn()
+ClassImp(AliGenReaderCwn);
+
+AliGenReaderCwn::AliGenReaderCwn():
+ fNcurrent(0),
+ fNparticle(0),
+ fNparticleMax(0),
+ fTreeNtuple(0),
+ fNihead(0),
+ fNrhead(0),
+ fIdpart(0),
+ fTheta(0.),
+ fPhi(0.),
+ fP(0.),
+ fE(0.)
{
// Default constructor
- fNcurrent = 0;
- fTreeNtuple = 0;
}
+AliGenReaderCwn::AliGenReaderCwn(const AliGenReaderCwn &reader):
+ AliGenReader(reader),
+ fNcurrent(0),
+ fNparticle(0),
+ fNparticleMax(0),
+ fTreeNtuple(0),
+ fNihead(0),
+ fNrhead(0),
+ fIdpart(0),
+ fTheta(0.),
+ fPhi(0.),
+ fP(0.),
+ fE(0.)
+{
+ // Copy constructor
+ reader.Copy(*this);
+}
+
+
AliGenReaderCwn::~AliGenReaderCwn()
{
delete fTreeNtuple;
{
public:
AliGenReaderCwn();
-
- AliGenReaderCwn(const AliGenReaderCwn &reader):AliGenReader(reader)
- {reader.Copy(*this);}
+ AliGenReaderCwn(const AliGenReaderCwn &reader);
virtual ~AliGenReaderCwn();
// Initialise
virtual void Init();
#include "AliGenReaderEMD.h"
-ClassImp(AliGenReaderEMD)
-
-
- // -----------------------------------------------------------------------------------
-AliGenReaderEMD::AliGenReaderEMD()
+ClassImp(AliGenReaderEMD);
+
+AliGenReaderEMD::AliGenReaderEMD():
+ fStartEvent(0),
+ fNcurrent(0),
+ fNparticle(0),
+ fTreeNtuple(0),
+ fIPSide(0),
+ fPcToTrack(0),
+ fNnLeft(0),
+ fEnLeft(0),
+ fNnRight(0),
+ fEnRight(0),
+ fNpLeft(0),
+ fEtapLeft(0),
+ fNpRight(0),
+ fEtapRight(0)
{
// Default constructor
- fStartEvent = 0;
- fTreeNtuple = 0;
- fIPSide = 0;
- fPcToTrack = 0;
}
+AliGenReaderEMD::AliGenReaderEMD(const AliGenReaderEMD &reader):
+ AliGenReader(reader),
+ fStartEvent(0),
+ fNcurrent(0),
+ fNparticle(0),
+ fTreeNtuple(0),
+ fIPSide(0),
+ fPcToTrack(0),
+ fNnLeft(0),
+ fEnLeft(0),
+ fNnRight(0),
+ fEnRight(0),
+ fNpLeft(0),
+ fEtapLeft(0),
+ fNpRight(0),
+ fEtapRight(0)
+{
+ // Copy Constructor
+ reader.Copy(*this);
+}
// -----------------------------------------------------------------------------------
AliGenReaderEMD::~AliGenReaderEMD()
{
public:
AliGenReaderEMD();
- AliGenReaderEMD(const AliGenReaderEMD &reader):AliGenReader(reader)
- {reader.Copy(*this);}
+ AliGenReaderEMD(const AliGenReaderEMD &reader);
virtual ~AliGenReaderEMD();
AliGenReaderEMD & operator=(const AliGenReaderEMD & rhs);
// Initialise
#include "AliGenReaderEcalHijing.h"
-ClassImp(AliGenReaderEcalHijing)
-
-
-AliGenReaderEcalHijing::AliGenReaderEcalHijing()
+ClassImp(AliGenReaderEcalHijing);
+
+AliGenReaderEcalHijing::AliGenReaderEcalHijing():
+ fNcurrent(0),
+ fNparticle(0),
+ fTreeNtuple(0),
+ fNjatt(0),
+ fNahij(0),
+ fNphij(0)
{
// Default constructor
- fNcurrent = 0;
- fTreeNtuple = 0;
+}
+
+AliGenReaderEcalHijing::AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader):
+ AliGenReader(reader),
+ fNcurrent(0),
+ fNparticle(0),
+ fTreeNtuple(0),
+ fNjatt(0),
+ fNahij(0),
+ fNphij(0)
+{
+ // Copy constructor
+ reader.Copy(*this);
}
void AliGenReaderEcalHijing::Init()
public:
AliGenReaderEcalHijing();
- AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader):AliGenReader(reader)
- {reader.Copy(*this);}
+ AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader);
virtual ~AliGenReaderEcalHijing(){;}
// Initialise
virtual void Init();
ClassImp(AliGenReaderEcalJets)
-AliGenReaderEcalJets::AliGenReaderEcalJets()
+AliGenReaderEcalJets::AliGenReaderEcalJets():
+ fNcurrent(0),
+ fNparticle(0),
+ fNev(0),
+ fNpart(0),
+ fNjet(0),
+ fNsjet(0),
+ fNpjet(0),
+ fTreeNtuple(0)
{
// Default constructor
- fNcurrent = 0;
- fTreeNtuple = 0;
+}
+
+ AliGenReaderEcalJets::AliGenReaderEcalJets(const AliGenReaderEcalJets &reader)
+ :AliGenReader(reader),
+ fNcurrent(0),
+ fNparticle(0),
+ fNev(0),
+ fNpart(0),
+ fNjet(0),
+ fNsjet(0),
+ fNpjet(0),
+ fTreeNtuple(0)
+{
+ // Copy Constructor
+ reader.Copy(*this);
}
void AliGenReaderEcalJets::Init()
{
public:
AliGenReaderEcalJets();
-
- AliGenReaderEcalJets(const AliGenReaderEcalJets &reader):AliGenReader(reader)
- {reader.Copy(*this);}
+ AliGenReaderEcalJets(const AliGenReaderEcalJets &reader);
virtual ~AliGenReaderEcalJets(){;}
// Initialise
virtual void Init();
ClassImp(AliGenScan)
AliGenScan::AliGenScan()
- :AliGenerator(-1)
+ :AliGenerator(-1),
+ fXCmin(0),
+ fXCmax(0),
+ fNx(1),
+ fYCmin(0),
+ fYCmax(0),
+ fNy(1),
+ fZmin(0),
+ fZmax(0),
+ fNz(1),
+ fIpart(0)
{
// Constructor
- fXCmin=0;
- fXCmax=0;
- fNx=1;
- fYCmin=0;
- fYCmax=0;
- fNy=1;
- fZmin=0;
- fZmax=0;
- fNz=1;
//
// Read all particles
fNpart=-1;
}
AliGenScan::AliGenScan(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fXCmin(0),
+ fXCmax(0),
+ fNx(1),
+ fYCmin(0),
+ fYCmax(0),
+ fNy(1),
+ fZmin(0),
+ fZmax(0),
+ fNz(1),
+ fIpart(0)
{
// Constructor
fName = "Scan";
fTitle = "Generator for particles on a grid";
-
-
- fXCmin=0;
- fXCmax=0;
- fNx=1;
- fYCmin=0;
- fYCmax=0;
- fNy=1;
- fZmin=0;
- fZmax=0;
- fNz=1;
}
//____________________________________________________________
#include "AliGenSlowNucleons.h"
#include "AliSlowNucleonModel.h"
- ClassImp(AliGenSlowNucleons)
+ClassImp(AliGenSlowNucleons);
+
- AliGenSlowNucleons::AliGenSlowNucleons():AliGenerator(-1)
+AliGenSlowNucleons::AliGenSlowNucleons()
+ :AliGenerator(-1),
+ fCMS(0.),
+ fMomentum(0.),
+ fBeta(0.),
+ fPmax (0.),
+ fATarget (0.),
+ fZTarget (0.),
+ fCharge(0),
+ fProtonDirection(0.),
+ fTemperatureG(0.),
+ fBetaSourceG(0.),
+ fTemperatureB(0.),
+ fBetaSourceB(0.),
+ fNgp(0),
+ fNgn(0),
+ fNbp(0),
+ fNbn(0),
+ fDebug(0),
+ fDebugHist1(0),
+ fDebugHist2(0),
+ fThetaDistribution(),
+ fCosThetaGrayHist(),
+ fCosTheta(),
+ fSlowNucleonModel(0)
{
// Default constructor
- fSlowNucleonModel = 0;
fCollisionGeometry = 0;
- fDebugHist1 = 0;
- fDebugHist2 = 0;
}
AliGenSlowNucleons::AliGenSlowNucleons(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fCMS(14000.),
+ fMomentum(0.),
+ fBeta(0.),
+ fPmax (10.),
+ fATarget (208.),
+ fZTarget (82.),
+ fCharge(1),
+ fProtonDirection(0.),
+ fTemperatureG(0.04),
+ fBetaSourceG(0.05),
+ fTemperatureB(0.004),
+ fBetaSourceB(0.),
+ fNgp(0),
+ fNgn(0),
+ fNbp(0),
+ fNbn(0),
+ fDebug(0),
+ fDebugHist1(0),
+ fDebugHist2(0),
+ fThetaDistribution(),
+ fCosThetaGrayHist(),
+ fCosTheta(),
+ fSlowNucleonModel(new AliSlowNucleonModel())
{
// Constructor
fName = "SlowNucleons";
fTitle = "Generator for gray particles in pA collisions";
- SetPmax();
- SetTarget();
- SetNominalCmsEnergy();
- SetCharge();
- SetTemperature();
- SetBetaSource();
- fSlowNucleonModel = new AliSlowNucleonModel();
fCollisionGeometry = 0;
- fDebug = 0;
}
//____________________________________________________________
AliGenSlowNucleons::AliGenSlowNucleons(const AliGenSlowNucleons & sn):
- AliGenerator(sn)
+ AliGenerator(sn),
+ fCMS(0.),
+ fMomentum(0.),
+ fBeta(0.),
+ fPmax (0.),
+ fATarget (0.),
+ fZTarget (0.),
+ fCharge(0),
+ fProtonDirection(0.),
+ fTemperatureG(0.),
+ fBetaSourceG(0.),
+ fTemperatureB(0.),
+ fBetaSourceB(0.),
+ fNgp(0),
+ fNgn(0),
+ fNbp(0),
+ fNbn(0),
+ fDebug(0),
+ fDebugHist1(0),
+ fDebugHist2(0),
+ fThetaDistribution(),
+ fCosThetaGrayHist(),
+ fCosTheta(),
+ fSlowNucleonModel(0)
{
// Copy constructor
sn.Copy(*this);
//_____________________________________________________________________________
AliGenThetaSlice::AliGenThetaSlice()
- :AliGenerator()
+ :AliGenerator(),
+ fIpart(0)
{
//
// Default constructor
//
- fIpart=0;
}
//_____________________________________________________________________________
AliGenThetaSlice::AliGenThetaSlice(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart),
+ fIpart(kProton)
{
//
// Standard constructor
//
fName = "ThetaSlice";
fTitle = "Particle generator - const. phi, slices in theta";
- // Generate Proton by default
- fIpart=kProton;
}
//_____________________________________________________________________________
#include "AliCollisionGeometry.h"
#include <TRandom.h>
-ClassImp(AliSlowNucleonModelExp)
+ClassImp(AliSlowNucleonModelExp);
-AliSlowNucleonModelExp::AliSlowNucleonModelExp()
+
+AliSlowNucleonModelExp::AliSlowNucleonModelExp():
+ fP(82),
+ fN (208 - 82),
+ fAlphaGray(2.),
+ fAlphaBlack(4.)
{
//
// Default constructor
//
- fP = 82;
- fN = 208 - 82;
- fAlphaGray = 2.;
- fAlphaBlack = 4.;
}
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff