//____________________________________________________________________________
AliPHOS::~AliPHOS()
{
+ // dtor
delete fHits ;
delete fDigits ;
}
}
//____________________________________________________________________________
-RecPointsList * AliPHOS::EmcRecPoints(Int_t evt)
+AliPHOSRecPoint::RecPointsList * AliPHOS::EmcRecPoints(Int_t evt)
{
// returns the pointer to the EMCA RecPoints list
// if the list is empty, get it from TreeR on the disk file
- RecPointsList * rv = 0 ;
+ AliPHOSRecPoint::RecPointsList * rv = 0 ;
if ( fEmcRecPoints )
rv = fEmcRecPoints ;
}
//____________________________________________________________________________
-RecParticlesList * AliPHOS::RecParticles(Int_t evt)
+AliPHOSRecParticle::RecParticlesList * AliPHOS::RecParticles(Int_t evt)
{
// returns the pointer to the RecParticles list
// if the list is empty, get it from TreeR on the disk file
- RecParticlesList * rv = 0 ;
+ AliPHOSRecParticle::RecParticlesList * rv = 0 ;
if ( fRecParticles )
rv = fRecParticles ;
}
//____________________________________________________________________________
-RecParticlesList * AliPHOS::TrackSegments(Int_t evt)
+AliPHOSRecParticle::RecParticlesList * AliPHOS::TrackSegments(Int_t evt)
{
// returns the pointer to the TrackSegments list
// if the list is empty, get it from TreeR on the disk file
- TrackSegmentsList * rv = 0 ;
+ AliPHOSTrackSegment::TrackSegmentsList * rv = 0 ;
if ( fTrackSegments )
rv = fTrackSegments ;
public:
AliPHOS(const char* name, const char* title): AliDetector(name,title) {}
- AliPHOS() : AliDetector() {}
+ AliPHOS() : AliDetector() {
+ // default ctor
+ }
virtual ~AliPHOS() ;
- virtual void CreateMaterials() ; // defines the material of the detector
+ virtual void CreateMaterials() ; // defines the material of the detector
virtual AliPHOSGeometry * GetGeometry() = 0 ;
- RecPointsList* EmcRecPoints(Int_t evt=0) ; // gets Array of cluster in the crystals
- RecParticlesList * RecParticles(Int_t evt = 0) ; // gets Array of reconstructed particles
- TrackSegmentsList * TrackSegments(Int_t evt=0) ; // gets Array of track segments
- virtual RecPointsList* PpsdRecPoints(Int_t evt=0)=0; // gets Array of clusters in the PPSD
- virtual TString Version() {return TString(" ") ; }
+ AliPHOSRecPoint::RecPointsList* EmcRecPoints(Int_t evt=0) ; // gets Array of cluster in the crystals
+ AliPHOSRecParticle::RecParticlesList* RecParticles(Int_t evt = 0) ; // gets Array of reconstructed particles
+ AliPHOSTrackSegment::TrackSegmentsList* TrackSegments(Int_t evt=0) ;// gets Array of track segments
+ virtual AliPHOSRecPoint::RecPointsList* PpsdRecPoints(Int_t evt=0)=0;// gets Array of clusters in the PPSD
+ virtual TString Version() {
+ // gives the version number (void for the base class)
+ return TString(" ") ; }
protected:
- RecPointsList * fEmcRecPoints ; // The RecPoints (clusters) list in EMC
- TrackSegmentsList * fTrackSegments ; // The TrackSegment list in PHOS
- RecParticlesList * fRecParticles ; // The reconstructed particles list in PHOS
+ AliPHOSRecPoint::RecPointsList * fEmcRecPoints ; // The RecPoints (clusters) list in EMC
+ AliPHOSTrackSegment::TrackSegmentsList * fTrackSegments ;// The TrackSegment list in PHOS
+ AliPHOSRecParticle::RecParticlesList * fRecParticles ; // The reconstructed particles list in PHOS
ClassDef(AliPHOS,2) // Photon Spectrometer Detector (base class)
}
}
+//____________________________________________________________________________
+AliPHOSAnalyze::AliPHOSAnalyze(const AliPHOSAnalyze & ana)
+{
+ // copy ctor
+ ( (AliPHOSAnalyze &)ana ).Copy(*this) ;
+}
+
+//____________________________________________________________________________
+AliPHOSAnalyze::Copy(TObject & obj)
+{
+ // copy an analysis into an other one
+ TObject::Copy(obj) ;
+ // I do nothing more because the copy is silly but the Code checkers requires one
+}
+
//____________________________________________________________________________
AliPHOSAnalyze::~AliPHOSAnalyze()
{
//fhElectronPositionY->Fill(recpart. ) ;
cout << "ELECTRON" << endl;
break;
- case kNEUTRAL_HA:
+ case kNEUTRALHA:
fhNeutralHadronEnergy->Fill(recparticle->Energy() ) ;
//fhNeutralHadronPositionX->Fill(recpart. ) ;
//fhNeutralHadronPositionY->Fill(recpart. ) ;
cout << "NEUTRAl HADRON" << endl;
break ;
- case kNEUTRAL_EM:
+ case kNEUTRALEM:
fhNeutralEMEnergy->Fill(recparticle->Energy() ) ;
//fhNeutralEMPositionX->Fill(recpart. ) ;
//fhNeutralEMPositionY->Fill(recpart. ) ;
//cout << "NEUTRAL EM" << endl;
break ;
- case kCHARGED_HA:
+ case kCHARGEDHA:
fhChargedHadronEnergy->Fill(recparticle->Energy() ) ;
//fhChargedHadronPositionX->Fill(recpart. ) ;
//fhChargedHadronPositionY->Fill(recpart. ) ;
cout << "CHARGED HADRON" << endl;
break ;
- case kGAMMA_HA:
+ case kGAMMAHA:
fhPhotonHadronEnergy->Fill(recparticle->Energy() ) ;
//fhPhotonHadronPositionX->Fill(recpart. ) ;
//fhPhotonHadronPositionY->Fill(recpart. ) ;
Text_t canvasname[80] ;
sprintf(canvasname, "Reconstructed particles in PHOSmodule # %d", module) ;
TCanvas * rparticlecanvas = new TCanvas("RparticleCanvas", canvasname, 650, 500) ;
- RecParticlesList * rpl = fPHOS->RecParticles() ;
+ AliPHOSRecParticle::RecParticlesList * rpl = fPHOS->RecParticles() ;
Int_t nRecParticles = rpl->GetEntries() ;
Int_t nRecParticlesInModule = 0 ;
TIter nextRecPart(rpl) ;
TCanvas * trackcanvas = new TCanvas("TrackSegmentCanvas", canvasname, 650, 500) ;
histotrack->Draw() ;
- TrackSegmentsList * trsegl = fPHOS->TrackSegments() ;
+ AliPHOSTrackSegment::TrackSegmentsList * trsegl = fPHOS->TrackSegments() ;
AliPHOSTrackSegment * trseg ;
Int_t nTrackSegments = trsegl->GetEntries() ;
AliPHOSAnalyze() ; // ctor
AliPHOSAnalyze(Text_t * name) ; // ctor
+ AliPHOSAnalyze(const AliPHOSAnalyze & ana) ; // cpy ctor
virtual ~AliPHOSAnalyze() ; // dtor
void AnalyzeOneEvent(Int_t evt = -999) ; // analyzes a single event ;
void AnalyzeManyEvents(Int_t Nevtents = 100, Int_t Module=0) ; // analyzes many events ;
void BookingHistograms() ; // booking histograms for the ManyEvent analysis ;
+ void Copy(TObject & obj) ; // copies an analysis into an other one
Bool_t Init(Int_t evt) ; // does various initialisations
void DisplayKineEvent(Int_t evt = -999) ; // displays the Kine events in ALICE coordinate
void DisplayRecParticles() ; // displays RecParticles in ALICE coordinate
Bool_t OpenRootFile(Text_t * name) ; // opens the root file
void SavingHistograms() ; // Save histograms in a root file
-private:
+ private:
AliPHOSClusterizer * fClu ; // a clusterizer
Int_t fEvt ; // the evt number being processed
virtual Float_t GetPpsdClusteringThreshold() = 0 ;
virtual Float_t GetPpsdEnergyThreshold() = 0 ;
- virtual void MakeClusters(const DigitsList * dl, RecPointsList * emccl, RecPointsList * ppsdl) = 0 ;
+ virtual void MakeClusters(const DigitsList * dl, AliPHOSRecPoint::RecPointsList * emccl, AliPHOSRecPoint::RecPointsList * ppsdl) = 0 ;
virtual void PrintParameters() = 0 ;
virtual void SetCalibrationParameters(Float_t A, Float_t B) = 0 ;
virtual void SetEmcClusteringThreshold(Float_t cluth) = 0 ;
}
//____________________________________________________________________________
-void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl, RecPointsList * emcl, RecPointsList * ppsdl)
+void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
+ AliPHOSRecPoint::RecPointsList * emcl,
+ AliPHOSRecPoint::RecPointsList * ppsdl)
{
// Steering method to construct the clusters stored in a list of Reconstructed Points
// A cluster is defined as a list of neighbour digits
virtual Float_t GetPpsdEnergyThreshold() { return fPpsdEnergyThreshold; }
virtual Bool_t IsInEmc(AliPHOSDigit * digit) ; // Tells if id digit is in EMC
- virtual void MakeClusters(const DigitsList * dl, RecPointsList * emcl, RecPointsList * ppsdl) ; // does the job
+ virtual void MakeClusters(const DigitsList * dl,
+ AliPHOSRecPoint::RecPointsList * emcl,
+ AliPHOSRecPoint::RecPointsList * ppsdl) ; // does the job
virtual void PrintParameters() ;
virtual void SetCalibrationParameters(Float_t A,Float_t B){ fA = A ; fB = B;}
virtual void SetEmcClusteringThreshold(Float_t cluth) { fEmcClusteringThreshold = cluth ; }
// Compares two digits with respect to its Id
// to sort according increasing Id
- Int_t rv ;
+ Int_t rv ;
AliPHOSDigit * digit = (AliPHOSDigit *)obj ;
class AliPHOSDigit : public AliDigitNew {
-public:
-
+ public:
+
AliPHOSDigit() ;
AliPHOSDigit(Int_t primary, Int_t id, Int_t DigEnergy, Int_t index = -1) ;
AliPHOSDigit(const AliPHOSDigit & digit) ;
- virtual ~AliPHOSDigit(){}
+ virtual ~AliPHOSDigit(){
+ // dtor
+ }
Bool_t operator==(AliPHOSDigit const &rValue) const;
AliPHOSDigit& operator+(AliPHOSDigit const &rValue) ;
friend class ostream& operator << ( ostream& , const AliPHOSDigit&) ;
Int_t Compare(TObject * obj) ;
- Int_t GetNprimary() const { return fNprimary ; }
+ Int_t GetNprimary() const {
+ // returns the number of primaries
+ return fNprimary ; }
Int_t GetPrimary(Int_t index) const ;
- Bool_t IsSortable() const { return kTRUE ; }
- void SetAmp(Int_t Amp) { fAmp=Amp ; }
+ Bool_t IsSortable() const {
+ // says that AliPHOSDigits are sortable (needed for Sort method
+ return kTRUE ; }
+ void SetAmp(Int_t Amp) {
+ // sets the amplitude data member
+ fAmp=Amp ; }
-private:
+ private:
Int_t fPrimary1 ; // first primary (because objects in a TClonesArray bust have constant length)
Int_t fPrimary2 ; // second primary (because objects in a TClonesArray bust have constant lengt)
//____________________________________________________________________________
AliPHOSEmcRecPoint::~AliPHOSEmcRecPoint()
{
+ // dtor
if ( fEnergyList )
delete[] fEnergyList ;
}
Int_t iDigit;
Int_t relid[4] ;
- const Int_t fMulDigit = AliPHOSEmcRecPoint::GetDigitsMultiplicity() ;
- Float_t * xi = new Float_t[fMulDigit] ;
- Float_t * zi = new Float_t[fMulDigit] ;
+ const Int_t kMulDigit = AliPHOSEmcRecPoint::GetDigitsMultiplicity() ;
+ Float_t * xi = new Float_t[kMulDigit] ;
+ Float_t * zi = new Float_t[kMulDigit] ;
// create the histogram for the single cluster
// 1. gets histogram boundaries
Float_t ximin = 999. ;
Float_t zimin = 999. ;
- for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+ for(iDigit=0; iDigit<kMulDigit; iDigit++) {
digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
phosgeom->RelPosInModule(relid, xi[iDigit], zi[iDigit]);
histo = new TH2F("cluster3D", title, xdim, ximin, ximax, zdim, zimin, zimax) ;
Float_t x, z ;
- for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+ for(iDigit=0; iDigit<kMulDigit; iDigit++) {
digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
phosgeom->RelPosInModule(relid, x, z);
}
if (!digitgraph) {
- digitgraph = new TGraph(fMulDigit,xi,zi);
+ digitgraph = new TGraph(kMulDigit,xi,zi);
digitgraph-> SetMarkerStyle(5) ;
digitgraph-> SetMarkerSize(1.) ;
digitgraph-> SetMarkerColor(1) ;
AliPHOSGeometry * phosgeom = (AliPHOSGeometry *) fGeom ;
Int_t iDigit;
- for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+ for(iDigit=0; iDigit < fMulDigit; iDigit++) {
digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
Int_t relid[4] ;
Float_t xi ;
}
//______________________________________________________________________________
-void AliPHOSEmcRecPoint::Streamer(TBuffer &R__b)
-{
- // Stream an object of class AliPHOSEmcRecPoint.
-
- if (R__b.IsReading()) {
- Version_t R__v = R__b.ReadVersion(); if (R__v) { }
- AliPHOSRecPoint::Streamer(R__b);
- R__b >> fDelta;
- fEnergyList = new Float_t[fMulDigit] ;
- R__b.ReadFastArray(fEnergyList, fMulDigit);
- R__b >> fLocMaxCut;
- R__b >> fW0;
- } else {
- R__b.WriteVersion(AliPHOSEmcRecPoint::IsA());
- AliPHOSRecPoint::Streamer(R__b);
- R__b << fDelta;
- R__b.WriteFastArray(fEnergyList, fMulDigit);
- R__b << fLocMaxCut;
- R__b << fW0;
- }
-}
+// void AliPHOSEmcRecPoint::Streamer(TBuffer &R__b)
+// {
+// // Stream an object of class AliPHOSEmcRecPoint.
+
+// if (R__b.IsReading()) {
+// Version_t R__v = R__b.ReadVersion(); if (R__v) { }
+// AliPHOSRecPoint::Streamer(R__b);
+// R__b >> fDelta;
+// fEnergyList = new Float_t[fMulDigit] ;
+// R__b.ReadFastArray(fEnergyList, fMulDigit);
+// R__b >> fLocMaxCut;
+// R__b >> fW0;
+// } else {
+// R__b.WriteVersion(AliPHOSEmcRecPoint::IsA());
+// AliPHOSRecPoint::Streamer(R__b);
+// R__b << fDelta;
+// R__b.WriteFastArray(fEnergyList, fMulDigit);
+// R__b << fLocMaxCut;
+// R__b << fW0;
+// }
+// }
+
public:
- AliPHOSEmcRecPoint(){} ;
+ AliPHOSEmcRecPoint(){
+ // default ctor
+ } ;
AliPHOSEmcRecPoint(Float_t W0, Float_t LocMaxCut) ;
virtual ~AliPHOSEmcRecPoint() ;
virtual void AddDigit(AliPHOSDigit & digit, Float_t Energy) ; // add a digit to the digits list
Int_t Compare(TObject * obj) ; // method for sorting
- Float_t GetDelta (){ return fDelta ; }
+ Float_t GetDelta (){
+ // gets the fDelta data member
+ return fDelta ; }
Float_t GetDispersion() ; // computes the dispersion of the shower
void GetElipsAxis(Float_t * lambda) ; // computes the axis of shower ellipsoide
- Float_t * GetEnergiesList(){return fEnergyList ;}
+ Float_t * GetEnergiesList(){
+ // gets the list of energies makink this recpoint
+ return fEnergyList ;}
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ;
- Float_t GetLocMaxCut () {return fLocMaxCut ; }
- Float_t GetLogWeightCut (){return fW0 ; }
+ Float_t GetLocMaxCut () {
+ // gets the cut of the local maximum search
+ return fLocMaxCut ; }
+ Float_t GetLogWeightCut (){
+ // gets the logarythmic weight for the center of gravity calculation
+ return fW0 ; }
Float_t GetMaximalEnergy(void) ; // get the highest energy in the cluster
- Int_t GetMaximumMultiplicity() { return fMaxDigit ; }
- Int_t GetMultiplicity(void) const { return fMulDigit ; }
+ Int_t GetMaximumMultiplicity() {
+ // gets the maximum number of digits allowed
+ return fMaxDigit ; }
+ Int_t GetMultiplicity(void) const {
+ // gets the number of digits making this recpoint
+ return fMulDigit ; }
Int_t GetMultiplicityAtLevel(const Float_t level) ; // computes multiplicity of digits with energy above relative level
Int_t GetNumberOfLocalMax(Int_t * maxAt, Float_t * maxAtEnergy) ; // searches for the local maxima
- Float_t GetTotalEnergy(void) const { return fAmp ; } // in EMC RecPoint Amp = Energy
- void GetLocalPosition(TVector3 &Lpos) ; // computes the position in the PHOS module
- Bool_t IsEmc(void) {return kTRUE ; }
- Bool_t IsSortable() const { return kTRUE ; }
+ Float_t GetTotalEnergy(void) const {
+ // gets the total amplitude of this recpoint (in EMC RecPoint Amp = Energy)
+ return fAmp ; }
+ void GetLocalPosition(TVector3 &Lpos) ; // computes the position in the PHOS module
+ Bool_t IsEmc(void) {
+ // true if the recpoint is in EMC
+ return kTRUE ; }
+ Bool_t IsSortable() const {
+ // says that emcrecpoints are sortable objects
+ return kTRUE ; }
void Print(Option_t * opt = "void") ;
private:
Bool_t AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) ;
Float_t fDelta ; // parameter used to sort the clusters
- Float_t *fEnergyList ; // energy of digits
+ Float_t *fEnergyList ; //[fMulDigit] energy of digits
Float_t fLocMaxCut ; // minimum energy difference to distinguish two maxima
Float_t fW0 ; // logarithmic weight factor for center of gravity calculation
case kELECTRON:
name = "ELECTRON" ;
break ;
- case kCHARGED_HA:
+ case kCHARGEDHA:
name = "CHARGED_HA" ;
break ;
- case kNEUTRAL_HA:
+ case kNEUTRALHA:
name = "NEUTRAL_HA" ;
break ;
- case kNEUTRAL_EM:
+ case kNEUTRALEM:
name = "NEUTRAL_EM" ;
break ;
- case kGAMMA_HA:
+ case kGAMMAHA:
name = "PHOTON_HA" ;
break ;
// --- AliRoot header files ---
-typedef TClonesArray FastRecParticlesList ;
-
const static Int_t kUNDEFINED =-1 ;
-const static Int_t kNEUTRAL_EM = 0 ;
-const static Int_t kNEUTRAL_HA = 1 ;
-const static Int_t kGAMMA = 2 ;
-const static Int_t kGAMMA_HA = 3 ;
-const static Int_t kABSURD_EM = 4 ;
-const static Int_t kABSURD_HA = 5 ;
-const static Int_t kELECTRON = 6 ;
-const static Int_t kCHARGED_HA = 7 ;
+const static Int_t kNEUTRALEM = 0 ;
+const static Int_t kNEUTRALHA = 1 ;
+const static Int_t kGAMMA = 2 ;
+const static Int_t kGAMMAHA = 3 ;
+const static Int_t kABSURDEM = 4 ;
+const static Int_t kABSURDHA = 5 ;
+const static Int_t kELECTRON = 6 ;
+const static Int_t kCHARGEDHA = 7 ;
class AliPHOSFastRecParticle : public TParticle {
-public:
+ public:
- AliPHOSFastRecParticle() {}; // ctor
+ AliPHOSFastRecParticle() {
+ // ctor
+ };
AliPHOSFastRecParticle(const AliPHOSFastRecParticle & rp) ; // ctor
AliPHOSFastRecParticle(const TParticle & p) ; // ctor
- virtual ~AliPHOSFastRecParticle(){} // dtor
-
+ virtual ~AliPHOSFastRecParticle(){
+ // dtor
+ }
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py) ;
virtual void Draw(Option_t *option) ;
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ;
- Int_t GetIndexInList() const { return fIndexInList ; }
+ Int_t GetIndexInList() const {
+ // returns the index of this in the list
+ return fIndexInList ;
+ }
virtual Int_t * GetPrimaries(Int_t & number) ;
- Int_t GetType() { return fType ; }
+ Int_t GetType() {
+ // returns the type of the particle
+ return fType ;
+ }
TString Name() ;
virtual void Paint(Option_t * option="");
void Print() ;
- void SetPrimary(Int_t index) { fPrimary = index ; }
- void SetType(Int_t type) { fType = type ; }
- void SetIndexInList(Int_t val) { fIndexInList = val ; }
-
-protected:
+ void SetPrimary(Int_t index) {
+ // sets the primary particle index
+ fPrimary = index ;
+ }
+ void SetType(Int_t type) {
+ // sets the particle type
+ fType = type ;
+ }
+ void SetIndexInList(Int_t val) {
+ // sets the value of the index in the list
+ fIndexInList = val ;
+ }
+
+ protected:
Int_t fIndexInList ; // the index of this RecParticle in the list stored in TreeR (to be set by analysis)
Int_t fPrimary ; // (unique) primary particle index
Int_t fType ; // particle type obtained by "virtual" reconstruction
+ private:
+
+ typedef TClonesArray FastRecParticlesList ;
+
ClassDef(AliPHOSFastRecParticle,1) // Reconstructed Particle produced by the fast simulation
};
ClassImp(AliPHOSGeometry)
- AliPHOSGeometry * AliPHOSGeometry::fGeom = 0 ;
+ AliPHOSGeometry * AliPHOSGeometry::fgGeom = 0 ;
//____________________________________________________________________________
AliPHOSGeometry::~AliPHOSGeometry(void)
{
// Returns the pointer of the unique instance
- return (AliPHOSGeometry *) fGeom ;
+ return (AliPHOSGeometry *) fgGeom ;
}
//____________________________________________________________________________
// Returns the pointer of the unique instance
AliPHOSGeometry * rv = 0 ;
- if ( fGeom == 0 ) {
- fGeom = new AliPHOSGeometry(name, title) ;
- rv = (AliPHOSGeometry * ) fGeom ;
+ if ( fgGeom == 0 ) {
+ fgGeom = new AliPHOSGeometry(name, title) ;
+ rv = (AliPHOSGeometry * ) fgGeom ;
}
else {
- if ( strcmp(fGeom->GetName(), name) != 0 ) {
- cout << "AliPHOSGeometry <E> : current geometry is " << fGeom->GetName() << endl
+ if ( strcmp(fgGeom->GetName(), name) != 0 ) {
+ cout << "AliPHOSGeometry <E> : current geometry is " << fgGeom->GetName() << endl
<< " you cannot call " << name << endl ;
}
else
- rv = (AliPHOSGeometry *) fGeom ;
+ rv = (AliPHOSGeometry *) fgGeom ;
}
return rv ;
}
public:
- AliPHOSGeometry() {} ; // must be kept public for root persistency purposes, but should never be called by the outside world
+ AliPHOSGeometry() {
+ // default ctor
+ // must be kept public for root persistency purposes, but should never be called by the outside world
+ } ;
virtual ~AliPHOSGeometry(void) ;
static AliPHOSGeometry * GetInstance(const Text_t* name, const Text_t* title) ;
static AliPHOSGeometry * GetInstance() ;
Float_t fPPSDModuleSize[3] ; // Size of an individual micromegas module
Float_t fZDisplacement ; // Z displacement of micromegas1 with respect to micromegas2
- static AliPHOSGeometry * fGeom ; // pointer to the unique instance of the singleton
+ static AliPHOSGeometry * fgGeom ; // pointer to the unique instance of the singleton
ClassDef(AliPHOSGeometry,1) // PHOS geometry class
public:
- AliPHOSHit() {}
+ AliPHOSHit() {
+ // default ctor
+ }
AliPHOSHit(const AliPHOSHit & hit) ;
AliPHOSHit(Int_t primary, Int_t id, Float_t *hits) ;
AliPHOSHit(Int_t shunt, Int_t primary, Int_t tracknumber, Int_t id, Float_t *hits) ;
- virtual ~AliPHOSHit(void) {}
+ virtual ~AliPHOSHit(void) {
+ // dtor
+ }
- Float_t GetEnergy(void) const { return fELOS ; }
- Int_t GetId(void) const { return fId ; }
- Int_t GetPrimary(void) const { return fPrimary ; }
+ Float_t GetEnergy(void) const {
+ // returns the energy loss for this hit
+ return fELOS ;
+ }
+ Int_t GetId(void) const {
+ // return the identificator of this his
+ return fId ;
+ }
+ Int_t GetPrimary(void) const {
+ // returns the primary particle id at the origine of this hit
+ return fPrimary ;
+ }
Bool_t operator == (AliPHOSHit const &rValue) const ;
AliPHOSHit operator + (const AliPHOSHit& rValue) const ;
ClassImp(AliPHOSIndexToObject)
- AliPHOSIndexToObject * AliPHOSIndexToObject::fObjGetter = 0 ;
+ AliPHOSIndexToObject * AliPHOSIndexToObject::fgObjGetter = 0 ;
//____________________________________________________________________________
AliPHOSIndexToObject::AliPHOSIndexToObject(AliPHOS * det)
// Returns the pointer of the unique instance already defined
AliPHOSIndexToObject * rv = 0 ;
- if ( fObjGetter )
- rv = fObjGetter ;
+ if ( fgObjGetter )
+ rv = fgObjGetter ;
else
cout << "AliPHOSIndexToObject::GetInstance ERROR: not yet initialized" << endl ;
// Creates and returns the pointer of the unique instance
// Must be called only when the environment has changed (a new event for exemple)
- if ( fObjGetter ) // delete it if already exists
- delete fObjGetter ;
+ if ( fgObjGetter ) // delete it if already exists
+ delete fgObjGetter ;
- fObjGetter = new AliPHOSIndexToObject(det) ;
+ fgObjGetter = new AliPHOSIndexToObject(det) ;
- return fObjGetter ;
+ return fgObjGetter ;
}
AliPHOSRecParticle * rv = 0 ;
- RecParticlesList * rplist = fDetector->RecParticles() ;
+ AliPHOSRecParticle::RecParticlesList * rplist = fDetector->RecParticles() ;
Int_t rpentries = 0 ;
AliPHOSRecPoint * rv = 0 ;
- RecPointsList * emclist = fDetector->EmcRecPoints() ;
- RecPointsList * ppsdlist = fDetector->PpsdRecPoints() ;
+ AliPHOSRecPoint::RecPointsList * emclist = fDetector->EmcRecPoints() ;
+ AliPHOSRecPoint::RecPointsList * ppsdlist = fDetector->PpsdRecPoints() ;
Int_t emcentries = 0 ;
Int_t ppsdentries = 0 ;
AliPHOSTrackSegment * rv = 0 ;
- TrackSegmentsList * tslist = fDetector->TrackSegments() ;
+ AliPHOSTrackSegment::TrackSegmentsList * tslist = fDetector->TrackSegments() ;
Int_t tsentries = 0 ;
public:
- AliPHOSIndexToObject(){ assert(0==1) ; } // should be never called
- virtual ~AliPHOSIndexToObject(){} ; // dtor
+ AliPHOSIndexToObject(){
+ // ctor: this is a singleton, the ctor should never be called but cint needs it as publiv
+ assert(0==1) ;
+ }
+ virtual ~AliPHOSIndexToObject(){
+ // dtor
+ }
static AliPHOSIndexToObject * GetInstance(AliPHOS * det) ;
static AliPHOSIndexToObject * GetInstance() ;
AliPHOS * fDetector ; // the detector
TTree * fReconstruct ; // the reconstruction tree
- static AliPHOSIndexToObject * fObjGetter ; // pointer to the unique instance of the singleton
+ static AliPHOSIndexToObject * fgObjGetter ; // pointer to the unique instance of the singleton
ClassDef(AliPHOSIndexToObject,1) // Algorithm class that provides methods to retrieve objects from a list knowing the index
public:
AliPHOSLink( Float_t r, Int_t EMC, Int_t PPSD) ; // ctor
- virtual ~AliPHOSLink(){} // dtor
-
+ virtual ~AliPHOSLink(){
+ // dtor
+ }
Int_t Compare(TObject * obj) ;
- Int_t GetEmc(void) { return fEmcN; }
- Int_t GetPpsd(void) { return fPpsdN ; }
- Float_t GetR(void) { return fR ; }
- Bool_t IsSortable() const{ return kTRUE ; }
+ Int_t GetEmc(void) {
+ // returns the index of EMC
+ return fEmcN;
+ }
+ Int_t GetPpsd(void) {
+ // returns the index of PPSD
+ return fPpsdN ;
+ }
+ Float_t GetR(void) {
+ // returns the distance between EMC and PPSD
+ return fR ;
+ }
+ Bool_t IsSortable() const{
+ // tells if this is a sortable object
+ return kTRUE ;
+ }
private:
AliPHOSPID() ; // ctor
virtual ~AliPHOSPID() ; // dtor
- virtual void MakeParticles(TrackSegmentsList * trsl, RecParticlesList * rpl) {} ;
+ virtual void MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl,
+ AliPHOSRecParticle::RecParticlesList * rpl) {} ;
virtual void SetShowerProfileCuts(Float_t, Float_t, Float_t, Float_t) {} ;
virtual void SetDispersionCutOff(Float_t ) {}
ClassImp( AliPHOSPIDv1)
//____________________________________________________________________________
-void AliPHOSPIDv1::MakeParticles(TrackSegmentsList * trsl, RecParticlesList * rpl)
+void AliPHOSPIDv1::MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl,
+ AliPHOSRecParticle::RecParticlesList * rpl)
{
// Makes a RecParticle out of a TrackSegment
AliPHOSPIDv1(): fCutOnDispersion(1.5){}
virtual ~ AliPHOSPIDv1(){} ; // dtor
- virtual void MakeParticles(TrackSegmentsList * trsl, RecParticlesList * rpl ) ; // does the job
+ virtual void MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl,
+ AliPHOSRecParticle::RecParticlesList * rpl ) ; // does the job
void Print() ;
virtual void SetDispersionCutOff(Float_t Dcut) {fCutOnDispersion = Dcut ; }
virtual void SetShowerProfileCuts(Float_t l1m, Float_t l1M, Float_t l2m, Float_t l2M) ;
public:
AliPHOSPpsdRecPoint() ; // ctor
- virtual ~AliPHOSPpsdRecPoint(){} // dtor
-
+ virtual ~AliPHOSPpsdRecPoint(){
+ // dtor
+ }
virtual void AddDigit(AliPHOSDigit & digit, Float_t Energy) ;
Int_t Compare(TObject * obj) ; // method to sort clusters
- Float_t GetDelta(void) {return fDelta ;}
- Int_t GetMultiplicity(void) const { return fMulDigit ; }
- Int_t GetMaximumMultiplicity() { return fMaxDigit ; }
+ Float_t GetDelta(void) {
+ // returns the parameter used for sorting
+ return fDelta ;
+ }
+ Int_t GetMultiplicity(void) const {
+ // returns the multiplicity of digits at the origin of this recpoint
+ return fMulDigit ;
+ }
+ Int_t GetMaximumMultiplicity() {
+ // returns the maximum allowed digit multiplicity
+ return fMaxDigit ;
+ }
void GetLocalPosition(TVector3 &LPos) ; // computes the position in the module of the cluster center
- Float_t GetTotalEnergy(void) const { return fAmp ; } // in Ppsd EMC RecPoint Amp = Energy
+ Float_t GetTotalEnergy(void) const {
+ // returns the amplitude for this recpoint
+ // in Ppsd EMC RecPoint Amp = Energy
+ return fAmp ;
+ }
Bool_t GetUp() ; // true if cluster is in upper ppsd
- Bool_t IsEmc(void) {return kFALSE ; }
- Bool_t IsSortable() const { return kTRUE ; }
+ Bool_t IsEmc(void) {
+ // tells that this is not a EMC
+ return kFALSE ;
+ }
+ Bool_t IsSortable() const {
+ // tells that this is a sortable object
+ return kTRUE ;
+ }
virtual void Paint(Option_t * option="");
void Print(Option_t * opt = "void") ;
#include "AliPHOSTrackSegment.h"
#include "AliPHOSFastRecParticle.h"
-typedef TClonesArray RecParticlesList ;
-
class AliPHOSRecParticle : public AliPHOSFastRecParticle {
public:
- AliPHOSRecParticle() {}; // ctor
+ AliPHOSRecParticle() {
+ // ctor
+ }
AliPHOSRecParticle(AliPHOSTrackSegment * ts) ; // ctor
AliPHOSRecParticle(const AliPHOSRecParticle & rp) ; // ctor
- virtual ~AliPHOSRecParticle(){} ; // dtor
-
+ virtual ~AliPHOSRecParticle(){
+ // dtor
+ }
AliPHOSTrackSegment * GetPHOSTrackSegment() const ;
Int_t GetPHOSTrackSegmentIndex(){return fPHOSTrackSegment;}
Int_t * GetPrimaries(Int_t & number) ;
Int_t fPHOSTrackSegment ; // pointer to the associated track segment in PHOS
+ typedef TClonesArray RecParticlesList ;
+
+
ClassDef(AliPHOSRecParticle,1) // Reconstructed Particle
};
Int_t iDigit;
Int_t relid[4] ;
- const Int_t fMulDigit=AliPHOSRecPoint::GetDigitsMultiplicity() ;
- Float_t * xi = new Float_t [fMulDigit] ;
- Float_t * zi = new Float_t [fMulDigit] ;
+ const Int_t kMulDigit=AliPHOSRecPoint::GetDigitsMultiplicity() ;
+ Float_t * xi = new Float_t [kMulDigit] ;
+ Float_t * zi = new Float_t [kMulDigit] ;
- for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+ for(iDigit = 0; iDigit < kMulDigit; iDigit++) {
digit = (AliPHOSDigit *) fDigitsList[iDigit];
phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
phosgeom->RelPosInModule(relid, xi[iDigit], zi[iDigit]) ;
#include "AliRecPoint.h"
#include "AliPHOSDigit.h"
-typedef TObjArray RecPointsList ;
-
class AliPHOSRecPoint : public AliRecPoint {
-public:
+ public:
AliPHOSRecPoint() ; // ctor
- virtual ~AliPHOSRecPoint(){} // dtor
+ virtual ~AliPHOSRecPoint(){
+ // dtor
+ }
virtual void AddDigit(AliPHOSDigit & digit, Float_t Energy) = 0 ;
- virtual Int_t Compare(TObject * obj) { assert(0==1) ; return 1 ; }
+ virtual Int_t Compare(TObject * obj) {
+ // check why this is done
+ assert(0==1) ; return 1 ;
+ }
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
virtual void Draw(Option_t * option="") ;
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ;
virtual Int_t GetPHOSMod(void) ;
virtual Int_t * GetPrimaries(Int_t & number) ;
- virtual Bool_t IsEmc(void){return kTRUE ;}
- virtual Bool_t IsSortable() const { return kTRUE ; }
+ virtual Bool_t IsEmc(void){
+ // says that this is a EMC
+ return kTRUE ;
+ }
+ virtual Bool_t IsSortable() const {
+ // tells that this is a sortable object
+ return kTRUE ;
+ }
virtual void Paint(Option_t * option="");
- virtual void Print(Option_t * opt = "void") {}
+ virtual void Print(Option_t * opt = "void") {
+ // Print prototype
+ }
-protected:
+ protected:
Int_t fPHOSMod ; // PHOS Module number in which the RecPoint is found
+ private:
+
+ typedef TObjArray RecPointsList ;
+
ClassDef(AliPHOSRecPoint,1) // RecPoint for PHOS (Base Class)
};
}
//____________________________________________________________________________
- void AliPHOSReconstructioner::Make(DigitsList * dl, RecPointsList * emccl, RecPointsList * ppsdl,
- TrackSegmentsList * trsl, RecParticlesList * rpl)
+ void AliPHOSReconstructioner::Make(DigitsList * dl,
+ AliPHOSRecPoint::RecPointsList * emccl,
+ AliPHOSRecPoint::RecPointsList * ppsdl,
+ AliPHOSTrackSegment::TrackSegmentsList * trsl,
+ AliPHOSRecParticle::RecParticlesList * rpl)
{
// Launches the Reconstruction process in the sequence: Make the reconstructed poins (clusterize)
// Make the track segments
primaries = (rp->GetPHOSTrackSegment())->GetPrimariesEmc(nprimaries);
switch(rp->GetType())
{
- case kNEUTRAL_EM:
+ case kNEUTRALEM:
strcpy( particle, "NEUTRAL_EM");
break;
- case kNEUTRAL_HA:
+ case kNEUTRALHA:
strcpy(particle, "NEUTRAL_HA");
break;
case kGAMMA:
strcpy(particle, "GAMMA");
break ;
- case kGAMMA_HA:
+ case kGAMMAHA:
strcpy(particle, "GAMMA_H");
break ;
- case kABSURD_EM:
+ case kABSURDEM:
strcpy(particle, "ABSURD_EM") ;
break ;
- case kABSURD_HA:
+ case kABSURDHA:
strcpy(particle, "ABSURD_HA") ;
break ;
case kELECTRON:
strcpy(particle, "ELECTRON") ;
break ;
- case kCHARGED_HA:
+ case kCHARGEDHA:
strcpy(particle, "CHARGED_HA") ;
break ;
}
AliPHOSClusterizer * GetClusterizer() { return fClusterizer ; }
void Init(AliPHOSClusterizer * Clusterizer, AliPHOSTrackSegmentMaker * Tracker,
AliPHOSPID * Identifier) ;
- void Make(TClonesArray * DL, RecPointsList * emccl, RecPointsList * ppsdl,
- TrackSegmentsList * trsl, RecParticlesList * rpl) ; // does the job
+ void Make(TClonesArray * DL,
+ AliPHOSRecPoint::RecPointsList * emccl,
+ AliPHOSRecPoint::RecPointsList * ppsdl,
+ AliPHOSTrackSegment::TrackSegmentsList * trsl,
+ AliPHOSRecParticle::RecParticlesList * rpl) ; // does the job
void SetDebugReconstruction(Bool_t deb) { fDebugReconstruction = deb; }
ClassImp(AliPHOSTrackSegment)
//____________________________________________________________________________
-AliPHOSTrackSegment::AliPHOSTrackSegment( AliPHOSEmcRecPoint * emc , AliPHOSPpsdRecPoint * ppsdrp1,
- AliPHOSPpsdRecPoint * ppsdrp2 )
+AliPHOSTrackSegment::AliPHOSTrackSegment( AliPHOSEmcRecPoint * emc ,
+ AliPHOSPpsdRecPoint * ppsdrp1,
+ AliPHOSPpsdRecPoint * ppsdrp2 )
{
// ctor
//____________________________________________________________________________
AliPHOSEmcRecPoint * AliPHOSTrackSegment::GetEmcRecPoint() const
{
+ // get the EMC recpoint at the origin of this track
+
AliPHOSIndexToObject * please = AliPHOSIndexToObject::GetInstance() ;
AliPHOSEmcRecPoint * rv = 0 ;
if ( fEmcRecPoint > -1 )
//____________________________________________________________________________
Int_t AliPHOSTrackSegment:: GetPHOSMod(void)
{
-
+ // Returns the phos module which contains this track
+
AliPHOSEmcRecPoint * emcrp = GetEmcRecPoint() ;
return emcrp->GetPHOSMod();
//____________________________________________________________________________
AliPHOSPpsdRecPoint * AliPHOSTrackSegment::GetPpsdLowRecPoint() const
{
+ // Returns the lower PPSD rec point at the origin of this track
+
AliPHOSIndexToObject * please = AliPHOSIndexToObject::GetInstance() ;
AliPHOSPpsdRecPoint * rv = 0 ;
-
+
if ( fPpsdLowRecPoint > -1 )
rv = (AliPHOSPpsdRecPoint *)please->GimeRecPoint( fPpsdLowRecPoint, TString("ppsd") ) ;
//____________________________________________________________________________
AliPHOSPpsdRecPoint * AliPHOSTrackSegment::GetPpsdUpRecPoint() const
{
+ // Returns the lower PPSD rec point at the origin of this track
+
AliPHOSIndexToObject * please = AliPHOSIndexToObject::GetInstance() ;
AliPHOSPpsdRecPoint * rv = 0 ;
#include "AliPHOSEmcRecPoint.h"
#include "AliPHOSPpsdRecPoint.h"
-typedef TClonesArray TrackSegmentsList ;
-
class AliPHOSTrackSegment : public TObject {
public:
- AliPHOSTrackSegment() {} // ctor
- AliPHOSTrackSegment(AliPHOSEmcRecPoint * EmcRecPoint , AliPHOSPpsdRecPoint * PpsdUp,
+ AliPHOSTrackSegment() {
+ // default ctor
+ }
+ AliPHOSTrackSegment(AliPHOSEmcRecPoint * EmcRecPoint ,
+ AliPHOSPpsdRecPoint * PpsdUp,
AliPHOSPpsdRecPoint * PpsdLow ) ; // ctor
AliPHOSTrackSegment(const AliPHOSTrackSegment & ts) ; // ctor
- virtual ~AliPHOSTrackSegment() {} // dtor
+ virtual ~AliPHOSTrackSegment() {
+ // dtor
+ }
void Copy(TObject & obj) ;
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
Int_t * GetPrimariesPpsdLow(Int_t & number) ;
Int_t * GetPrimariesPpsdUp(Int_t & number) ;
AliPHOSEmcRecPoint * GetEmcRecPoint() const ;
- Int_t GetEmcRecPointIndex() {return fEmcRecPoint; }
- Int_t GetIndexInList() const { return fIndexInList ; }
+ Int_t GetIndexInList() const {
+ // returns the index of this in the list
+ return fIndexInList ;
+ }
+ Int_t GetEmcRecPointIndex() {
+ // return the index of the EMC recpoint at the origine of this
+ return fEmcRecPoint ;
+ }
AliPHOSPpsdRecPoint * GetPpsdLowRecPoint() const ;
- Int_t GetPpsdLowRecPointIndex() {return fPpsdLowRecPoint ; }
+ Int_t GetPpsdLowRecPointIndex() {
+ // returns the PPSD low recpoint at the origin of this
+ return fPpsdLowRecPoint ;
+ }
AliPHOSPpsdRecPoint * GetPpsdUpRecPoint() const ;
- Int_t GetPpsdUpRecPointIndex() {return fPpsdUpRecPoint ; }
+ Int_t GetPpsdUpRecPointIndex() {
+ // returns the PPSD up recpoint at the origin of this
+ return fPpsdUpRecPoint ;
+ }
virtual void Paint(Option_t * option="");
void Print() ;
- void SetIndexInList(Int_t val) { fIndexInList = val ; }
+ void SetIndexInList(Int_t val) {
+ // sets the index value of this in the list
+ fIndexInList = val ;
+ }
-
-private:
+ private:
Int_t fEmcRecPoint ; // The EMC reconstructed point index in array stored in TreeR/PHOSEmcRP
Int_t fIndexInList ; // the index of this TrackSegment in the list stored in TreeR (to be set by analysis)
Int_t fPpsdLowRecPoint ; // The PPSD reconstructed point from the lower layer index in array stored in TreeR/PHOSPpsdRP
Int_t fPpsdUpRecPoint ; // The PPSD reconstructed point from the upper layer index in array stored in TreeR/PHOSPpsdRP
+ typedef TClonesArray TrackSegmentsList ;
+
ClassDef(AliPHOSTrackSegment,1) // Track segment in PHOS
};
virtual ~ AliPHOSTrackSegmentMaker(){} // dtor
- virtual void MakeTrackSegments(DigitsList * DL, RecPointsList * emcl, RecPointsList * ppsdl, TrackSegmentsList * trsl ) = 0 ;
- // does the job
+ virtual void MakeTrackSegments(DigitsList * DL,
+ AliPHOSRecPoint::RecPointsList * emcl,
+ AliPHOSRecPoint::RecPointsList * ppsdl,
+ AliPHOSTrackSegment::TrackSegmentsList * trsl ) = 0 ; // does the job
virtual void SetMaxEmcPpsdDistance(Float_t r) = 0 ;
virtual void SetUnfoldFlag() = 0 ;
virtual void UnsetUnfoldFlag() = 0 ;
}
//____________________________________________________________________________
-void AliPHOSTrackSegmentMakerv1::FillOneModule(DigitsList * dl, RecPointsList * emcIn, TObjArray * emcOut,
- RecPointsList * ppsdIn, TObjArray * ppsdOutUp,
- TObjArray * ppsdOutLow, Int_t & phosmod, Int_t & emcStopedAt,
- Int_t & ppsdStopedAt)
+void AliPHOSTrackSegmentMakerv1::FillOneModule(DigitsList * dl,
+ AliPHOSRecPoint::RecPointsList * emcIn,
+ TObjArray * emcOut,
+ AliPHOSRecPoint::RecPointsList * ppsdIn,
+ TObjArray * ppsdOutUp,
+ TObjArray * ppsdOutLow,
+ Int_t & phosmod,
+ Int_t & emcStopedAt,
+ Int_t & ppsdStopedAt)
{
// Unfold clusters and fill xxxOut arrays with clusters from one PHOS module
}
//____________________________________________________________________________
-void AliPHOSTrackSegmentMakerv1::MakePairs(TObjArray * emcRecPoints, TObjArray * ppsdRecPointsUp,
- TObjArray * ppsdRecPointsLow, TClonesArray * linklowArray,
- TClonesArray * linkupArray, TrackSegmentsList * trsl)
+void AliPHOSTrackSegmentMakerv1::MakePairs(TObjArray * emcRecPoints,
+ TObjArray * ppsdRecPointsUp,
+ TObjArray * ppsdRecPointsLow,
+ TClonesArray * linklowArray,
+ TClonesArray * linkupArray,
+ AliPHOSTrackSegment::TrackSegmentsList * trsl)
{
// Finds the smallest links and makes pairs of PPSD and EMC clusters with smallest distance
}
//____________________________________________________________________________
-void AliPHOSTrackSegmentMakerv1::MakeTrackSegments(DigitsList * dl, RecPointsList * emcl,
- RecPointsList * ppsdl, TrackSegmentsList * trsl)
+void AliPHOSTrackSegmentMakerv1::MakeTrackSegments(DigitsList * dl,
+ AliPHOSRecPoint::RecPointsList * emcl,
+ AliPHOSRecPoint::RecPointsList * ppsdl,
+ AliPHOSTrackSegment::TrackSegmentsList * trsl)
{
// Makes the track segments out of the list of EMC and PPSD Recpoints and stores them in a list
}
//____________________________________________________________________________
-void AliPHOSTrackSegmentMakerv1::UnfoldClusters(DigitsList * dl, RecPointsList * emcIn, AliPHOSEmcRecPoint * iniEmc,
- Int_t nMax, int * maxAt, Float_t * maxAtEnergy, TObjArray * emcList)
+void AliPHOSTrackSegmentMakerv1::UnfoldClusters(DigitsList * dl,
+ AliPHOSRecPoint::RecPointsList * emcIn,
+ AliPHOSEmcRecPoint * iniEmc,
+ Int_t nMax,
+ int * maxAt,
+ Float_t * maxAtEnergy,
+ TObjArray * emcList)
{
// Performs the unfolding of a cluster with nMax overlapping showers
// This is time consuming (use the (Un)SetUnfolFlag() )
Bool_t FindFit(AliPHOSEmcRecPoint * emcRP, int * MaxAt, Float_t * maxAtEnergy,
Int_t NPar, Float_t * FitParametres) ; //Used in UnfoldClusters, calls TMinuit
- void FillOneModule(DigitsList * Dl, RecPointsList * emcIn, TObjArray * emcOut, RecPointsList * ppsdIn,
- TObjArray * ppsdOutUp, TObjArray * ppsdOutLow, Int_t &PHOSModule, Int_t & emcStopedAt,
+ void FillOneModule(DigitsList * Dl, AliPHOSRecPoint::RecPointsList * emcIn,
+ TObjArray * emcOut,
+ AliPHOSRecPoint::RecPointsList * ppsdIn,
+ TObjArray * ppsdOutUp,
+ TObjArray * ppsdOutLow,
+ Int_t &PHOSModule,
+ Int_t & emcStopedAt,
Int_t & ppsdStopedAt) ; // Unfolds clusters and fills temporary arrais
Float_t GetDistanceInPHOSPlane(AliPHOSEmcRecPoint * EmcClu , AliPHOSPpsdRecPoint * Ppsd , Bool_t & TooFar ) ; // see R0
void MakeLinks(TObjArray * EmcRecPoints, TObjArray * PpsdRecPointsUp, TObjArray * PpsdRecPointsLow,
TClonesArray * LinkLowArray, TClonesArray *LinkUpArray) ; //Evaluates distances(links) between EMC and PPSD
- void MakePairs(TObjArray * EmcRecPoints, TObjArray * PpsdRecPointsUp, TObjArray * PpsdRecPointsLow,
- TClonesArray * LinkLowArray, TClonesArray * LinkUpArray, TrackSegmentsList * trsl) ;
- //Finds pairs(triplets) with smallest link
- void MakeTrackSegments(DigitsList * DL, RecPointsList * emcl, RecPointsList * ppsdl, TrackSegmentsList * trsl ) ; // does the job
+ void MakePairs(TObjArray * EmcRecPoints,
+ TObjArray * PpsdRecPointsUp,
+ TObjArray * PpsdRecPointsLow,
+ TClonesArray * LinkLowArray,
+ TClonesArray * LinkUpArray,
+ AliPHOSTrackSegment::TrackSegmentsList * trsl) ; //Finds pairs(triplets) with smallest link
+ void MakeTrackSegments(DigitsList * DL,
+ AliPHOSRecPoint::RecPointsList * emcl,
+ AliPHOSRecPoint::RecPointsList * ppsdl,
+ AliPHOSTrackSegment::TrackSegmentsList * trsl ) ; // does the job
virtual void SetMaxEmcPpsdDistance(Float_t r){ fR0 = r ;}
virtual void SetUnfoldFlag() { fUnfoldFlag = kTRUE ; } ;
static Double_t ShowerShape(Double_t r) ; // Shape of shower used in unfolding; class member function (not object member function)
- void UnfoldClusters(DigitsList * DL, RecPointsList * emcIn, AliPHOSEmcRecPoint * iniEmc, Int_t Nmax,
- int * maxAt, Float_t * maxAtEnergy, TObjArray * emclist) ; //Unfolds overlaping clusters using TMinuit package
+ void UnfoldClusters(DigitsList * DL,
+ AliPHOSRecPoint::RecPointsList * emcIn,
+ AliPHOSEmcRecPoint * iniEmc,
+ Int_t Nmax,
+ int * maxAt,
+ Float_t * maxAtEnergy,
+ TObjArray * emclist) ; //Unfolds overlaping clusters using TMinuit package
virtual void UnsetUnfoldFlag() { fUnfoldFlag = kFALSE ; }
private:
}
//____________________________________________________________________________
-RecPointsList * AliPHOSv0::PpsdRecPoints(Int_t evt)
+AliPHOSRecPoint::RecPointsList * AliPHOSv0::PpsdRecPoints(Int_t evt)
{
// returns the pointer to the PPSD RecPoints list
// if the list is empty, get it from TreeR on the disk file
- RecPointsList * rv = 0 ;
+ AliPHOSRecPoint::RecPointsList * rv = 0 ;
if ( fPpsdRecPoints )
rv = fPpsdRecPoints ;
fEmcRecPoints = 0 ;
}
- // fEmcRecPoints= new RecPointsList("AliPHOSEmcRecPoint", 1000) ; if TClonesArray
- fEmcRecPoints= new RecPointsList(100) ;
+ // fEmcRecPoints= new AliPHOSRecPoint::RecPointsList("AliPHOSEmcRecPoint", 1000) ; if TClonesArray
+ fEmcRecPoints= new AliPHOSRecPoint::RecPointsList(100) ;
if ( fEmcRecPoints && gAlice->TreeR() ) {
sprintf(branchname,"%sEmcRP",GetName()) ;
fPpsdRecPoints = 0 ;
}
- // fPpsdRecPoints = new RecPointsList("AliPHOSPpsdRecPoint", 1000) ; if TClonesArray
- fPpsdRecPoints = new RecPointsList(100) ;
+ // fPpsdRecPoints = new AliPHOSRecPoint::RecPointsList("AliPHOSPpsdRecPoint", 1000) ; if TClonesArray
+ fPpsdRecPoints = new AliPHOSRecPoint::RecPointsList(100) ;
if ( fPpsdRecPoints && gAlice->TreeR() ) {
sprintf(branchname,"%sPpsdRP",GetName()) ;
fTrackSegments = 0 ;
}
- fTrackSegments = new TrackSegmentsList("AliPHOSTrackSegment", 1000) ;
+ fTrackSegments = new AliPHOSTrackSegment::TrackSegmentsList("AliPHOSTrackSegment", 1000) ;
if ( fTrackSegments && gAlice->TreeR() ) {
sprintf(branchname,"%sTS",GetName()) ;
gAlice->TreeR()->Branch(branchname, &fTrackSegments, fBufferSize) ;
delete fRecParticles ;
fRecParticles = 0 ;
}
- fRecParticles = new RecParticlesList("AliPHOSRecParticle", 1000) ;
+ fRecParticles = new AliPHOSRecParticle::RecParticlesList("AliPHOSRecParticle", 1000) ;
if ( fRecParticles && gAlice->TreeR() ) {
sprintf(branchname,"%sRP",GetName()) ;
gAlice->TreeR()->Branch(branchname, &fRecParticles, fBufferSize) ;
virtual void Init(void) ; // does nothing
Int_t IsVersion(void) const { return 0 ; }
void MakeBranch(Option_t* opt) ;
- virtual RecPointsList* PpsdRecPoints(Int_t evt=0) ; // gets Array of clusters in the PPSD
+ virtual AliPHOSRecPoint::RecPointsList* PpsdRecPoints(Int_t evt=0) ; // gets Array of clusters in the PPSD
void Reconstruction(AliPHOSReconstructioner * Reconstructioner) ;
void ResetClusters(){} ;
virtual void ResetDigits() ;
//____________________________________________________________________________
AliPHOSv0hits::AliPHOSv0hits()
{
- // ctor
+ // default ctor
fNTmpHits = 0 ;
fTmpHits = 0 ;
}
AliPHOSv0hits::AliPHOSv0hits(const char *name, const char *title):
AliPHOSv0(name,title)
{
+ // ctor
fHits= new TClonesArray("AliPHOSHit",1000) ;
}
SetBigBox(2, fGeom->GetOuterBoxSize(0) );
fNRecParticles = 0 ;
- fFastRecParticles = new FastRecParticlesList("AliPHOSFastRecParticle", 100) ;
+ fFastRecParticles = new AliPHOSFastRecParticle::FastRecParticlesList("AliPHOSFastRecParticle", 100) ;
fResPara1 = 0.030 ; // GeV
fResPara2 = 0.00003 ;
else {
ran = fRan.Rndm() ;
if( ran <= 0.9498 )
- rv = kNEUTRAL_EM ;
+ rv = kNEUTRALEM ;
else
- rv = kNEUTRAL_HA ;
+ rv = kNEUTRALHA ;
}
break ;
case 2112: // it's a neutron
ran = fRan.Rndm() ;
if ( ran <= 0.9998 )
- rv = kNEUTRAL_HA ;
+ rv = kNEUTRALHA ;
else
- rv = kNEUTRAL_EM ;
+ rv = kNEUTRALEM ;
break ;
case -2112: // it's a anti-neutron
ran = fRan.Rndm() ;
if ( ran <= 0.9984 )
- rv = kNEUTRAL_HA ;
+ rv = kNEUTRALHA ;
else
- rv = kNEUTRAL_EM ;
+ rv = kNEUTRALEM ;
break ;
case 11: // it's a electron
if ( ran <= 0.9996 )
rv = kELECTRON ;
else
- rv = kCHARGED_HA ;
+ rv = kCHARGEDHA ;
break;
case -11: // it's a positon
if ( ran <= 0.9996 )
rv = kELECTRON ;
else
- rv = kCHARGED_HA ;
+ rv = kCHARGEDHA ;
break;
case -1: // it's a charged
ran = fRan.Rndm() ;
if ( ran <= 0.9996 )
- rv = kCHARGED_HA ;
+ rv = kCHARGEDHA ;
else
rv = kGAMMA ;
// makes the detected position
void MakeRecParticle(const Int_t modid, const TVector3 pos, AliPHOSFastRecParticle & rp) ; // makes a reconstructes particle from primary
Int_t MakeType(AliPHOSFastRecParticle & rp) ; // gets the detected type of particle
- FastRecParticlesList * FastRecParticles() { return fFastRecParticles ; } // gets TClonesArray of reconstructed particles
+ // gets TClonesArray of reconstructed particles
+ AliPHOSFastRecParticle::FastRecParticlesList * FastRecParticles() { return fFastRecParticles ; }
virtual void ResetPoints() ;
void ResetFastRecParticles() ;
void SetBigBox(Int_t index, Float_t value) ;
Float_t fBigBoxX ; // main box containing all PHOS (EMC+PPSD)
Float_t fBigBoxY ; // main box containing all PHOS (EMC+PPSD)
Float_t fBigBoxZ ; // main box containing all PHOS (EMC+PPSD)
- FastRecParticlesList * fFastRecParticles ; // list of particles modified by the response function
+ AliPHOSFastRecParticle::FastRecParticlesList * fFastRecParticles ; // list of particles modified by the response function
AliPHOSGeometry * fGeom ; // geometry definition
Int_t fNRecParticles ; // number of detected particles
TRandom fRan ; // random number generator
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff