fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
if (relid[0] == module)
{
+
+Int_t nprim = digit->GetNprimary() ;
+ cout << " digit nprim = " << nprim << endl ;
+Int_t ii ;
+Int_t * aprim = digit->GetPrimary() ;
+for ( ii = 0 ; ii < nprim ; ii++)
+ cout << ii << " prim = " << aprim[ii] << endl ;
+
nDigits++ ;
energy = fClu->Calibrate(digit->GetAmp()) ;
etot += energy ;
AliPHOSEmcRecPoint * emc ;
while((emc = (AliPHOSEmcRecPoint *)nextemc()))
{
+
+ Int_t numberofprimaries ;
+ Int_t * primariesarray = new Int_t[10] ;
+ emc->GetPrimaries(numberofprimaries, primariesarray) ;
+ // cout << " HELLO " << numberofprimaries << endl ;
+ // Int_t index ;
+ //for ( index = 0 ; index < numberofprimaries ; index++)
+ // cout << index << " " << primariesarray[index] << endl;
+
totalnClusters++ ;
if ( emc->GetPHOSMod() == module )
{
AliPHOSDigit * digit ;
while ( (digit = (AliPHOSDigit *)next()) ) {
-
+
+// cout << " clusterizerv1 " << endl ;
+// int nprim = digit->GetNprimary() ;
+// int * aprim = digit->GetPrimary() ;
+// for ( int ii = 0 ; ii < nprim ; ii++)
+// cout << ii << " prim = " << aprim[ii] << endl ;
+
Int_t id = digit->GetId() ;
Float_t ene = Calibrate(digit->GetAmp()) ;
geom->AbsToRelNumbering(id, relid) ;
// --- Standard library ---
#include <iostream>
+#include <cassert>
// --- AliRoot header files ---
ClassImp(AliPHOSDigit)
+//____________________________________________________________________________
+ AliPHOSDigit::AliPHOSDigit() : fPrimary(0)
+{
+}
+
//____________________________________________________________________________
AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Int_t DigEnergy)
{
- fId = id;
- fAmp = DigEnergy ;
- fPrimary = new Int_t[1] ;
+ fId = id ;
+ fAmp = DigEnergy ;
+ fPrimary = new Int_t[1] ;
fPrimary[0] = primary ;
- fNprimary = 1 ;
+ fNprimary = 1 ;
+}
+
+//____________________________________________________________________________
+AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit)
+{
+ fId = digit.fId;
+ fAmp = digit.fAmp ;
+ fNprimary = digit.GetNprimary() ;
+ fPrimary = new Int_t[fNprimary] ;
+ Int_t * primary = digit.GetPrimary() ;
+ Int_t index ;
+ for ( index = 0 ; index < fNprimary ; index++ )
+ fPrimary[index] = primary[index] ;
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-Bool_t AliPHOSDigit::operator==(AliPHOSDigit const &Digit) const
+Int_t AliPHOSDigit::Compare(TObject * obj)
{
- if ( fId == Digit.fId )
+ Int_t rv ;
+
+ AliPHOSDigit * digit = (AliPHOSDigit *)obj ;
+
+ Int_t iddiff = fId - digit->GetId() ;
+
+ if ( iddiff > 0 )
+ rv = 1 ;
+ else if ( iddiff < 0 )
+ rv = -1 ;
+ else
+ rv = 0 ;
+
+ return rv ;
+
+}
+//____________________________________________________________________________
+Bool_t AliPHOSDigit::operator==(AliPHOSDigit const & digit) const
+{
+ if ( fId == digit.fId )
return kTRUE ;
else
return kFALSE ;
}
-
+
//____________________________________________________________________________
-AliPHOSDigit& AliPHOSDigit::operator+(AliPHOSDigit const &Digit)
+AliPHOSDigit& AliPHOSDigit::operator+(AliPHOSDigit const & digit)
{
- fAmp += Digit.fAmp ;
+ fAmp += digit.fAmp ;
Int_t * tempo = new Int_t[fNprimary] ;
Int_t index ;
Int_t oldfNprimary = fNprimary ;
for ( index = 0 ; index < oldfNprimary ; index++ ){
- cout << " 1 " << index << endl ;
tempo[index] = fPrimary[index] ;
}
delete fPrimary ;
- fNprimary += Digit.GetNprimary() ;
+ fNprimary += digit.GetNprimary() ;
fPrimary = new Int_t[fNprimary] ;
for ( index = 0 ; index < oldfNprimary ; index++ ) {
- cout << " 2 " << index << endl ;
fPrimary[index] = tempo[index] ;
}
Int_t jndex = 0 ;
for ( index = oldfNprimary ; index < fNprimary ; index++ ) {
- cout << " 1 " << index << " " << jndex << endl ;
- fPrimary[index] = Digit.fPrimary[jndex] ;
+ fPrimary[index] = digit.fPrimary[jndex] ;
jndex++ ;
}
}
//____________________________________________________________________________
-ostream& operator << ( ostream& out , const AliPHOSDigit& Digit)
+ostream& operator << ( ostream& out , const AliPHOSDigit & digit)
{
- out << "ID " << Digit.fId << " Energy = " << Digit.fAmp ;
+ out << "ID " << digit.fId << " Energy = " << digit.fAmp ;
return out ;
}
-//____________________________________________________________________________
-Int_t AliPHOSDigit::Compare(TObject * obj)
+//______________________________________________________________________________
+void AliPHOSDigit::Streamer(TBuffer &R__b)
{
- Int_t rv ;
-
- AliPHOSDigit * digit = (AliPHOSDigit *)obj ;
-
- Int_t iddiff = fId - digit->GetId() ;
-
- if ( iddiff > 0 )
- rv = 1 ;
- else if ( iddiff < 0 )
- rv = -1 ;
- else
- rv = 0 ;
-
- return rv ;
-
+ assert(0==1) ;
+ // Stream an object of class AliPHOSDigit.
+ if (R__b.IsReading()) {
+ Version_t R__v = R__b.ReadVersion(); if (R__v) { }
+ AliDigitNew::Streamer(R__b);
+ R__b.ReadArray(fPrimary);
+ R__b >> fNprimary;
+ } else {
+ R__b.WriteVersion(AliPHOSDigit::IsA());
+ AliDigitNew::Streamer(R__b);
+ R__b.WriteArray(fPrimary, fNprimary);
+ R__b << fNprimary;
+
+ }
}
+
+
public:
- AliPHOSDigit() {}
+ AliPHOSDigit() ;
AliPHOSDigit(Int_t primary, Int_t id, Int_t DigEnergy) ;
+ AliPHOSDigit(const AliPHOSDigit & digit) ;
virtual ~AliPHOSDigit() ;
Bool_t operator==(AliPHOSDigit const &rValue) const;
friend ostream& operator << ( ostream& , const AliPHOSDigit&) ;
Int_t Compare(TObject * obj) ;
- Int_t GetAmp() const { return fAmp ; }
- Int_t GetId() const { return fId ; }
Int_t GetNprimary() const { return fNprimary ; }
Int_t * GetPrimary() const { return fPrimary ; }
Bool_t IsSortable() const { return kTRUE ; }
void SetAmp(Int_t Amp) { fAmp=Amp ; }
-
+
private:
- Int_t fId ; // absolute id
- Int_t fAmp ; // digitalized energy
Int_t * fPrimary ; // Array of primary particles which contribute to the digit
Int_t fNprimary ; // Number of primaries
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 ; }
- void Print(Option_t * opt = "void") ;
+ Bool_t IsSortable() const { return kTRUE ; }
+ void Print(Option_t * opt = "void") ;
private:
Float_t fDelta ; // parameter used to sort the clusters
Float_t fLocMaxCut ; // parameter used for local maximum searc
Float_t * fEnergyList ; // energy of digits
- Float_t fW0 ; // logarithmic weight factor for center of gravity calculation
+ Float_t fW0 ; // logarithmic weight factor for center of gravity calculation
ClassDef(AliPHOSEmcRecPoint,1) // EMC RecPoint, version 1
}
}
-
//____________________________________________________________________________
Int_t AliPHOSRecPoint::GetPHOSMod()
{
return fPHOSMod ;
}
+//______________________________________________________________________________
+void AliPHOSRecPoint::GetPrimaries(Int_t & number, Int_t * list)
+{
+ AliPHOSDigit * digit ;
+ Int_t index ;
+ Int_t maxcounter = 10 ;
+ Int_t counter = 0 ;
+ Int_t * tempo = new Int_t[maxcounter] ;
+
+ for ( index = 0 ; index < GetDigitsMultiplicity() ; index++ ) { // all digits
+ digit = (AliPHOSDigit *) fDigitsList[index] ;
+ Int_t * newprimaryarray = digit->GetPrimary() ;
+ Int_t nprimaries = digit->GetNprimary() ;
+ // cout << " nprimaries = " << nprimaries << endl ;
+ Int_t jndex ;
+ for ( jndex = 0 ; jndex < nprimaries ; jndex++ ) { // all primaries in digit
+ if ( counter >= maxcounter ) {
+ number = - 1 ;
+ cout << "AliPHOSRecPoint::GetNprimaries ERROR > increase maxcounter " << endl ;
+ break ;
+ }
+ Int_t newprimary = newprimaryarray[jndex] ;
+ // cout << "GetPrimaries " << newprimary << endl ;
+ Int_t kndex ;
+ Bool_t already = kFALSE ;
+ for ( kndex = 0 ; kndex < counter ; kndex++ ) { //check if not already stored
+ if ( newprimary == tempo[kndex] ){
+ already = kTRUE ;
+ break ;
+ }
+ } // end of check
+ if ( !already) { // store it
+ tempo[counter] = newprimary ;
+ counter++ ;
+ } // store it
+ } // all primaries in digit
+ } // all digits
+
+ counter-- ;
+ number = counter ;
+ for ( index = 0 ; index < number ; index ++ )
+ list[index] = tempo[index] ;
+
+}
+
//______________________________________________________________________________
void AliPHOSRecPoint::Paint(Option_t *)
{
AliPHOSRecPoint() ; // ctor
virtual ~AliPHOSRecPoint() ; // dtor
virtual void AddDigit(AliDigitNew & digit, Float_t Energy) = 0 ;
- 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 Bool_t IsEmc(void){return kTRUE ;}
- virtual void Paint(Option_t * option="");
- virtual void Print(Option_t * opt = "void") {}
+ 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 void GetPrimaries(Int_t & number, Int_t * list) ;
+ virtual Bool_t IsEmc(void){return kTRUE ;}
+ virtual void Paint(Option_t * option="");
+ virtual void Print(Option_t * opt = "void") {}
virtual Int_t Compare(TObject * obj) { assert(0==1) ; }
virtual Bool_t IsSortable() const { return kTRUE ; }
//___________________________________________________________________________
void AliPHOSv0::FinishEvent()
{
- // cout << "//_____________________________________________________" << endl ;
- // cout << "<I> AliPHOSv0::FinishEvent() -- Starting digitalization" << endl ;
+ cout << "//_____________________________________________________" << endl ;
+ cout << "<I> AliPHOSv0::FinishEvent() -- Starting digitalization" << endl ;
Int_t i ;
+ Int_t relid[4];
Int_t j ;
TClonesArray &lDigits = *fDigits ;
AliPHOSHit * hit ;
for ( i = 0 ; i < fNTmpHits ; i++ ) {
hit = (AliPHOSHit*)fTmpHits->At(i) ;
- cout << "FinishEvent hit" << hit->GetPrimary() << " " << hit->GetId() << endl ;
newdigit = new AliPHOSDigit( hit->GetPrimary(), hit->GetId(), Digitize( hit->GetEnergy() ) ) ;
for ( j = 0 ; j < fNdigits ; j++) {
- curdigit = (AliPHOSDigit*) lDigits[j] ;
+ curdigit = (AliPHOSDigit*) lDigits[j] ;
if ( *curdigit == *newdigit) {
- *curdigit = *newdigit + *curdigit ;
+ *curdigit = *curdigit + *newdigit ;
deja = kTRUE ;
}
}
delete newdigit ;
}
- for ( i = 0 ; i < fNdigits ; i++ ) {
- newdigit = (AliPHOSDigit*)lDigits[i] ;
- Int_t * prim = newdigit->GetPrimary() ;
- for ( j = 0 ; j < newdigit->GetNprimary() ; j++)
- cout << "FinishEvent digit " << prim[j] << " " << newdigit->GetId() << endl ;
- }
-
+ // Noise induced by the PIN diode of the PbWO crystals
Float_t energyandnoise ;
for ( i = 0 ; i < fNdigits ; i++ ) {
newdigit = (AliPHOSDigit * ) fDigits->At(i) ;
- energyandnoise = newdigit->GetAmp() + Digitize(gRandom->Gaus(0., fPINElectronicNoise)) ;
- if (energyandnoise < 0 ) energyandnoise = 0 ;
- newdigit->SetAmp(energyandnoise) ;
-
+
+// int nprim = newdigit->GetNprimary() ;
+// cout << " finishevent " << nprim << endl ;
+// int * prim = newdigit->GetPrimary() ;
+// for (int ii = 0 ; ii < nprim ; ii++)
+// cout << ii << " prim = " << prim[ii] << endl ;
+
+ fGeom->AbsToRelNumbering(newdigit->GetId(), relid) ;
+ if (relid[1]==0){ // Digits belong to EMC (PbW0_4 crystals)
+ energyandnoise = newdigit->GetAmp() + Digitize(gRandom->Gaus(0., fPINElectronicNoise)) ;
+ if (energyandnoise < 0 )
+ energyandnoise = 0 ;
+ newdigit->SetAmp(energyandnoise) ;
+ }
}