fOrigin[2] = 0.;
}
-//_____________________________________________________________________________
-AliGenACORDE::AliGenACORDE(const AliGenACORDE& gen)
- : AliGenerator(gen)
-{
- //
- // Copy constructor
- //
- gen.Copy(*this);
-}
-
-//_____________________________________________________________________________
-AliGenACORDE& AliGenACORDE::operator=(const AliGenACORDE& gen)
-{
- //
- // Asingment operator
- //
- gen.Copy(*this);
- return *this;
-}
-
//_____________________________________________________________________________
AliGenACORDE::~AliGenACORDE()
{
public:
AliGenACORDE();
AliGenACORDE(Int_t npart);
- AliGenACORDE(const AliGenACORDE& gen);
virtual ~AliGenACORDE();
- AliGenACORDE& operator= (const AliGenACORDE& gen);
-
virtual void Init();
virtual void Generate();
virtual void SetPart(Int_t part) {fIpart = part;}
void GenerateOneSingleMuon(Bool_t withFlatMomentum=kFALSE);
private:
+ AliGenACORDE(const AliGenACORDE& gen);
+ AliGenACORDE& operator= (const AliGenACORDE& gen);
+
Int_t fIpart; //! Particle type.
ECRMode fCRMode; //! Cosmic muons generation method flag
TString* fCRModeName; //! Cosmic muons generation mode name
fOsigma[2] = 2000.;
}
-AliGenBeamGas::AliGenBeamGas(const AliGenBeamGas & beamgas):
- AliGenExtFile(beamgas),
- fInteractions(1)
-{
-// Copy constructor
- beamgas.Copy(*this);
-}
//____________________________________________________________
AliGenBeamGas::~AliGenBeamGas()
-void AliGenBeamGas::Copy(TObject&) const
-{
- //
- // Copy
- //
- Fatal("Copy","Not implemented!\n");
-}
-
-
-
-
{
public:
AliGenBeamGas();
- AliGenBeamGas(const AliGenBeamGas &beamgas);
virtual ~AliGenBeamGas();
//
virtual void SetNumberOfInteractions(Int_t n)
protected:
Int_t fInteractions; // Number of interactions
private:
- void Copy(TObject&) const;
+ AliGenBeamGas(const AliGenBeamGas &beamgas);
+ AliGenBeamGas & operator=(const AliGenBeamGas &beamgas);
ClassDef(AliGenBeamGas,1) //Generator for beam gas interactions
fTitle= "Particle Generator using cocktail of generators";
}
-AliGenCocktail::AliGenCocktail(const AliGenCocktail & cocktail):
- AliGenerator(cocktail),
- fNGenerators(0),
- fRandom(kFALSE),
- fUsePerEventRate(kFALSE),
- fProb(0),
- fEntries(0),
- flnk1(0),
- flnk2(0),
- fHeader(0)
-{
-// Copy constructor
- cocktail.Copy(*this);
-}
-
AliGenCocktail::~AliGenCocktail()
{
// Destructor
// Add a header to the list
if (fHeader) fHeader->AddHeader(header);
}
-
-AliGenCocktail& AliGenCocktail::operator=(const AliGenCocktail& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return (*this);
-}
-void AliGenCocktail::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented!\n");
-}
{
public:
AliGenCocktail();
- AliGenCocktail(const AliGenCocktail &cocktail);
virtual ~AliGenCocktail();
virtual void Init();
AliGenCocktailEntry* NextGenerator();
void FirstGeneratorPair(AliGenCocktailEntry*&e1, AliGenCocktailEntry*&e2);
void NextGeneratorPair (AliGenCocktailEntry*&e1, AliGenCocktailEntry*&e2);
- AliGenCocktail & operator=(const AliGenCocktail & rhs);
virtual void AddHeader(AliGenEventHeader* header);
protected:
//
private:
- void Copy(TObject &arun) const;
+ AliGenCocktail(const AliGenCocktail &cocktail);
+ AliGenCocktail & operator=(const AliGenCocktail & rhs);
+
ClassDef(AliGenCocktail,1) // Particle cocktail generator a la SHAKER
};
SetName("AliGenCocktailAfterBurner");
SetTitle("AliGenCocktailAfterBurner");
}
-/*********************************************************************/
-AliGenCocktailAfterBurner::AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& 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);
-}
/*********************************************************************/
/*********************************************************************/
/*********************************************************************/
-AliGenCocktailAfterBurner& AliGenCocktailAfterBurner::operator=(const AliGenCocktailAfterBurner& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return (*this);
-}
-/*********************************************************************/
-/*********************************************************************/
-
AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n) const
{
//Returns the pointer to the N'th stack (event)
return kPNoProcess;
}
-void AliGenCocktailAfterBurner::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented!\n");
-}
public:
AliGenCocktailAfterBurner();
- AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& in);
virtual ~AliGenCocktailAfterBurner();
- AliGenCocktailAfterBurner & operator=(const AliGenCocktailAfterBurner & rhs);
virtual void Init();
virtual void Generate();
//needed by some afterburners that works better with higher statistics
//this generates such a artificial one
private:
- void Copy(TObject &arun) const;
+ AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& in);
+ AliGenCocktailAfterBurner & operator=(const AliGenCocktailAfterBurner & rhs);
ClassDef(AliGenCocktailAfterBurner,2) // Particle cocktail generator a la SHAKER
//background events added
SetChildThetaRange();
}
-//____________________________________________________________
-AliGenCorrHF::AliGenCorrHF(const AliGenCorrHF & CorrHF)
- :AliGenMC(CorrHF),
- fFileName(0),
- fFile(0),
- fQuark(0),
- fBias(0.),
- fTrials(0),
- fDecayer(0)
-{
-// Copy constructor
- CorrHF.Copy(*this);
-}
-
//____________________________________________________________
AliGenCorrHF::~AliGenCorrHF()
{
SetHighWaterMark(nt);
}
-//____________________________________________________________________________________
-AliGenCorrHF& AliGenCorrHF::operator=(const AliGenCorrHF& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
//____________________________________________________________________________________
Int_t AliGenCorrHF::IpCharm(TRandom* ran)
{
AliGenCorrHF();
AliGenCorrHF(Int_t npart, Int_t param);
AliGenCorrHF(char* tname, Int_t npart, Int_t param);
- AliGenCorrHF(const AliGenCorrHF &CorrHF);
virtual ~AliGenCorrHF();
virtual void Generate();
// force decay type
virtual void SetDecayer(AliDecayer* decayer) {fDecayer = decayer;}
- AliGenCorrHF & operator=(const AliGenCorrHF & rhs);
-
// Particle type parametrisation functions, needed by GetHadronPair
static Int_t IpCharm(TRandom* ran);
static Int_t IpBeauty(TRandom* ran);
AliDecayer* fDecayer; //! Pointer to pythia object for decays
private:
+ AliGenCorrHF(const AliGenCorrHF &CorrHF);
+ AliGenCorrHF & operator=(const AliGenCorrHF & rhs);
+
static Double_t* fgIntegral; //! Pointer to array of cumulative sums of wght-s
static Int_t fgnptbins; // =12 Number of bins for the fragm.
// function dependence on quark pt
fTitle = "Primaries from ext. File";
}
-AliGenExtFile::AliGenExtFile(const AliGenExtFile & ExtFile):
- AliGenMC(ExtFile),
- fFileName(0),
- fReader(0)
-{
-// Copy constructor
- ExtFile.Copy(*this);
-}
//____________________________________________________________
AliGenExtFile::~AliGenExtFile()
{
}
-AliGenExtFile& AliGenExtFile::operator=(const AliGenExtFile& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
-
-void AliGenExtFile::Copy(TObject&) const
-{
- //
- // Copy
- //
- Fatal("Copy","Not implemented!\n");
-}
-
-
-
-
public:
AliGenExtFile();
AliGenExtFile(Int_t npart);
- AliGenExtFile(const AliGenExtFile &ext);
- virtual ~AliGenExtFile();
+ virtual ~AliGenExtFile();
// Initialise
virtual void Init();
// generate event
virtual void Generate();
- AliGenExtFile & operator=(const AliGenExtFile & rhs);
void SetReader(AliGenReader* reader) {fReader = reader;}
protected:
void CdEventFile();
- void Copy(TObject&) const;
const Text_t *fFileName; //! File to read from
AliGenReader *fReader; //! Reader to read the file
+
+ private:
+ AliGenExtFile(const AliGenExtFile &ext);
+ AliGenExtFile & operator=(const AliGenExtFile & rhs);
ClassDef(AliGenExtFile,1) //Generate particles from external file
};
fTitle = "FLUKA Boundary Source";
}
-AliGenFLUKAsource::AliGenFLUKAsource(const AliGenFLUKAsource & 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);
-}
-
-
//____________________________________________________________
AliGenFLUKAsource::~AliGenFLUKAsource()
{
}
-AliGenFLUKAsource& AliGenFLUKAsource::operator=(const AliGenFLUKAsource& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return (*this);
-}
-
-
-void AliGenFLUKAsource::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented!\n");
-}
-
AliGenFLUKAsource();
AliGenFLUKAsource(Int_t npart);
- AliGenFLUKAsource(const AliGenFLUKAsource &FLUKAsource);
- virtual ~AliGenFLUKAsource();
+ virtual ~AliGenFLUKAsource();
// Initialise
virtual void Init() {}
// Initialise fluka data
virtual void SetFraction(Float_t frac=1.){fFrac=frac;}
// generate event
virtual void Generate();
- AliGenFLUKAsource & operator=(const AliGenFLUKAsource & rhs);
protected:
Float_t fAge; // Time of flight
private:
- void Copy(TObject &arun) const;
+ AliGenFLUKAsource(const AliGenFLUKAsource &FLUKAsource);
+ AliGenFLUKAsource & operator=(const AliGenFLUKAsource & rhs);
ClassDef(AliGenFLUKAsource,1) //Boundary source
};
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);
- AliGenGeVSim & operator=(const AliGenGeVSim & /*ggs*/)
- {Fatal("= operator","Not implemented\n"); return *this;}
+ AliGenGeVSim & operator=(const AliGenGeVSim & /*ggs*/);
+
Int_t fModel; // Selected model (1-7)
Float_t fPsi; // Reaction Plane angle (0-2pi)
SetPtRange();
}
-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);
-}
-
//_____________________________________________________________________________
AliGenHIJINGpara::~AliGenHIJINGpara()
{
fNt = nt;
}
-void AliGenHIJINGpara::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented!\n");
-}
-
-
void AliGenHIJINGpara::Draw( const char * /*opt*/)
{
//
AliGenHIJINGpara();
AliGenHIJINGpara(Int_t npart);
- AliGenHIJINGpara(const AliGenHIJINGpara &HIJINGpara);
- AliGenHIJINGpara& operator = (const AliGenHIJINGpara ¶)
- {para.Copy(*this); return (*this);}
virtual ~AliGenHIJINGpara();
virtual void SetCutVertexZ(Float_t cut=999999.) {fCutVertexZ = cut;}
virtual void Generate();
AliDecayer* fDecayer; // ! Pointer to pythia object for decays
void DecayPi0(Float_t* orig, Float_t * p);
- void Copy(TObject ¶) const;
+
+ private:
+ AliGenHIJINGpara(const AliGenHIJINGpara &HIJINGpara);
+ AliGenHIJINGpara& operator = (const AliGenHIJINGpara ¶) ;
+
+
ClassDef(AliGenHIJINGpara,3) // Hijing parametrisation generator
};
#endif
fTitle="HIJING Parametrisation Particle Generator with Baryons";
}
-AliGenHIJINGparaBa::AliGenHIJINGparaBa(const AliGenHIJINGparaBa& para) :
- AliGenHIJINGpara(para),
- fPtba(0),
- fETAba(0)
-{
-// Copy constructor
- para.Copy(*this);
-}
-
//_____________________________________________________________________________
AliGenHIJINGparaBa::~AliGenHIJINGparaBa()
{
public:
AliGenHIJINGparaBa();
AliGenHIJINGparaBa(Int_t npart);
- AliGenHIJINGparaBa(const AliGenHIJINGparaBa &HIJINGpara);
- AliGenHIJINGparaBa& operator = (const AliGenHIJINGparaBa ¶)
- {para.Copy(*this); return (*this);}
virtual ~AliGenHIJINGparaBa();
virtual void Generate();
virtual void Init();
TF1* fPtba; //! Parametrised pt distribution for baryons
TF1* fETAba; //! Parametrised eta distribution for baryons
+ private:
+ AliGenHIJINGparaBa(const AliGenHIJINGparaBa &HIJINGpara);
+ AliGenHIJINGparaBa& operator = (const AliGenHIJINGparaBa ¶);
+
ClassDef(AliGenHIJINGparaBa,1) // Hijing parametrisation generator with baryons
};
#endif
fNpart=-1;
}
-AliGenHalo::AliGenHalo(const AliGenHalo & Halo)
- :AliGenerator(Halo),
- fp(0),
- fFileName(0)
-{
-// Copy constructor
- Halo.Copy(*this);
-}
-
-
//____________________________________________________________
AliGenHalo::~AliGenHalo()
{
}
-AliGenHalo& AliGenHalo::operator=(const AliGenHalo& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
-
-void AliGenHalo::Copy(TObject&) const
-{
- //
- // Copy
- //
- Fatal("Copy","Not implemented!\n");
-}
-
-
public:
AliGenHalo();
AliGenHalo(Int_t npart);
- AliGenHalo(const AliGenHalo &Halo);
virtual ~AliGenHalo();
virtual void Init();
virtual void SetFileName(TString filename) {fFileName=TString(filename);}
virtual void Generate();
- AliGenHalo & operator=(const AliGenHalo & rhs);
protected:
FILE *fp; // ! Pointer to file
TString fFileName; // Choose the file
private:
- void Copy(TObject &Halo) const;
+ AliGenHalo(const AliGenHalo &Halo);
+ AliGenHalo & operator=(const AliGenHalo & rhs);
+
ClassDef(AliGenHalo,1) // LHC background boundary source (MARS input)
};
#endif
SetAnalog(0);
}
-AliGenHaloProtvino::AliGenHaloProtvino(const AliGenHaloProtvino & 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);
-}
-
-
-//____________________________________________________________
-AliGenHaloProtvino::~AliGenHaloProtvino()
-{
-// Destructor
-}
-
-//____________________________________________________________
-void AliGenHaloProtvino::Init()
-{
-// Initialisation
- fFile = fopen(fFileName,"r");
- if (fFile) {
- printf("\n File %s opened for reading, %p ! \n ", fFileName.Data(), (void*)fFile);
- } else {
- printf("\n Opening of file %s failed, %p ! \n ", fFileName.Data(), (void*)fFile);
- }
-//
-//
-//
-// Read file with gas pressure values
- char *name = 0;
- if (fRunPeriod < 5) {
- name = gSystem->ExpandPathName("$(ALICE_ROOT)/LHC/gasPressure.dat" );
- fGPASize = 21;
- fG1 = new Float_t[fGPASize];
- fG2 = new Float_t[fGPASize];
- fZ1 = new Float_t[fGPASize];
- fZ2 = new Float_t[fGPASize];
- } else if (fRunPeriod == 5) {
- name = gSystem->ExpandPathName("$(ALICE_ROOT)/LHC/pressure_2003_startup.dat");
- fGPASize = 18853;
- fG1 = new Float_t[fGPASize];
- fZ1 = new Float_t[fGPASize];
- } else if (fRunPeriod ==6) {
- name = gSystem->ExpandPathName("$(ALICE_ROOT)/LHC/pressure_2003_conditioned.dat");
- fGPASize = 12719;
- fG1 = new Float_t[fGPASize];
- fZ1 = new Float_t[fGPASize];
- } else {
- Fatal("Init()", "No gas pressure file for given run period !");
- }
-
-
- FILE* file = fopen(name, "r");
- Float_t z;
- Int_t i;
- Float_t p[5];
-
- const Float_t kCrossSection = 0.094e-28; // m^2
- const Float_t kFlux = 1.e11 / 25.e-9; // protons/s
- Float_t pFlux[5] = {0.2, 0.2, 0.3, 0.3, 1.0};
-
- if (fRunPeriod < 5) {
-//
-// Ring 1
-//
-
- for (i = 0; i < fGPASize; i++)
- {
- fscanf(file, "%f %f %f %f %f %f", &z, &p[0], &p[1], &p[2] , &p[3], &p[4]);
- fG1[i] = p[fRunPeriod];
-
- if (i > 0) {
- fZ1[i] = fZ1[i-1] + z;
- } else {
- fZ1[i] = 20.;
- }
- }
-//
-// Ring 2
-//
- for (i = 0; i < fGPASize; i++)
- {
- fscanf(file, "%f %f %f %f %f %f", &z, &p[0], &p[1], &p[2] , &p[3], &p[4]);
- fG2[i] = p[fRunPeriod];
- if (i > 0) {
- fZ2[i] = fZ2[i-1] + z;
- } else {
- fZ2[i] = 20.;
- }
- }
-//
-// Interaction rates
-//
- for (i = 0; i < fGPASize; i++)
- {
- fG1[i] = fG1[i] * kCrossSection * pFlux[fRunPeriod] * kFlux; // 1/m/s
- fG2[i] = fG2[i] * kCrossSection * pFlux[fRunPeriod] * kFlux; // 1/m/s
- }
-
- } else {
- for (i = 0; i < fGPASize; i++)
- {
- fscanf(file, "%f %e %e %e %e %e", &z, &p[0], &p[1], &p[2], &p[3], &p[4]);
- z /= 1000.;
- fG1[i] = p[4] * kCrossSection * kFlux; // 1/m/s
- // 1/3 of nominal intensity at startup
- if (fRunPeriod == kLHCPR674Startup) fG1[i] /= 3.;
- fZ1[i] = z;
- }
- }
-
-
-
-
-//
-// Transform into interaction rates
-//
-
-
-
-
- Float_t sum1 = 0.;
- Float_t sum2 = 0.;
-
- for (Int_t i = 0; i < 300; i++) {
- Float_t z = 20.+i*1.;
- z*=100;
- Float_t wgt1 = GasPressureWeight(z);
- Float_t wgt2 = GasPressureWeight(-z);
-// printf("weight: %f %f %f %f %f \n", z, wgt1, wgt2, fZ1[20], fZ2[20]);
- sum1 += wgt1;
- sum2 += wgt2;
- }
- sum1/=250.;
- sum2/=250.;
- printf("\n %f %f \n \n", sum1, sum2);
-}
-
-//____________________________________________________________
-void AliGenHaloProtvino::Generate()
-{
-// Generate from input file
-
- Float_t polar[3]= {0,0,0};
- Float_t origin[3];
- Float_t p[3], p0;
- Float_t tz, txy;
- Float_t amass;
- //
- Int_t ncols, nt;
- static Int_t nskip = 0;
- Int_t nread = 0;
-
- Float_t* zPrimary = new Float_t [fNpart];
- Int_t * inuc = new Int_t [fNpart];
- Int_t * ipart = new Int_t [fNpart];
- Float_t* wgt = new Float_t [fNpart];
- Float_t* ekin = new Float_t [fNpart];
- Float_t* vx = new Float_t [fNpart];
- Float_t* vy = new Float_t [fNpart];
- Float_t* tx = new Float_t [fNpart];
- Float_t* ty = new Float_t [fNpart];
-
- Float_t zVertexOld = -1.e10;
- Int_t nInt = 0; // Counts number of interactions
- Float_t wwgt = 0.;
-
- while(1) {
-//
-// Load event into array
-//
- ncols = fscanf(fFile,"%f %d %d %f %f %f %f %f %f",
- &zPrimary[nread], &inuc[nread], &ipart[nread], &wgt[nread],
- &ekin[nread], &vx[nread], &vy[nread],
- &tx[nread], &ty[nread]);
-
- if (ncols < 0) break;
-// Skip fNskip events
- nskip++;
- if (fNpart !=-1 && nskip <= fNskip) continue;
-// Count interactions
- if (zPrimary[nread] != zVertexOld) {
- nInt++;
- zVertexOld = zPrimary[nread];
- }
-// Count tracks
- nread++;
- if (fNpart !=-1 && nread > fNpart) break;
- }
-//
-// Mean time between interactions
-//
- Float_t dT = fTimePerEvent/nInt; // sec
- Float_t t = 0; // sec
-
-//
-// Loop over primaries
-//
- zVertexOld = -1.e10;
- Double_t arg = 0.;
-
- for (Int_t nprim = 0; nprim < fNpart; nprim++)
- {
- amass = TDatabasePDG::Instance()->GetParticle(ipart[nprim])->Mass();
-
- //
- // Momentum vector
- //
- p0=sqrt(ekin[nprim]*ekin[nprim] + 2.*amass*ekin[nprim]);
-
- txy=TMath::Sqrt(tx[nprim]*tx[nprim]+ty[nprim]*ty[nprim]);
- if (txy == 1.) {
- tz=0;
- } else {
- tz=-TMath::Sqrt(1.-txy);
- }
-
- p[0] = p0*tx[nprim];
- p[1] = p0*ty[nprim];
- p[2] =-p0*tz;
-
- origin[0] = vx[nprim];
- origin[1] = vy[nprim];
- origin[2] = -2196.5;
-
- //
- //
- // Particle weight
-
- Float_t originP[3] = {0., 0., 0.};
- originP[2] = zPrimary[nprim];
-
- Float_t pP[3] = {0., 0., 0.};
- Int_t ntP;
-
- if (fSide == -1) {
- originP[2] = -zPrimary[nprim];
- origin[2] = -origin[2];
- p[2] = -p[2];
- }
-
- //
- // Time
- //
- if (zPrimary[nprim] != zVertexOld) {
- while(arg==0.) arg = gRandom->Rndm();
- t -= dT*TMath::Log(arg); // (sec)
- zVertexOld = zPrimary[nprim];
- }
-
-// Get statistical weight according to local gas-pressure
-//
- fParentWeight=wgt[nprim]*GasPressureWeight(zPrimary[nprim]);
-
- if (!fAnalog || gRandom->Rndm() < fParentWeight) {
-// Pass parent particle
-//
- PushTrack(0,-1,kProton,pP,originP,polar,t,kPNoProcess,ntP, fParentWeight);
- KeepTrack(ntP);
- PushTrack(fTrackIt,ntP,ipart[nprim],p,origin,polar,t,kPNoProcess,nt,fParentWeight);
- }
- //
- // Both sides are considered
- //
-
- if (fSide > 1) {
- fParentWeight=wgt[nprim]*GasPressureWeight(-zPrimary[nprim]);
- if (!fAnalog || gRandom->Rndm() < fParentWeight) {
- origin[2] = -origin[2];
- originP[2] = -originP[2];
- p[2]=-p[2];
- PushTrack(0,-1,kProton,pP,originP,polar,t,kPNoProcess,ntP, fParentWeight);
- KeepTrack(ntP);
- PushTrack(fTrackIt,ntP,ipart[nprim],p,origin,polar,t,kPNoProcess,nt,fParentWeight);
- }
- }
- wwgt += fParentWeight;
-
- SetHighWaterMark(nt);
- }
- delete [] zPrimary;
- delete [] inuc;
- delete [] ipart;
- delete [] wgt;
- delete [] ekin;
- delete [] vx;
- delete [] vy;
- delete [] tx;
- delete [] ty;
- printf("Total weight %f\n\n", wwgt);
-
-}
-
-
-AliGenHaloProtvino& AliGenHaloProtvino::operator=(const AliGenHaloProtvino& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
-
-
-Float_t AliGenHaloProtvino::GasPressureWeight(Float_t zPrimary)
-{
-//
-// Return z-dependent gasspressure weight = interaction rate [1/m/s].
-//
- Float_t weight = 0.;
- zPrimary /= 100.; // m
- if (fRunPeriod < 5) {
- Float_t zAbs = TMath::Abs(zPrimary);
- if (zPrimary > 0.)
- {
- if (zAbs > fZ1[20]) {
- weight = 2.e4;
- } else {
- for (Int_t i = 1; i < 21; i++) {
- if (zAbs < fZ1[i]) {
- weight = fG1[i];
- break;
- }
- }
- }
- } else {
- if (zAbs > fZ2[20]) {
- weight = 2.e4;
- } else {
- for (Int_t i = 1; i < 21; i++) {
- if (zAbs < fZ2[i]) {
- weight = fG2[i];
- break;
- }
- }
- }
- }
- } else {
- Int_t index = TMath::BinarySearch(fGPASize, fZ1, zPrimary);
- weight = fG1[index];
- }
- return weight;
-}
-
-void AliGenHaloProtvino::Draw(Option_t *)
-{
-// Draws the gas pressure distribution
- Float_t z[400];
- Float_t p[400];
-
- for (Int_t i = 0; i < 400; i++)
- {
- z[i] = -20000. + Float_t(i) * 100;
- p[i] = GasPressureWeight(z[i]);
- }
-
- TGraph* gr = new TGraph(400, z, p);
- TCanvas* c1 = new TCanvas("c1","Canvas 1",400,10,600,700);
- c1->cd();
- gr->Draw("AL");
-}
-
-
-void AliGenHaloProtvino::Copy(TObject&) const
-{
- //
- // Copy
- //
- Fatal("Copy","Not implemented!\n");
-}
-
/*
# Title: README file for the sources of IR8 machine induced background
enum constants{kY1Day0, kY1Day70, kY2D0, kY2D10, kY3D90, kLHCPR674Startup, kLHCPR674Conditioned};
AliGenHaloProtvino();
AliGenHaloProtvino(Int_t npart);
- AliGenHaloProtvino(const AliGenHaloProtvino &HaloProtvino);
virtual ~AliGenHaloProtvino();
virtual void Init();
virtual void SetFileName(TString filename) {fFileName=TString(filename);}
virtual void SetRunPeriod(Int_t t = kY3D90) {fRunPeriod = t;}
virtual void SetTimePerEvent(Float_t t = 1.e-4) {fTimePerEvent = t;}
virtual void Draw(Option_t * opt="");
- AliGenHaloProtvino & operator=(const AliGenHaloProtvino & rhs);
protected:
FILE* fFile; // ! Pointer to file
Float_t* fG2; // ! gas pressures
Int_t fGPASize; // ! Size of arrays
private:
- void Copy(TObject&) const;
+ AliGenHaloProtvino(const AliGenHaloProtvino &HaloProtvino);
+ AliGenHaloProtvino & operator=(const AliGenHaloProtvino & rhs);
+
ClassDef(AliGenHaloProtvino,1) // LHC background boundary source (Protvino Group results)
for (Int_t i=0; i<8; i++) fParentSelect[i]=fChildSelect[i]=0;
}
-AliGenMC::AliGenMC(const AliGenMC & 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);
-}
-
AliGenMC::~AliGenMC()
{
// Destructor
iparticle->SetMomentum(px, py, pzb, eb);
}
}
-
-
-
-AliGenMC& AliGenMC::operator=(const AliGenMC& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
-void AliGenMC::Copy(TObject&) const
-{
- //
- // Copy
- //
- Fatal("Copy","Not implemented!\n");
-}
-
-
public:
AliGenMC();
AliGenMC(Int_t npart);
- AliGenMC(const AliGenMC &MC);
virtual ~AliGenMC();
virtual void Init();
virtual void SetForceDecay(Decay_t decay = kAll) {fForceDecay = decay;}
- AliGenMC & operator=(const AliGenMC & rhs);
- virtual void SetCutOnChild(Int_t flag = 0) {fCutOnChild = flag;}
+ virtual void SetCutOnChild(Int_t flag = 0) {fCutOnChild = flag;}
virtual void SetChildMomentumRange(Float_t pmin = 0, Float_t pmax = 1.e10)
{fChildPMin = pmin; fChildPMax = pmax;}
virtual void SetChildPtRange(Float_t ptmin = 0, Float_t ptmax = 20.)
// all kinematic selection cuts go here
Bool_t KinematicSelection(TParticle *particle, Int_t flag) const;
Int_t CheckPDGCode(Int_t pdgcode) const;
- void Copy(TObject&) const;
+
protected:
TClonesArray* fParticles; //!Particle List
TArrayI fParentSelect; //!Parent particles to be selected
AliGeometry * fGeometryAcceptance; // Geometry to which particles must be simulated
Int_t fPdgCodeParticleforAcceptanceCut; // Abs(PDG Code) of the particle to which the GeometryAcceptance must be applied
Int_t fNumberOfAcceptedParticles; // Number of accepted particles in GeometryAcceptance with the right Abs(PdgCode)
+
+ private:
+ AliGenMC(const AliGenMC &MC);
+ AliGenMC & operator=(const AliGenMC & rhs);
ClassDef(AliGenMC,5) // AliGenerator implementation for generators using MC methods
};
{
// Constructor
}
-//_________________________________________________________________________
-AliGenMUONCocktail::AliGenMUONCocktail(const AliGenMUONCocktail & 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
-}
-
//_________________________________________________________________________
AliGenMUONCocktail::~AliGenMUONCocktail()
{
AliDebug(5,Form("Generated Events are %d and Succeeded Events are %d",fNGenerated,fNSucceded));
}
-
-
-AliGenMUONCocktail& AliGenMUONCocktail::operator=(const AliGenMUONCocktail& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
-void AliGenMUONCocktail::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented!\n");
-}
-
-
-
{
public:
AliGenMUONCocktail();
- AliGenMUONCocktail(const AliGenMUONCocktail &cocktail);
- virtual ~AliGenMUONCocktail();
+ virtual ~AliGenMUONCocktail();
virtual void Init();
virtual void Generate();
Int_t GetMuonMultiplicity() const {return fMuonMultiplicity;}
fInvMassMaxCut=MassMax;
fInvMassCut = kTRUE; }
private:
+ AliGenMUONCocktail(const AliGenMUONCocktail &cocktail);
AliGenMUONCocktail& operator=(const AliGenMUONCocktail & rhs);
- void Copy(TObject &cocktail) const;
+
//
private:
AliFastGlauber * fFastGlauber; //! Fast glauber calculations
{
// Constructor
}
-//_________________________________________________________________________
-AliGenMUONCocktailpp::AliGenMUONCocktailpp(const AliGenMUONCocktailpp & 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()
// Destructor
public:
AliGenMUONCocktailpp();
- AliGenMUONCocktailpp(const AliGenMUONCocktailpp &cocktail);
virtual ~AliGenMUONCocktailpp();
virtual void Init();
virtual void Generate();
//
private:
+ AliGenMUONCocktailpp(const AliGenMUONCocktailpp &cocktail);
+ AliGenMUONCocktailpp & operator=(const AliGenMUONCocktailpp &cocktail);
+
Float_t fTotalRate;// Total rate of the full cocktail processes
Int_t fMuonMultiplicity; // Muon multiplicity for the primordial trigger
Float_t fMuonPtCut;// Transverse momentum cut for muons
SetChildThetaRange();
}
-
-AliGenParam::AliGenParam(const AliGenParam & 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);
-}
-
//____________________________________________________________
AliGenParam::~AliGenParam()
{
fYPara->GetHistogram()->SetXTitle("y");
}
-AliGenParam& AliGenParam::operator=(const AliGenParam& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
Double_t (*PtPara)(Double_t*, Double_t*),
Double_t (*YPara )(Double_t*, Double_t*),
Int_t (*IpPara)(TRandom*) );
- AliGenParam(const AliGenParam &Param);
virtual ~AliGenParam();
virtual void Generate();
TF1 * GetY() {return fYPara;}
Float_t GetRelativeArea(Float_t ptMin, Float_t ptMax, Float_t yMin, Float_t yMax, Float_t phiMin, Float_t phiMax);
- AliGenParam & operator=(const AliGenParam & rhs);
protected:
Double_t (*fPtParaFunc)(Double_t*, Double_t*); //! Pointer to Pt parametrisation function
Double_t (*fYParaFunc )(Double_t*, Double_t*); //! Pointer to Y parametrisation function
Int_t fTrials; // Number of trials
Float_t fDeltaPt; // pT sampling in steps of fDeltaPt
AliDecayer *fDecayer; // ! Pointer to pythia object for decays
- ClassDef(AliGenParam,1) // Generator using parameterised pt- and y-distribution
+
+ private:
+ AliGenParam(const AliGenParam &Param);
+ AliGenParam & operator=(const AliGenParam & rhs);
+
+ ClassDef(AliGenParam,1) // Generator using parameterised pt- and y-distribution
};
#endif
fCollisionGeometry = 0;
}
-//____________________________________________________________
-AliGenSlowNucleons::AliGenSlowNucleons(const AliGenSlowNucleons & 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);
-}
-
//____________________________________________________________
AliGenSlowNucleons::~AliGenSlowNucleons()
{
Double_t energy = sqrt(m*m + q[0]*q[0] + q[1]*q[1] + q[2]*q[2]);
q[2] = gamma * (q[2] + beta*energy);
}
-
-
-AliGenSlowNucleons& AliGenSlowNucleons::operator=(const AliGenSlowNucleons& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
-void AliGenSlowNucleons::Copy(TObject&) const
-{
- //
- // Copy
- //
- Fatal("Copy","Not implemented!\n");
-}
-
-
-
-
-
-
-
public:
AliGenSlowNucleons();
AliGenSlowNucleons(Int_t npart);
- AliGenSlowNucleons(const AliGenSlowNucleons &sn);
virtual ~AliGenSlowNucleons();
virtual void Init();
virtual void FinishRun();
void GenerateSlow(Int_t charge, Double_t T, Double_t beta, Float_t* q, Float_t &theta);
Double_t Maxwell(Double_t m, Double_t p, Double_t t);
void Lorentz(Double_t m, Double_t beta, Float_t* q);
- void Copy(TObject&) const;
- AliGenSlowNucleons & operator=(const AliGenSlowNucleons & rhs);
protected:
Float_t fCMS; // Center of mass energy
Float_t fMomentum; // Target nucleus momentum
//
AliSlowNucleonModel* fSlowNucleonModel; // The slow nucleon model
+
+ private:
+ AliGenSlowNucleons(const AliGenSlowNucleons &sn);
+ AliGenSlowNucleons & operator=(const AliGenSlowNucleons & rhs);
+
ClassDef(AliGenSlowNucleons,2) // Slow Nucleon Generator
};
#endif
SetNuclei(0,0);
}
-AliGenPythia::AliGenPythia(const AliGenPythia & Pythia)
- :AliGenMC(Pythia),
- fProcess(kPyCharm),
- fStrucFunc(kCTEQ5L),
- fEnergyCMS(5500.),
- fKineBias(0.),
- fTrials(0),
- fTrialsRun(0),
- fQ(0.),
- fX1(0.),
- fX2(0.),
- fEventTime(0.),
- fInteractionRate(0.),
- fTimeWindow(0.),
- fCurSubEvent(0),
- fEventsTime(0),
- fNev(0),
- fFlavorSelect(0),
- fXsection(0.),
- fPythia(0),
- fPtHardMin(0.),
- fPtHardMax(1.e4),
- fYHardMin(-1.e10),
- fYHardMax(1.e10),
- fGinit(kTRUE),
- fGfinal(kTRUE),
- fHadronisation(kTRUE),
- fNpartons(0),
- fReadFromFile(kFALSE),
- fQuench(kFALSE),
- fPtKick(1.),
- fFullEvent(kTRUE),
- fDecayer(new AliDecayerPythia()),
- fDebugEventFirst(-1),
- fDebugEventLast(-1),
- fEtMinJet(0.),
- fEtMaxJet(1.e4),
- fEtaMinJet(-20.),
- fEtaMaxJet(20.),
- fPhiMinJet(0.),
- fPhiMaxJet(2.* TMath::Pi()),
- fJetReconstruction(kCell),
- fEtaMinGamma(-20.),
- fEtaMaxGamma(20.),
- fPhiMinGamma(0.),
- fPhiMaxGamma(2. * TMath::Pi()),
- fPycellEtaMax(2.),
- fPycellNEta(274),
- fPycellNPhi(432),
- fPycellThreshold(0.),
- fPycellEtSeed(4.),
- fPycellMinEtJet(10.),
- fPycellMaxRadius(1.),
- fStackFillOpt(kFlavorSelection),
- fFeedDownOpt(kTRUE),
- fFragmentation(kTRUE),
- fSetNuclei(kFALSE),
- fNewMIS(kFALSE),
- fHFoff(kFALSE),
- fTriggerParticle(0),
- fTriggerEta(0.9),
- fCountMode(kCountAll),
- fHeader(0),
- fRL(0),
- fFileName(0),
- fFragPhotonInCalo(kFALSE),
- fPi0InCalo(kFALSE) ,
- fCheckEMCAL(kFALSE),
- fCheckPHOS(kFALSE),
- fFragPhotonOrPi0MinPt(0),
- fPHOSMinPhi(219.),
- fPHOSMaxPhi(321.),
- fPHOSEta(0.13),
- fEMCALMinPhi(79.),
- fEMCALMaxPhi(191.),
- fEMCALEta(0.71)
-{
-// copy constructor
- Pythia.Copy(*this);
-}
-
AliGenPythia::~AliGenPythia()
{
// Destructor
return checking;
}
-
-AliGenPythia& AliGenPythia::operator=(const AliGenPythia& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
-
void AliGenPythia::LoadEvent(AliStack* stack, Int_t flag, Int_t reHadr)
{
//
AliGenPythia();
AliGenPythia(Int_t npart);
- AliGenPythia(const AliGenPythia &Pythia);
virtual ~AliGenPythia();
virtual void Generate();
virtual void Init();
Bool_t CheckKinematicsOnChild();
- // Assignment Operator
- AliGenPythia & operator=(const AliGenPythia & rhs);
void GetSubEventTime();
void AddHeader(AliGenEventHeader* header);
Float_t fEMCALMaxPhi ;
Float_t fEMCALEta ;
+ private:
+ AliGenPythia(const AliGenPythia &Pythia);
+ AliGenPythia & operator=(const AliGenPythia & rhs);
+
ClassDef(AliGenPythia,5) // AliGenerator interface to Pythia
};
#endif
fTitle= "Jet Generator using PYTHIA";
}
-AliGenPythiaJets::AliGenPythiaJets(const AliGenPythiaJets & Pythia):
- AliGenPythia(Pythia)
-{
-// copy constructor
- Pythia.Copy(*this);
-}
-
AliGenPythiaJets::~AliGenPythiaJets()
{
// Destructor
}
return triggered;
}
-
-AliGenPythiaJets& AliGenPythiaJets::operator=(const AliGenPythiaJets& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return *this;
-}
void AliGenPythiaJets::TransformEvent(Float_t beta, Float_t phi)
{
public:
AliGenPythiaJets();
AliGenPythiaJets(Int_t npart);
- AliGenPythiaJets(const AliGenPythiaJets &Pythia);
virtual ~AliGenPythiaJets();
virtual void Init();
virtual void Generate();
virtual Bool_t CheckTrigger();
virtual void SetQuenchingFactor(Int_t quench = -1) {fQuench = quench;}
- // Assignment Operator
- AliGenPythiaJets & operator=(const AliGenPythiaJets & rhs);
protected:
Float_t fEtMinJetQ[2]; // Minimum et of triggered Jet
Float_t fEtMaxJetQ[2]; // Maximum et of triggered Jet
Float_t fPtHardMinQ[2]; // Lower pT-hard cut
Float_t fPtHardMaxQ[2]; // Higher pT-hard cut
+
+ private:
+ AliGenPythiaJets(const AliGenPythiaJets &Pythia);
+ AliGenPythiaJets & operator=(const AliGenPythiaJets & rhs);
+
ClassDef(AliGenPythiaJets,1) // AliGenerator Interface to Pythia Jet Production
};
#endif
AliConfig::Instance()->Add(this);
}
-//_______________________________________________________________________
-AliGenerator::AliGenerator(const AliGenerator &gen):
- TNamed(gen),
- AliRndm(gen),
- fMCEvGen(0),
- fThetaMin(0),
- fThetaMax(0),
- fPhiMin(0),
- fPhiMax(0),
- fPMin(0),
- fPMax(0),
- fPtMin(0),
- fPtMax(0),
- fYMin(0),
- fYMax(0),
- fVMin(3),
- fVMax(3),
- fNpart(0),
- fParentWeight(0),
- fChildWeight(0),
- fAnalog(0),
- fVertexSmear(kNoSmear),
- fVertexSource(kInternal),
- fCutVertexZ(0),
- fPileUpTimeWindow(-1.),
- fTrackIt(0),
- fVertexGenerator(0),
- fOrigin(3),
- fOsigma(3),
- fVertex(3),
- fStack(0),
- fContainer(0),
- fCollisionGeometry(0)
-{
- //
- // Copy constructor
- //
- gen.Copy(*this);
-}
-
-//_______________________________________________________________________
-AliGenerator & AliGenerator::operator=(const AliGenerator &gen)
-{
- //
- // Assignment operator
- //
- gen.Copy(*this);
- return (*this);
-}
-
-//_______________________________________________________________________
-void AliGenerator::Copy(TObject &/* gen */) const
-{
- //
- // Copy *this onto gen
- //
- AliFatal("Not implemented!");
-}
-
//_______________________________________________________________________
AliGenerator::~AliGenerator()
{
public:
AliGenerator();
AliGenerator(Int_t npart);
- AliGenerator(const AliGenerator &gen);
virtual ~AliGenerator();
virtual void Init();
- void Copy(TObject &gen) const;
virtual void SetOrigin(Float_t ox, Float_t oy, Float_t oz);
virtual void SetOrigin(const TLorentzVector &o);
virtual void SetSigma(Float_t sx, Float_t sy, Float_t sz);
virtual void SetMC(TGenerator *theMC) {fMCEvGen =theMC;}
virtual void AddHeader(AliGenEventHeader* /*header*/) {;}
virtual void SetContainer(AliGenerator* container) {fContainer = container;}
- AliGenerator & operator=(const AliGenerator &gen);
// Getters
kYRange = BIT(18),
kMomentumRange = BIT(19)
};
+
+ private:
+ AliGenerator(const AliGenerator &gen);
+ AliGenerator & operator=(const AliGenerator &gen);
+
ClassDef(AliGenerator,3) // Base class for event generators
};
if (fPtMin == 0) fPtMin = 1.E-04;
}
-//____________________________________________________________
-AliGenEpEmv1::AliGenEpEmv1(const AliGenEpEmv1 & gen)
- :AliGenMC(gen)
-{
- // copy constructor
- gen.Copy(*this);
-}
-
//____________________________________________________________
AliGenEpEmv1::~AliGenEpEmv1()
{
void Init();
void SetDebug(Int_t debug) {fDebug=debug;}
- AliGenEpEmv1(const AliGenEpEmv1 & gen);
protected:
+ AliGenEpEmv1(const AliGenEpEmv1 & gen);
+ AliGenEpEmv1 & operator=(const AliGenEpEmv1 & gen);
+
Float_t fMass; // electron mass
TEpEmGen * fEpEmGen; // e+e- generator
Int_t fDebug; // debug level
AliGenCocktailAfterBurner* GetGenerator();
/*******************************************************************/
-AliGenHBTprocessor::AliGenHBTprocessor(const AliGenHBTprocessor& in):
- AliGenerator(in),
- fHBTprocessor(0x0),
- fHbtPStatCodes(0x0),
- fEventMerge(1)
-{
-//copy contructor
- // AliGenHBTprocessor::AliGenHBTprocessor();
-}
AliGenHBTprocessor::AliGenHBTprocessor():
AliGenerator(),
fHBTprocessor(0x0),
public:
AliGenHBTprocessor();
- AliGenHBTprocessor(const AliGenHBTprocessor& in);
virtual ~AliGenHBTprocessor();
virtual void Init();
/******* P R O T E C T E D M E T H O D S *****/
void GetTrackEventIndex(Int_t n, Int_t &evno, Int_t &index) const; //returns event(stack) number and
+ private:
+ AliGenHBTprocessor(const AliGenHBTprocessor& in);
+ AliGenHBTprocessor & operator=(const AliGenHBTprocessor& in);
+
ClassDef(AliGenHBTprocessor,1) // Interface class for AliMevsim
};
AliHerwigRndm::SetHerwigRandom(GetRandom());
}
-AliGenHerwig::AliGenHerwig(const AliGenHerwig & Herwig)
- :AliGenMC(Herwig),
- fAutPDF("LHAPDF"),
- fModPDF(19070),
- fStrucFunc(kCTEQ5L),
- fKeep(0),
- fDecaysOff(1),
- fTrigger(0),
- fSelectAll(0),
- fFlavor(0),
- fEnergyCMS(14000),
- fMomentum1(7000),
- fMomentum2(7000),
- fKineBias(1),
- fTrials(0),
- fXsection(0),
- fHerwig(0x0),
- fProcess(0),
- fPtHardMin(0.),
- fPtRMS(0.),
- fMaxPr(10),
- fMaxErrors(1000),
- fEnSoft(1),
- fEv1Pr(0),
- fEv2Pr(0),
- fFileName(0)
-{
-// Copy constructor
- Herwig.Copy(*this);
-}
-
-
AliGenHerwig::~AliGenHerwig()
{
// Destructor
fHerwig->Hwefin();
}
-
-AliGenHerwig& AliGenHerwig::operator=(const AliGenHerwig& rhs)
-{
-// Assignment operator
- rhs.Copy(*this);
- return (*this);
-}
-
void AliGenHerwig::FinishRunJimmy()
{
fHerwig->Hwefin();
public:
AliGenHerwig();
AliGenHerwig(Int_t npart);
- AliGenHerwig(const AliGenHerwig &Herwig);
virtual ~AliGenHerwig();
virtual void Generate();
virtual void Init();
virtual void SetTrigger(Int_t flag=kNoTrigger) {fTrigger = flag;}
virtual void SetFlavor(Int_t flag=0) {fFlavor = flag;}
virtual void SetSelectAll(Int_t flag=0) {fSelectAll = flag;}
- AliGenHerwig & operator=(const AliGenHerwig & rhs);
virtual void SetStrucFunc(StrucFunc_t func = kCTEQ5L)
{fStrucFunc = func;}
virtual void SetPtHardMin(Double_t pt) {fPtHardMin=pt;}
TString fFileName; //!Name of file to read from hard scattering
private:
+ AliGenHerwig(const AliGenHerwig &Herwig);
+ AliGenHerwig & operator=(const AliGenHerwig & rhs);
+
// check if particle is selected as parent particle
Bool_t ParentSelected(Int_t ip);
// check if particle is selected as child particle
AliHijingRndm::SetHijingRandom(GetRandom());
}
-AliGenHijing::AliGenHijing(const AliGenHijing & hijing):
- AliGenMC(hijing),
- fFrame("CMS"),
- fMinImpactParam(0.),
- fMaxImpactParam(5.),
- fKeep(0),
- fQuench(1),
- fShadowing(1),
- fDecaysOff(1),
- fTrigger(0),
- fEvaluate(0),
- fSelectAll(0),
- fFlavor(0),
- fEnergyCMS(5500.),
- fKineBias(0.),
- fTrials(0),
- fXsection(0.),
- fHijing(0),
- fPtHardMin(0.),
- fPtHardMax(1.e4),
- fSpectators(1),
- fDsigmaDb(0),
- fDnDb(0),
- fPtMinJet(-2.5),
- fEtaMinJet(-20.),
- fEtaMaxJet(+20.),
- fPhiMinJet(0.),
- fPhiMaxJet(2. * TMath::Pi()),
- fRadiation(3),
- fSimpleJet(kFALSE),
- fNoGammas(kFALSE),
- fProjectileSpecn(0),
- fProjectileSpecp(0),
- fTargetSpecn(0),
- fTargetSpecp(0),
- fLHC(kFALSE),
- fRandomPz(kFALSE),
- fNoHeavyQuarks(kFALSE)
-{
-// copy constructor
-}
-
-
AliGenHijing::~AliGenHijing()
{
// Destructor
} // fTrigger == 2
return triggered;
}
-
-
-void AliGenHijing::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented!\n");
-}
-
-AliGenHijing& AliGenHijing::operator=(const AliGenHijing& rhs)
-{
- rhs.Copy(*this);
- return (*this);
-}
-
public:
AliGenHijing();
AliGenHijing(Int_t npart);
- AliGenHijing(const AliGenHijing &Hijing);
virtual ~AliGenHijing();
virtual void Generate();
virtual void Init();
virtual TGraph* BinaryCollisions() {return fDnDb;}
virtual Bool_t CheckTrigger();
//
- AliGenHijing & operator=(const AliGenHijing & rhs);
protected:
Bool_t SelectFlavor(Int_t pid);
void MakeHeader();
Bool_t fNoHeavyQuarks; // If true no heavy quarks are produced
private:
- void Copy(TObject &rhs) const;
+ AliGenHijing(const AliGenHijing &Hijing);
+ AliGenHijing & operator=(const AliGenHijing & rhs);
+
// adjust the weight from kinematic cuts
void AdjustWeights();
// check seleted daughters
SetKfOnium ();
}
-//____________________________________________________________
-AliGenTPHIC::AliGenTPHIC(const AliGenTPHIC & gen):
- AliGenMC(gen)
-{
- // copy constructor
- gen.Copy(*this);
-}
-
//____________________________________________________________
AliGenTPHIC::~AliGenTPHIC()
{
// calculated so far
return fTPHICgen->GetXSTOTE();
}
-
-void AliGenTPHIC::Copy(TObject&) const
-{
- //
- // Copy
- //
- Fatal("Copy","Not implemented!\n");
-}
-
{
public:
AliGenTPHIC();
- AliGenTPHIC(const AliGenTPHIC & gen);
virtual ~AliGenTPHIC();
void Generate();
void Init();
Float_t GetXSectionCurrent ();
Float_t GetXSection ();
Float_t GetXSectionError ();
- private:
- void Copy(TObject&) const;
protected:
TPHICgen *fTPHICgen; //!generator TPHIC17
AliPythia *fPythia; //!generator PYTHIA6
Int_t fDebug; //!debug level
Int_t fDebugEventFirst; //!First event to debug
Int_t fDebugEventLast; //!Last event to debug
-ClassDef(AliGenTPHIC,1) // Generator of 2-photon processes in ultra-peripheral collisions
+
+ private:
+ AliGenTPHIC(const AliGenTPHIC & gen);
+ AliGenTPHIC & operator=(const AliGenTPHIC & gen);
+
+ ClassDef(AliGenTPHIC,1) // Generator of 2-photon processes in ultra-peripheral collisions
};
#endif