Added functionalities to have the list of primary particles attached to the digits...
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 14 Feb 2000 15:32:33 +0000 (15:32 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 14 Feb 2000 15:32:33 +0000 (15:32 +0000)
PHOS/AliPHOSAnalyze.cxx
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSDigit.cxx
PHOS/AliPHOSDigit.h
PHOS/AliPHOSEmcRecPoint.h
PHOS/AliPHOSRecPoint.cxx
PHOS/AliPHOSRecPoint.h
PHOS/AliPHOSv0.cxx

index 94abec4..a2e320f 100644 (file)
@@ -572,6 +572,14 @@ void AliPHOSAnalyze::DisplayRecPoints()
          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 ; 
@@ -594,6 +602,15 @@ void AliPHOSAnalyze::DisplayRecPoints()
       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 )
            { 
index e242a0c..ecd030f 100644 (file)
@@ -104,7 +104,13 @@ void AliPHOSClusterizerv1::FillandSort(const DigitsList * dl, TObjArray * tl)
   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) ;
index 56b9ae1..212c50e 100644 (file)
@@ -23,6 +23,7 @@
 // --- 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] ;
 }
 
 //____________________________________________________________________________
@@ -48,18 +67,37 @@ AliPHOSDigit::~AliPHOSDigit()
 }
 
 //____________________________________________________________________________
-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 ; 
@@ -67,23 +105,20 @@ AliPHOSDigit& AliPHOSDigit::operator+(AliPHOSDigit const &Digit)
   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++ ; 
   }
       
@@ -91,29 +126,30 @@ AliPHOSDigit& AliPHOSDigit::operator+(AliPHOSDigit const &Digit)
 }
 
 //____________________________________________________________________________
-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;
+
+   }
 }
+
+   
index 4dc32f3..9867142 100644 (file)
@@ -27,8 +27,9 @@ class AliPHOSDigit : public AliDigitNew {
   
 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;
@@ -37,17 +38,13 @@ public:
   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
   
index b7b0eac..d8a9a72 100644 (file)
@@ -50,8 +50,8 @@ public:
   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:
 
@@ -60,7 +60,7 @@ 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
 
index 8e28b4a..6fda027 100644 (file)
@@ -153,7 +153,6 @@ void AliPHOSRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
    }
 }
 
-
 //____________________________________________________________________________
 Int_t AliPHOSRecPoint::GetPHOSMod()
 { 
@@ -172,6 +171,51 @@ Int_t AliPHOSRecPoint::GetPHOSMod()
 }
 
 //______________________________________________________________________________
+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 *)
 {
 // Paint this ALiRecPoint as a TMarker  with its current attributes
index aac17b0..688d9e8 100644 (file)
@@ -34,13 +34,14 @@ public:
   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 ; }  
index 0c620d1..2a1212e 100644 (file)
@@ -1042,9 +1042,10 @@ Int_t AliPHOSv0::Digitize(Float_t Energy){
 //___________________________________________________________________________
 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 ;
@@ -1054,12 +1055,11 @@ void AliPHOSv0::FinishEvent()
 
   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 ; 
       }
     }
@@ -1071,20 +1071,24 @@ void AliPHOSv0::FinishEvent()
     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) ;
+    }
   }