}
AliDimuCombinator::AliDimuCombinator(const AliDimuCombinator & combinator)
+ :TObject(combinator)
{
// Dummy copy constructor
+ combinator.Copy(*this);
}
AliDimuCombinator& AliDimuCombinator::operator=(const AliDimuCombinator& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
-void AliDimuCombinator::Copy(AliDimuCombinator &combi) const
+void AliDimuCombinator::Copy(AliDimuCombinator&) const
{
//
- // Copy *this onto lego -- not implemented
+ // Copy
//
Fatal("Copy","Not implemented!\n");
}
#include <TTree.h>
- ClassImp(AliGenBeamGas)
+ClassImp(AliGenBeamGas)
AliGenBeamGas::AliGenBeamGas()
- :AliGenExtFile()
+ :AliGenExtFile()
{
// Constructor
//
fOsigma[2] = 2000.;
}
-AliGenBeamGas::AliGenBeamGas(const AliGenBeamGas & ExtFile)
+AliGenBeamGas::AliGenBeamGas(const AliGenBeamGas & beamgas):
+ AliGenExtFile(beamgas)
{
-// copy constructor
+// Copy constructor
+ beamgas.Copy(*this);
}
//____________________________________________________________
}
-//AliGenBeamGas& AliGenBeamGas::operator=(const AliGenBeamGas& rhs)
-//{
-// Assignment operator
-// return *this;
-//}
-
+void AliGenBeamGas::Copy(AliGenBeamGas&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
{
public:
AliGenBeamGas();
- AliGenBeamGas(const AliGenBeamGas &ext);
+ AliGenBeamGas(const AliGenBeamGas &beamgas);
virtual ~AliGenBeamGas();
//
virtual void SetNumberOfInteractions(Int_t n)
virtual void Init();
// generate event
virtual void Generate();
+ private:
+ void Copy(AliGenBeamGas&) const;
protected:
Int_t fInteractions;
fNGenerators=0;
}
-AliGenCocktail::AliGenCocktail(const AliGenCocktail & cocktail)
+AliGenCocktail::AliGenCocktail(const AliGenCocktail & cocktail):
+ AliGenerator(cocktail)
{
-// copy constructor
+// Copy constructor
+ cocktail.Copy(*this);
}
AliGenCocktail::~AliGenCocktail()
AliGenCocktail& AliGenCocktail::operator=(const AliGenCocktail& rhs)
{
// Assignment operator
- return *this;
+ rhs.Copy(*this);
+ return (*this);
}
+void AliGenCocktail::Copy(AliGenCocktail &) const
+{
+ Fatal("Copy","Not implemented!\n");
+}
+
+
void FirstGeneratorPair(AliGenCocktailEntry*&e1, AliGenCocktailEntry*&e2);
void NextGeneratorPair (AliGenCocktailEntry*&e1, AliGenCocktailEntry*&e2);
AliGenCocktail & operator=(const AliGenCocktail & rhs);
-
+ private:
+ void Copy(AliGenCocktail &arun) const;
protected:
Int_t fNGenerators; // Number of generators booked
TList *fEntries; // List of Generators
fNBgEvents = 0;
}
/*********************************************************************/
-AliGenCocktailAfterBurner::AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& in)
+AliGenCocktailAfterBurner::AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& cocktail):
+ AliGenCocktail(cocktail)
+
{
- //cpy ctor
+ //Copy constructor
+ cocktail.Copy(*this);
}
/*********************************************************************/
AliGenCocktailAfterBurner& AliGenCocktailAfterBurner::operator=(const AliGenCocktailAfterBurner& rhs)
{
// Assignment operator
- return *this;
+ rhs.Copy(*this);
+ return (*this);
}
/*********************************************************************/
/*********************************************************************/
}
return kPNoProcess;
}
+
+void AliGenCocktailAfterBurner::Copy(AliGenCocktailAfterBurner &) const
+{
+ Fatal("Copy","Not implemented!\n");
+}
void SetNBgEvents(Int_t nbg=0){fNBgEvents = nbg;}
static TMCProcess IntToMCProcess(Int_t no);
-
+ private:
+ void Copy(AliGenCocktailAfterBurner &arun) const;
protected:
Int_t fNAfterBurners; // Number of afterburners
TList *fAfterBurnerEntries;// List of afterburners
//(events that are generated only temporarly)
//needed by some afterburners that works better with higher statistics
//this generates such a artificial one
- private:
+ private:
+
ClassDef(AliGenCocktailAfterBurner,2) // Particle cocktail generator a la SHAKER
//background events added
};
ClassImp(AliGenCocktailEntry)
- AliGenCocktailEntry::AliGenCocktailEntry()
+
+AliGenCocktailEntry::AliGenCocktailEntry()
{
// Default constructor
fGenerator =0;
fBias=1;
}
-AliGenCocktailEntry::AliGenCocktailEntry(const AliGenCocktailEntry &entry)
+AliGenCocktailEntry::AliGenCocktailEntry(const AliGenCocktailEntry &entry):
+ TNamed(entry)
{
// Dummy copy constructor
+ entry.Copy(*this);
}
=(const AliGenCocktailEntry& rhs)
{
// Assignment operator
- return *this;
+ rhs.Copy(*this);
+ return (*this);
+}
+
+void AliGenCocktailEntry::Copy(AliGenCocktailEntry&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
}
Float_t Rate(){return fRate;}
void PrintInfo();
AliGenCocktailEntry & operator =(const AliGenCocktailEntry & rhs);
+ private:
+ void Copy(AliGenCocktailEntry&) const;
protected:
AliGenerator *fGenerator; // Pointer to generator
Int_t fNGenerated; // Number of primaries generated
#include <TTree.h>
- ClassImp(AliGenExtFile)
+ClassImp(AliGenExtFile)
AliGenExtFile::AliGenExtFile()
:AliGenMC()
fReader = 0;
}
-AliGenExtFile::AliGenExtFile(const AliGenExtFile & ExtFile)
+AliGenExtFile::AliGenExtFile(const AliGenExtFile & ExtFile):
+ AliGenMC(ExtFile)
{
-// copy constructor
+// Copy constructor
+ ExtFile.Copy(*this);
}
//____________________________________________________________
AliGenExtFile::~AliGenExtFile()
AliGenExtFile& AliGenExtFile::operator=(const AliGenExtFile& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
+
+void AliGenExtFile::Copy(AliGenExtFile&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
void SetReader(AliGenReader* reader) {fReader = reader;}
protected:
void CdEventFile();
+ private:
+ void Copy(AliGenExtFile&) const;
protected:
const Text_t *fFileName; //! File to read from
AliGenReader *fReader; //! Reader to read the file
#include <TTree.h>
#include <TChain.h>
#include <stdlib.h>
- ClassImp(AliGenFLUKAsource)
- AliGenFLUKAsource::AliGenFLUKAsource()
+ClassImp(AliGenFLUKAsource)
+
+AliGenFLUKAsource::AliGenFLUKAsource()
:AliGenerator(-1)
{
// Constructor
fSourceId=-1;
}
-AliGenFLUKAsource::AliGenFLUKAsource(const AliGenFLUKAsource & FLUKAsource)
+AliGenFLUKAsource::AliGenFLUKAsource(const AliGenFLUKAsource & FLUKAsource):
+ AliGenerator(FLUKAsource)
{
-// copy constructor
+// Copy constructor
+ FLUKAsource.Copy(*this);
}
AliGenFLUKAsource& AliGenFLUKAsource::operator=(const AliGenFLUKAsource& rhs)
{
// Assignment operator
- return *this;
+ rhs.Copy(*this);
+ return (*this);
}
+void AliGenFLUKAsource::Copy(AliGenFLUKAsource &) const
+{
+ Fatal("Copy","Not implemented!\n");
+}
+
// generate event
virtual void Generate();
AliGenFLUKAsource & operator=(const AliGenFLUKAsource & rhs);
+ private:
+ void Copy(AliGenFLUKAsource &arun) const;
protected:
Int_t fIkine; // Flag to choose type of particles to be read
}
//_____________________________________________________________________________
-void AliGenFixed::SetSigma(Float_t sx, Float_t sy, Float_t sz)
+void AliGenFixed::SetSigma(Float_t /*sx*/, Float_t /*sy*/, Float_t /*sz*/)
{
//
// Set the interaction point sigma
return 553;
}
-Double_t AliGenGSIlib::PtUpsilonFlat( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtUpsilonFlat( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return weight;
}
-Double_t AliGenGSIlib::YUpsilonFlat(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YUpsilonFlat(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return yu;
}
-Double_t AliGenGSIlib::PtUpsilonRitman( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtUpsilonRitman( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenGSIlib::YUpsilonRitman(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YUpsilonRitman(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return yu;
}
-Double_t AliGenGSIlib::PtUpsilonKarel( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtUpsilonKarel( Double_t */*px*/, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return 0.1;
}
-Double_t AliGenGSIlib::YUpsilonKarel(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YUpsilonKarel(Double_t */*py*/, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return 0.2;
}
-Double_t AliGenGSIlib::PtUpsilonMUON( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtUpsilonMUON( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenGSIlib::YUpsilonMUON(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YUpsilonMUON(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return 443;
}
-Double_t AliGenGSIlib::PtJpsiFlat( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtJpsiFlat( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return weight;
}
-Double_t AliGenGSIlib::YJpsiFlat(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YJpsiFlat(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return yu;
}
-Double_t AliGenGSIlib::PtJpsiMUON( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtJpsiMUON( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenGSIlib::PtJpsiRitman( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtJpsiRitman( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenGSIlib::YJpsiMUON(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YJpsiMUON(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
// J/Psi pt-distribution by Sergei
//
//--------------------------------------------------------------------------
-//Double_t AliGenGSIlib::PtJpsi( Double_t *px, Double_t *dummy )
+//Double_t AliGenGSIlib::PtJpsi( Double_t *px, Double_t */*dummy*/ )
//{
// return x = gRandom->Rndm()*10.;
return ip;
}
-Double_t AliGenGSIlib::PtCharmFlat( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::PtCharmFlat( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return x ;
}
-Double_t AliGenGSIlib::PtCharmGSI( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::PtCharmGSI( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return TMath::Power(x,kp1) * (pass1 + kp3 * pass2);
}
-Double_t AliGenGSIlib::PtCharmMUON( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::PtCharmMUON( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenGSIlib::YCharm( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::YCharm( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return ip;
}
-Double_t AliGenGSIlib::PtBeautyFlat( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::PtBeautyFlat( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return x ;
}
-Double_t AliGenGSIlib::PtBeautyGSI( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::PtBeautyGSI( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return TMath::Power(x,kp1) * (pass1 + kp3 * pass2);
}
-Double_t AliGenGSIlib::PtBeautyMUON( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::PtBeautyMUON( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenGSIlib::YBeauty( Double_t *px, Double_t *dummy)
+Double_t AliGenGSIlib::YBeauty( Double_t *px, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return 221;
}
-Double_t AliGenGSIlib::PtEtaPHOS( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtEtaPHOS( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return PtScal(*px,3); // 3==> Eta in the PtScal function
}
-Double_t AliGenGSIlib::YEtaPHOS(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YEtaPHOS(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return 331;
}
-Double_t AliGenGSIlib::PtEtaprimePHOS( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtEtaprimePHOS( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return PtScal(*px,5); // 5==> Etaprime in the PtScal function
}
-Double_t AliGenGSIlib::YEtaprimePHOS(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YEtaprimePHOS(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return 223;
}
-Double_t AliGenGSIlib::PtOmega( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtOmega( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return PtScal(*px,4); // 4==> Omega in the PtScal function
}
-Double_t AliGenGSIlib::YOmega(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YOmega(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return 113;
}
-Double_t AliGenGSIlib::PtRho( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtRho( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return PtScal(*px,11); // 11==> Rho in the PtScal function
}
-Double_t AliGenGSIlib::YRho(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YRho(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
}
}
}
-Double_t AliGenGSIlib::PtPion( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtPion( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return y*x;
}
-Double_t AliGenGSIlib::YPion(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YPion(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
}
}
}
-Double_t AliGenGSIlib::PtKaonPHOS( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtKaonPHOS( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return PtScal(*px,2); // 2==> Kaon in the PtScal function
}
-Double_t AliGenGSIlib::YKaonPHOS(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YKaonPHOS(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
return 333;
}
-Double_t AliGenGSIlib::PtPhiPHOS( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtPhiPHOS( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return PtScal(*px,6); // 6==> Phi in the PtScal function
}
-Double_t AliGenGSIlib::YPhiPHOS(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YPhiPHOS(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
}
}
}
-Double_t AliGenGSIlib::PtBaryons( Double_t *px, Double_t *dummy )
+Double_t AliGenGSIlib::PtBaryons( Double_t *px, Double_t */*dummy*/ )
{
//--------------------------------------------------------------------------
//
return PtScal(*px,7); // 7==> Baryon in the PtScal function
}
-Double_t AliGenGSIlib::YBaryons(Double_t *py, Double_t *dummy)
+Double_t AliGenGSIlib::YBaryons(Double_t *py, Double_t */*dummy*/)
{
//--------------------------------------------------------------------------
//
//Getters
Float_t GetEventPlane() const {return fEventPlane;}
- Float_t GetEllipticFlow(Int_t pdg) const {return fEllipticFlow;}
+ Float_t GetEllipticFlow() const {return fEllipticFlow;}
//Setters
void SetEventPlane(Float_t psi);
ClassImp(AliGenHIJINGpara)
-AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para)
+
+AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para):
+ AliGenerator(para)
{
-// copy constructor
+// Copy constructor
+ para.Copy(*this);
}
//_____________________________________________________________________________
gAlice->SetGenEventHeader(header);
}
-AliGenHIJINGpara& AliGenHIJINGpara::operator=(const AliGenHIJINGpara& rhs)
-{
-// Assignment operator
- return *this;
-}
-
void AliGenHIJINGpara::SetPtRange(Float_t ptmin, Float_t ptmax) {
AliGenerator::SetPtRange(ptmin, ptmax);
}
}
fNt = nt;
}
+
+void AliGenHIJINGpara::Copy(AliGenHIJINGpara &) const
+{
+ Fatal("Copy","Not implemented!\n");
+}
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();
virtual void Init();
- AliGenHIJINGpara & operator=(const AliGenHIJINGpara & rhs);
virtual void SetPtRange(Float_t ptmin = 0., Float_t ptmax=15.);
virtual void SetPi0Decays(Bool_t flag = kFALSE) {fPi0Decays = flag;}
private:
void DecayPi0(Float_t* orig, Float_t * p);
+ void Copy(AliGenHIJINGpara ¶) const;
protected:
Int_t fNt; // CurrentTrack;
Float_t fCutVertexZ; // Vertex truncation
#include "AliGenHalo.h"
#include "AliRun.h"
- ClassImp(AliGenHalo)
- AliGenHalo::AliGenHalo()
- :AliGenerator(-1)
+ClassImp(AliGenHalo)
+
+AliGenHalo::AliGenHalo()
+ :AliGenerator(-1)
{
// Constructor
fName="Halo";
}
AliGenHalo::AliGenHalo(const AliGenHalo & Halo)
+ :AliGenerator(Halo)
{
-// copy constructor
+// Copy constructor
+ Halo.Copy(*this);
}
AliGenHalo& AliGenHalo::operator=(const AliGenHalo& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
+void AliGenHalo::Copy(AliGenHalo&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
class AliGenHalo : public AliGenerator
{
-public:
+ public:
AliGenHalo();
AliGenHalo(Int_t npart);
AliGenHalo(const AliGenHalo &Halo);
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
- ClassDef(AliGenHalo,1) // LHC background boundary source (MARS input)
+ private:
+ void Copy(AliGenHalo &Halo) const;
+ protected:
+ FILE *fp; // ! Pointer to file
+ TString fFileName; // Choose the file
+ ClassDef(AliGenHalo,1) // LHC background boundary source (MARS input)
};
#endif
#include "AliGenHaloProtvino.h"
#include "AliRun.h"
- ClassImp(AliGenHaloProtvino)
- AliGenHaloProtvino::AliGenHaloProtvino()
- :AliGenerator(-1)
+ClassImp(AliGenHaloProtvino)
+
+AliGenHaloProtvino::AliGenHaloProtvino()
+ :AliGenerator(-1)
{
// Constructor
SetAnalog(0);
}
-AliGenHaloProtvino::AliGenHaloProtvino(const AliGenHaloProtvino & HaloProtvino)
+AliGenHaloProtvino::AliGenHaloProtvino(const AliGenHaloProtvino & HaloProtvino):
+ AliGenerator(HaloProtvino)
{
-// copy constructor
+// Copy constructor
+ HaloProtvino.Copy(*this);
}
AliGenHaloProtvino& AliGenHaloProtvino::operator=(const AliGenHaloProtvino& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
return weight;
}
+void AliGenHaloProtvino::Copy(AliGenHaloProtvino&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
/*
# Title: README file for the sources of IR8 machine induced background
# Author: Vadim Talanov <Vadim.Talanov@cern.ch>
AliGenHaloProtvino & operator=(const AliGenHaloProtvino & rhs);
-
+ private:
+ void Copy(AliGenHaloProtvino&) const;
protected:
FILE* fFile; // ! Pointer to file
TString fFileName; // Choose the file
#include "AliGenMC.h"
- ClassImp(AliGenMC)
+ClassImp(AliGenMC)
AliGenMC::AliGenMC()
- :AliGenerator()
+ :AliGenerator()
{
// Default Constructor
SetCutOnChild();
}
AliGenMC::AliGenMC(Int_t npart)
- :AliGenerator(npart)
+ :AliGenerator(npart)
{
// Constructor
SetCutOnChild();
SetProjectile();
}
-AliGenMC::AliGenMC(const AliGenMC & mc)
+AliGenMC::AliGenMC(const AliGenMC & mc):
+ AliGenerator(mc)
{
-// copy constructor
+// Copy constructor
+ mc.Copy(*this);
}
AliGenMC::~AliGenMC()
AliGenMC& AliGenMC::operator=(const AliGenMC& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
+void AliGenMC::Copy(AliGenMC&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
// all kinematic selection cuts go here
Bool_t KinematicSelection(TParticle *particle, Int_t flag) const;
Int_t CheckPDGCode(Int_t pdgcode) const;
-
+ private:
+ void Copy(AliGenMC&) const;
protected:
TClonesArray* fParticles; //!Particle List
TArrayI fParentSelect; //!Parent particles to be selected
ClassImp(AliGenMUONlib)
//
// Pions
-Double_t AliGenMUONlib::PtPion(Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtPion(Double_t *px, Double_t* /*dummy*/)
{
//
// PT-PARAMETERIZATION CDF, PRL 61(88) 1819
//
// y-distribution
//
-Double_t AliGenMUONlib::YPion( Double_t *py, Double_t *dummy)
+Double_t AliGenMUONlib::YPion( Double_t *py, Double_t */*dummy*/)
{
// Pion y
Double_t y=TMath::Abs(*py);
//
// pt-distribution
//____________________________________________________________
-Double_t AliGenMUONlib::PtKaon( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtKaon( Double_t *px, Double_t */*dummy*/)
{
// Kaon pT
return PtScal(*px,2);
// y-distribution
//____________________________________________________________
-Double_t AliGenMUONlib::YKaon( Double_t *py, Double_t *dummy)
+Double_t AliGenMUONlib::YKaon( Double_t *py, Double_t */*dummy*/)
{
// Kaon y
Double_t y=TMath::Abs(*py);
//
// pt-distribution
//____________________________________________________________
-Double_t AliGenMUONlib::PtJpsi( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtJpsi( Double_t *px, Double_t */*dummy*/)
{
// J/Psi pT
const Double_t kpt0 = 4.;
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenMUONlib::PtJpsiPbPb( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtJpsiPbPb( Double_t *px, Double_t */*dummy*/)
{
// J/Psi pT spectrum
//
}
return y;
}
-Double_t AliGenMUONlib::PtJpsiPP( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtJpsiPP( Double_t *px, Double_t */*dummy*/)
{
// J/Psi pT spectrum
//
//
// y-distribution
//____________________________________________________________
-Double_t AliGenMUONlib::YJpsi(Double_t *py, Double_t *dummy)
+Double_t AliGenMUONlib::YJpsi(Double_t *py, Double_t */*dummy*/)
{
// J/psi y
const Double_t ky0 = 4.;
}
-Double_t AliGenMUONlib::YJpsiPbPb( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YJpsiPbPb( Double_t *px, Double_t */*dummy*/)
{
//
return y;
}
-Double_t AliGenMUONlib::YJpsiPP( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YJpsiPP( Double_t *px, Double_t */*dummy*/)
{
//
//
// pt-distribution
//____________________________________________________________
-Double_t AliGenMUONlib::PtUpsilon( Double_t *px, Double_t *dummy )
+Double_t AliGenMUONlib::PtUpsilon( Double_t *px, Double_t */*dummy*/ )
{
// Upsilon pT
const Double_t kpt0 = 5.3;
return x/TMath::Power(pass1,kxn);
}
-Double_t AliGenMUONlib::PtUpsilonPbPb( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtUpsilonPbPb( Double_t *px, Double_t */*dummy*/)
{
//
return y;
}
-Double_t AliGenMUONlib::PtUpsilonPP( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtUpsilonPP( Double_t *px, Double_t */*dummy*/)
{
//
// y-distribution
//
//____________________________________________________________
-Double_t AliGenMUONlib::YUpsilon(Double_t *py, Double_t *dummy)
+Double_t AliGenMUONlib::YUpsilon(Double_t *py, Double_t */*dummy*/)
{
// Upsilon y
const Double_t ky0 = 3.;
}
-Double_t AliGenMUONlib::YUpsilonPbPb( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YUpsilonPbPb( Double_t *px, Double_t */*dummy*/)
{
//
return y;
}
-Double_t AliGenMUONlib::YUpsilonPP( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YUpsilonPP( Double_t *px, Double_t */*dummy*/)
{
//
//
// pt-distribution (by scaling of pion distribution)
//____________________________________________________________
-Double_t AliGenMUONlib::PtPhi( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtPhi( Double_t *px, Double_t */*dummy*/)
{
// Phi pT
return PtScal(*px,7);
}
// y-distribution
-Double_t AliGenMUONlib::YPhi( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YPhi( Double_t *px, Double_t */*dummy*/)
{
// Phi y
Double_t *dum=0;
//
// pt-distribution (by scaling of pion distribution)
//____________________________________________________________
-Double_t AliGenMUONlib::PtOmega( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtOmega( Double_t *px, Double_t */*dummy*/)
{
// Omega pT
return PtScal(*px,5);
}
// y-distribution
-Double_t AliGenMUONlib::YOmega( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YOmega( Double_t *px, Double_t */*dummy*/)
{
// Omega y
Double_t *dum=0;
//
// pt-distribution (by scaling of pion distribution)
//____________________________________________________________
-Double_t AliGenMUONlib::PtEta( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtEta( Double_t *px, Double_t */*dummy*/)
{
// Eta pT
return PtScal(*px,3);
}
// y-distribution
-Double_t AliGenMUONlib::YEta( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YEta( Double_t *px, Double_t */*dummy*/)
{
// Eta y
Double_t *dum=0;
//
// pt-distribution
//____________________________________________________________
-Double_t AliGenMUONlib::PtCharm( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtCharm( Double_t *px, Double_t */*dummy*/)
{
// Charm pT
const Double_t kpt0 = 4.08;
return x/TMath::Power(pass1,kxn);
}
// y-distribution
-Double_t AliGenMUONlib::YCharm( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YCharm( Double_t *px, Double_t */*dummy*/)
{
// Charm y
Double_t *dum=0;
//
// pt-distribution
//____________________________________________________________
-Double_t AliGenMUONlib::PtBeauty( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::PtBeauty( Double_t *px, Double_t */*dummy*/)
{
// Beauty pT
const Double_t kpt0 = 4.;
return x/TMath::Power(pass1,kxn);
}
// y-distribution
-Double_t AliGenMUONlib::YBeauty( Double_t *px, Double_t *dummy)
+Double_t AliGenMUONlib::YBeauty( Double_t *px, Double_t */*dummy*/)
{
// Beauty y
Double_t *dum=0;
return func;
}
typedef Int_t (*GenFuncIp) (TRandom *);
-GenFuncIp AliGenMUONlib::GetIp(Int_t param, const char* tname) const
+GenFuncIp AliGenMUONlib::GetIp(Int_t param, const char* /*tname*/) const
{
// Return pointer to particle type parameterisation
GenFuncIp func;
// Particle distribution IdPi0Flat 111 (pi0)
//
-Double_t AliGenPHOSlib::PtPi0Flat(Double_t *px, Double_t *)
+Double_t AliGenPHOSlib::PtPi0Flat(Double_t */*px*/, Double_t *)
{
// Pion transverse momentum flat distribution
}
-Double_t AliGenPHOSlib::YPi0Flat( Double_t *py, Double_t *)
+Double_t AliGenPHOSlib::YPi0Flat( Double_t */*py*/, Double_t *)
{
// pion y-distribution
// Particle distribution IdEtaFlat 111 (pi0)
//
-Double_t AliGenPHOSlib::PtEtaFlat(Double_t *px, Double_t *)
+Double_t AliGenPHOSlib::PtEtaFlat(Double_t */*px*/, Double_t *)
{
// Eta transverse momentum flat distribution
}
-Double_t AliGenPHOSlib::YEtaFlat( Double_t *py, Double_t *)
+Double_t AliGenPHOSlib::YEtaFlat( Double_t */*py*/, Double_t *)
{
//
// pion y-distribution
typedef Double_t (*GenFunc) (Double_t*, Double_t*);
- GenFunc AliGenPHOSlib::GetPt(Int_t param, const char* tname) const
+GenFunc AliGenPHOSlib::GetPt(Int_t param, const char* /*tname*/) const
{
// Return pinter to pT parameterisation
GenFunc func;
return func;
}
- GenFunc AliGenPHOSlib::GetY(Int_t param, const char* tname) const
+GenFunc AliGenPHOSlib::GetY(Int_t param, const char* /*tname*/) const
{
// Return pointer to Y parameterisation
GenFunc func;
return func;
}
typedef Int_t (*GenFuncIp) (TRandom *);
- GenFuncIp AliGenPHOSlib::GetIp(Int_t param, const char* tname) const
+GenFuncIp AliGenPHOSlib::GetIp(Int_t param, const char* /*tname*/) const
{
// Return pointer to particle composition
GenFuncIp func;
//
// Neutral Pions
-Double_t AliGenPMDlib::PtPi0(Double_t *px, Double_t *dummy)
+Double_t AliGenPMDlib::PtPi0(Double_t *px, Double_t */*dummy*/)
{
//
// PT-PARAMETERIZATION CDF, PRL 61(88) 1819
//
// y-distribution
//
-Double_t AliGenPMDlib::YPi0( Double_t *py, Double_t *dummy)
+Double_t AliGenPMDlib::YPi0( Double_t *py, Double_t */*dummy*/)
{
//
// y parametrisation for pi0
// pt-distribution
//____________________________________________________________
-Double_t AliGenPMDlib::PtEta( Double_t *px, Double_t *dummy)
+Double_t AliGenPMDlib::PtEta( Double_t *px, Double_t */*dummy*/)
{
// Kaon pT
return PtScal(*px,3);
// y-distribution
//____________________________________________________________
-Double_t AliGenPMDlib::YEta( Double_t *py, Double_t *dummy)
+Double_t AliGenPMDlib::YEta( Double_t *py, Double_t */*dummy*/)
{
//
// y parametrisation for etas
typedef Double_t (*GenFunc) (Double_t*, Double_t*);
-GenFunc AliGenPMDlib::GetPt(Int_t param, const char* tname) const
+GenFunc AliGenPMDlib::GetPt(Int_t param, const char* /*tname*/) const
{
// Return pointer to pT parameterisation
GenFunc func=NULL;
return func;
}
-GenFunc AliGenPMDlib::GetY(Int_t param, const char* tname) const
+GenFunc AliGenPMDlib::GetY(Int_t param, const char* /*tname*/) const
{
// Return pointer to y- parameterisation
GenFunc func=NULL;
}
typedef Int_t (*GenFuncIp) (TRandom *);
-GenFuncIp AliGenPMDlib::GetIp(Int_t param, const char* tname) const
+GenFuncIp AliGenPMDlib::GetIp(Int_t param, const char* /*tname*/) const
{
// Return pointer to particle type parameterisation
GenFuncIp func=NULL;
AliGenParam::AliGenParam(const AliGenParam & Param)
+ :AliGenMC(Param)
{
-// copy constructor
+// Copy constructor
Param.Copy(*this);
}
AliGenParam& AliGenParam::operator=(const AliGenParam& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
virtual void SetDecayer(AliDecayer* decayer) {fDecayer = decayer;}
virtual void Draw();
AliGenParam & operator=(const AliGenParam & rhs);
+ private:
+ void Copy(AliGenParam&) const;
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
AliGenReader& AliGenReader::operator=(const AliGenReader& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
// Need to be implemented in the implementation classes. Interface dies.
Fatal("AliGenReader::RewindEvent","\nMethod RewindEvent not present in the implementation class.\n");
}
+
+void AliGenReader::Copy(AliGenReader&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
+
{
public:
AliGenReader():fFileName(NULL),fCode(kPDG){;}
- AliGenReader(const AliGenReader &reader):fFileName(NULL),fCode(kPDG){;}
-
+ AliGenReader(const AliGenReader &reader)
+ :TObject(reader), fFileName(NULL), fCode(kPDG){reader.Copy(*this);}
virtual ~AliGenReader(){;}
// Initialise
virtual void Init() {}
void SetParticleCode(Code_t code) {fCode = code;}
virtual TParticle* NextParticle(){return NULL;}
virtual void RewindEvent();
-
AliGenReader & operator=(const AliGenReader & rhs);
+ private:
+ void Copy(AliGenReader&) const;
protected:
const Text_t *fFileName; // Name of file to read from
Code_t fCode; // Particle code type
AliGenReaderCwn& AliGenReaderCwn::operator=(const AliGenReaderCwn& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
+void AliGenReaderCwn::Copy(AliGenReaderCwn&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
public:
AliGenReaderCwn();
- AliGenReaderCwn(const AliGenReaderCwn &reader){;}
+ AliGenReaderCwn(const AliGenReaderCwn &reader):AliGenReader(reader)
+ {reader.Copy(*this);}
virtual ~AliGenReaderCwn();
// Initialise
virtual void Init();
virtual Int_t NextEvent();
virtual TParticle* NextParticle();
AliGenReaderCwn & operator=(const AliGenReaderCwn & rhs);
+ private:
+ void Copy(AliGenReaderCwn&) const;
+
protected:
Int_t fNcurrent; // points to the next entry
Int_t fNparticle; // particle number in event
AliGenReaderEcalHijing& AliGenReaderEcalHijing::operator=(const AliGenReaderEcalHijing& rhs)
{
// Assignment operator
- return *this;
+ rhs.Copy(*this);
+ return (*this);
+}
+
+void AliGenReaderEcalHijing::Copy(AliGenReaderEcalHijing&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
}
public:
AliGenReaderEcalHijing();
- AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader){;}
+ AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader):AliGenReader(reader)
+ {reader.Copy(*this);}
virtual ~AliGenReaderEcalHijing(){;}
// Initialise
virtual void Init();
virtual Int_t NextEvent();
virtual TParticle* NextParticle();
AliGenReaderEcalHijing & operator=(const AliGenReaderEcalHijing & rhs);
+ private:
+ void Copy(AliGenReaderEcalHijing&) const;
protected:
Int_t fNcurrent; // points to the next entry
Int_t fNparticle; //
AliGenReaderEcalJets& AliGenReaderEcalJets::operator=(const AliGenReaderEcalJets& rhs)
{
// Assignment operator
- return *this;
+ rhs.Copy(*this);
+ return (*this);
}
+void AliGenReaderEcalJets::Copy(AliGenReaderEcalJets&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
public:
AliGenReaderEcalJets();
- AliGenReaderEcalJets(const AliGenReaderEcalJets &reader){;}
+ AliGenReaderEcalJets(const AliGenReaderEcalJets &reader):AliGenReader(reader)
+ {reader.Copy(*this);}
virtual ~AliGenReaderEcalJets(){;}
// Initialise
virtual void Init();
virtual Int_t NextEvent();
virtual TParticle* NextParticle();
AliGenReaderEcalJets & operator=(const AliGenReaderEcalJets & rhs);
+ private:
+ void Copy(AliGenReaderEcalJets&) const;
protected:
Int_t fNcurrent; // points to the next event
Int_t fNparticle; // points to the next particle
const TString AliGenReaderTreeK::fgkEventFolderName("GenReaderTreeK");
AliGenReaderTreeK::AliGenReaderTreeK():
- AliGenReader(),
- fNcurrent(0),
- fNparticle(0),
- fNp(0),
- fInRunLoader(0),
- fBaseFile(0),
- fStack(0),
- fOnlyPrimaries(kFALSE),
- fDirs(0x0),
- fCurrentDir(0)
+ AliGenReader(),
+ fNcurrent(0),
+ fNparticle(0),
+ fNp(0),
+ fInRunLoader(0),
+ fBaseFile(0),
+ fStack(0),
+ fOnlyPrimaries(kFALSE),
+ fDirs(0x0),
+ fCurrentDir(0)
{
// Default constructor
}
AliGenReaderTreeK::AliGenReaderTreeK(const AliGenReaderTreeK &reader):
- fNcurrent(0),
- fNparticle(0),
- fNp(0),
- fInRunLoader(0),
- fBaseFile(0),
- fStack(0),
- fOnlyPrimaries(kFALSE),
- fDirs(0x0),
- fCurrentDir(0)
+ AliGenReader(reader),
+ fNcurrent(0),
+ fNparticle(0),
+ fNp(0),
+ fInRunLoader(0),
+ fBaseFile(0),
+ fStack(0),
+ fOnlyPrimaries(kFALSE),
+ fDirs(0x0),
+ fCurrentDir(0)
{
- ;
+ reader.Copy(*this);
}
AliGenReaderTreeK& AliGenReaderTreeK::operator=(const AliGenReaderTreeK& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
+void AliGenReaderTreeK::Copy(AliGenReaderTreeK&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
TString& AliGenReaderTreeK::GetDirName(Int_t entry)
AliGenReaderTreeK & operator=(const AliGenReaderTreeK & rhs);
void SetDirs(TObjArray* dirs){fDirs = dirs;} //sets array directories names
void AddDir(const char* dirname);
+ private:
+ void Copy(AliGenReaderTreeK&) const;
protected:
Int_t fNcurrent; // points to the next entry
Int_t fNparticle; // Next particle in list
typedef Double_t (*GenFunc) (Double_t*, Double_t*);
- GenFunc AliGenSTRANGElib::GetPt(Int_t param, const char* tname) const
+ GenFunc AliGenSTRANGElib::GetPt(Int_t param, const char* /*tname*/) const
{
// Return pinter to pT parameterisation
GenFunc func;
return func;
}
- GenFunc AliGenSTRANGElib::GetY(Int_t param, const char* tname) const
+ GenFunc AliGenSTRANGElib::GetY(Int_t param, const char* /*tname*/) const
{
// Return pointer to Y parameterisation
GenFunc func;
return func;
}
typedef Int_t (*GenFuncIp) (TRandom *);
- GenFuncIp AliGenSTRANGElib::GetIp(Int_t param, const char* tname) const
+ GenFuncIp AliGenSTRANGElib::GetIp(Int_t param, const char* /*tname*/) const
{
// Return pointer to particle composition
GenFuncIp func;
public:
AliSlowNucleonModel() {;}
virtual ~AliSlowNucleonModel(){;}
- virtual void GetNumberOfSlowNucleons(AliCollisionGeometry* geo,
- Int_t& ngp, Int_t& ngn,
- Int_t& nbp, Int_t& nbn) {;}
+ virtual void GetNumberOfSlowNucleons(AliCollisionGeometry* /*geo*/,
+ Int_t& /*ngp*/, Int_t& /*ngn*/,
+ Int_t& /*nbp*/, Int_t& /*nbn*/) {;}
protected:
ClassDef(AliSlowNucleonModel,1) // Gray Particle Model