Compare() changed to Compare() const
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Feb 2001 17:10:00 +0000 (17:10 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Feb 2001 17:10:00 +0000 (17:10 +0000)
22 files changed:
PHOS/AliPHOS.cxx
PHOS/AliPHOS.h
PHOS/AliPHOSAnalyze.cxx
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSCpvRecPoint.cxx
PHOS/AliPHOSCpvRecPoint.h
PHOS/AliPHOSEmcRecPoint.cxx
PHOS/AliPHOSEmcRecPoint.h
PHOS/AliPHOSIndexToObject.cxx
PHOS/AliPHOSPpsdRecPoint.cxx
PHOS/AliPHOSPpsdRecPoint.h
PHOS/AliPHOSRecPoint.cxx
PHOS/AliPHOSRecPoint.h
PHOS/AliPHOSReconstructioner.cxx
PHOS/AliPHOSTrackSegment.cxx
PHOS/AliPHOSTrackSegmentMakerv1.cxx
PHOS/AliPHOSTrackSegmentMakerv1.h
PHOS/AliPHOSv1.cxx
PHOS/AliPHOSv1.h
PHOS/Makefile
PHOS/PHOSHistos.cxx
PHOS/PHOSLinkDef.h

index af95946..2bd10d1 100644 (file)
@@ -350,50 +350,56 @@ void AliPHOS::CreateMaterials()
 void AliPHOS::SetTreeAddress()
 { 
 
+
   // TBranch *branch;
-  AliDetector::SetTreeAddress();
+  //  AliDetector::SetTreeAddress();
+
+  TBranch *branch;
+  char branchname[20];
+  sprintf(branchname,"%s",GetName());
+  //
+  // Branch address for hit tree
+  TTree *treeH = gAlice->TreeH();
+  if (treeH && fHits) {
+    branch = treeH->GetBranch(branchname);
+    if (branch) branch->SetAddress(&fHits);
+  }
+  //
+  // Branch address for digit tree
+  TTree *treeD = gAlice->TreeD();
+
+  if(fDigits)
+    fDigits->Clear();
+  else
+    fDigits = new TClonesArray("AliPHOSDigit",1000);
+
+  if (treeD && fDigits) {
+    branch = treeD->GetBranch(branchname);
+    if (branch) branch->SetAddress(&fDigits);
+  }
 
-  TBranch * branch ;
 
   if(fSDigits)
     fSDigits->Clear();
   else
-    fSDigits = new TClonesArray("AliPHOSDigit",1) ;
+    fSDigits = new TClonesArray("AliPHOSDigit",1000);
 
   if (gAlice->TreeS()  && fSDigits ) {
     branch = gAlice->TreeS()->GetBranch("PHOS");
     if (branch) branch->SetAddress(&fSDigits) ;
   } 
 
-  if(fDigits)
-    fDigits->Clear();
-  else
-    fDigits = new TClonesArray("AliPHOSDigit",1) ;
-
-  if (gAlice->TreeD()  && fDigits ) {
-    branch = gAlice->TreeD()->GetBranch("PHOS");
-    if (branch) branch->SetAddress(&fDigits) ;
-  } 
 
   TTree *treeR = gAlice->TreeR();
    
   //Branch address for TreeR: EmcRecPoint
   
-  if(fEmcRecPoints)
-    fEmcRecPoints->Delete();
-  else
-    fEmcRecPoints  = new AliPHOSRecPoint::RecPointsList(1) ; 
-
   if ( treeR && fEmcRecPoints ) {
     branch = treeR->GetBranch("PHOSEmcRP");
     if (branch) branch->SetAddress(&fEmcRecPoints) ;
   }
 
   //Branch address for TreeR: PPSDRecPoint
-  if(fPpsdRecPoints)
-    fPpsdRecPoints->Delete();
-  else
-    fPpsdRecPoints = new AliPHOSRecPoint::RecPointsList(1) ;
 
   if ( treeR && fPpsdRecPoints ) {
     branch = treeR->GetBranch("PHOSPpsdRP");
@@ -401,10 +407,6 @@ void AliPHOS::SetTreeAddress()
   }
 
   //Branch address for TreeR: TrackSegments
-  if(fTrackSegments)
-    fTrackSegments->Clear() ;
-  else
-    fTrackSegments = new AliPHOSTrackSegment::TrackSegmentsList("AliPHOSTrackSegment", 1) ;
   
   if ( treeR && fTrackSegments ) {
     branch = treeR->GetBranch("PHOSTS");
@@ -412,10 +414,6 @@ void AliPHOS::SetTreeAddress()
   }
   
   //Branch address for TreeR: RecParticles
-  if(fRecParticles)
-    fRecParticles->Clear() ;
-  else
-    fRecParticles  = new AliPHOSRecParticle::RecParticlesList("AliPHOSRecParticle", 1) ;
 
   if ( treeR && fRecParticles ) {
     branch = treeR->GetBranch("PHOSRP");
index 1761e48..66b2108 100644 (file)
@@ -39,26 +39,27 @@ class AliPHOS : public AliDetector {
   }
   virtual void   AddHit( Int_t shunt, Int_t primary, Int_t track, Int_t id, Float_t *hits ) = 0 ;   
   virtual void   CreateMaterials() ;                     
-  virtual  AliPHOSRecPoint::RecPointsList **  EmcRecPoints() {
+  AliPHOSRecPoint::RecPointsList *  EmcRecPoints() const {
     // Getting list of RecPoints
-    return &fEmcRecPoints ;
+    return fEmcRecPoints ;
   }
   virtual  AliPHOSGeometry * GetGeometry() = 0 ;
-  virtual void Hit2Digit(){}  // Will convert hits to digits in versions v1 etc
 
-  virtual Int_t   IsVersion(void) const { return -1 ; } 
-  virtual  AliPHOSRecPoint::RecPointsList ** PpsdRecPoints() {
+  Int_t   IsVersion(void) const { return -1 ; } 
+  AliPHOSRecPoint::RecPointsList * PpsdRecPoints() const {
     // to be redefined when ppsd is present
-    return & fPpsdRecPoints ;
+    return  fPpsdRecPoints ;
   } 
   virtual void  SetTreeAddress();                
-  virtual  AliPHOSRecParticle::RecParticlesList **  RecParticles() {
+  AliPHOSRecParticle::RecParticlesList *  RecParticles() const {
     // Getting list of RecParticles
-    return & fRecParticles ;
+    return fRecParticles ;
   }
-  virtual  AliPHOSTrackSegment::TrackSegmentsList **  TrackSegments() {
+  TClonesArray *SDigits() const {return fSDigits;}
+
+  AliPHOSTrackSegment::TrackSegmentsList *  TrackSegments() const {
     // Getting list of TrackSegments
-    return & fTrackSegments ;
+    return fTrackSegments ;
   }
   virtual TString Version() {return TString(" ") ; } 
  
index 413a5c4..a08a314 100644 (file)
@@ -134,6 +134,7 @@ void AliPHOSAnalyze::DrawRecon(Int_t Nevent,Int_t Nmod){
   //for event Nevent in the module Nmod.
 
   TH2F * digitOccupancy  = new TH2F("digitOccupancy","EMC digits", 64,-71.,71.,64,-71.,71.);
+  TH2F * sdigitOccupancy = new TH2F("sdigitOccupancy","EMC sdigits", 64,-71.,71.,64,-71.,71.);
   TH2F * emcOccupancy    = new TH2F("emcOccupancy","EMC RecPoints",64,-71.,71.,64,-71.,71.);
   TH2F * ppsdUp          = new TH2F("ppsdUp","PPSD Up digits",     128,-71.,71.,128,-71.,71.) ;
   TH2F * ppsdUpCl        = new TH2F("ppsdUpCl","PPSD Up RecPoints",128,-71.,71.,128,-71.,71.) ;
@@ -181,107 +182,157 @@ void AliPHOSAnalyze::DrawRecon(Int_t Nevent,Int_t Nmod){
       }
     }  
 
-  fPHOS->SetTreeAddress() ;
+  //  fPHOS->SetTreeAddress() ;
 
-  gAlice->TreeD()->GetEvent(0) ;
-  gAlice->TreeR()->GetEvent(0) ;
+  gAlice->TreeS()->GetEvent(0) ;
+
+  Int_t iSDigit ;
+  AliPHOSDigit * sdigit ;
   
-  TObjArray ** emcRecPoints =  fPHOS->EmcRecPoints() ;
-  TObjArray ** ppsdRecPoints = fPHOS->PpsdRecPoints() ;
-  TClonesArray ** recParticleList  = fPHOS->RecParticles() ;
+  if(fPHOS->SDigits()){
+    for(iSDigit = 0; iSDigit < fPHOS->SDigits()->GetEntries(); iSDigit++)
+      {
+       sdigit = (AliPHOSDigit *) fPHOS->SDigits()->At(iSDigit) ;
+       Int_t relid[4];
+       fGeom->AbsToRelNumbering(sdigit->GetId(), relid) ;
+       Float_t x,z ;
+       fGeom->RelPosInModule(relid,x,z) ;
+       Float_t e = fPHOS->Calibrate(sdigit->GetAmp()) ;
+       if(relid[0]==Nmod){
+         if(relid[1]==0)  //EMC
+           sdigitOccupancy->Fill(x,z,e) ;
+         if((relid[1]>0)&&(relid[1]<17))
+           ppsdUp->Fill(x,z,e) ;
+         if(relid[1]>16)
+           ppsdLow->Fill(x,z,e) ;
+       }
+      }
+  }
+  else{
+    cout << "No SDigits read " << endl ;
+  }
   
-  Int_t iDigit ;
-  AliPHOSDigit * digit ;
+  gAlice->TreeD()->GetEvent(0) ;
   
-  for(iDigit = 0; iDigit < fPHOS->Digits()->GetEntries(); iDigit++)
-    {
-      digit = (AliPHOSDigit *) fPHOS->Digits()->At(iDigit) ;
-      Int_t relid[4];
-      fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
-      Float_t x,z ;
-      fGeom->RelPosInModule(relid,x,z) ;
-      Float_t e = fClu->Calibrate(digit->GetAmp()) ;
-      if(relid[0]==Nmod){
-        if(relid[1]==0)  //EMC
-          digitOccupancy->Fill(x,z,e) ;
-        if((relid[1]>0)&&(relid[1]<17))
-          ppsdUp->Fill(x,z,e) ;
-        if(relid[1]>16)
-          ppsdLow->Fill(x,z,e) ;
+  if(fPHOS->Digits()){
+    Int_t iDigit ;
+    AliPHOSDigit * digit ;
+    for(iDigit = 0; iDigit < fPHOS->Digits()->GetEntries(); iDigit++)
+      {
+       digit = (AliPHOSDigit *) fPHOS->Digits()->At(iDigit) ;
+       Int_t relid[4];
+       fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
+       Float_t x,z ;
+       fGeom->RelPosInModule(relid,x,z) ;
+       Float_t e = fClu->Calibrate(digit->GetAmp()) ;
+       if(relid[0]==Nmod){
+         if(relid[1]==0)  //EMC
+           digitOccupancy->Fill(x,z,e) ;
+         if((relid[1]>0)&&(relid[1]<17))
+           ppsdUp->Fill(x,z,e) ;
+         if(relid[1]>16)
+           ppsdLow->Fill(x,z,e) ;
+       }
       }
-    }
+  }
+  else{
+    cout << "No Digits read " << endl ;
+  }
+
+  gAlice->TreeR()->GetEvent(0) ;
+  
+  TObjArray * emcRecPoints =  fPHOS->EmcRecPoints() ;
+  TObjArray * ppsdRecPoints = fPHOS->PpsdRecPoints() ;
+  TClonesArray * recParticleList  = fPHOS->RecParticles() ;
+
   
   Int_t irecp ;
   TVector3 pos ;
   
-  for(irecp = 0; irecp < (*emcRecPoints)->GetEntries() ; irecp ++){
-    AliPHOSEmcRecPoint * emc= (AliPHOSEmcRecPoint*)(*emcRecPoints)->At(irecp) ;
-    if(emc->GetPHOSMod()==Nmod){
-      emc->GetLocalPosition(pos) ;
-      emcOccupancy->Fill(pos.X(),pos.Z(),emc->GetEnergy());
+  if(emcRecPoints ){
+    for(irecp = 0; irecp < emcRecPoints->GetEntries() ; irecp ++){
+      AliPHOSEmcRecPoint * emc= (AliPHOSEmcRecPoint*)emcRecPoints->At(irecp) ;
+      if(emc->GetPHOSMod()==Nmod){
+       emc->GetLocalPosition(pos) ;
+       emcOccupancy->Fill(pos.X(),pos.Z(),emc->GetEnergy());
+      }
     }
   }
-  
-  for(irecp = 0; irecp < (*ppsdRecPoints)->GetEntries() ; irecp ++){
-    AliPHOSPpsdRecPoint * ppsd= (AliPHOSPpsdRecPoint *)(*ppsdRecPoints)->At(irecp) ;
-    if(ppsd->GetPHOSMod()==Nmod){
-      ppsd->GetLocalPosition(pos) ;
-      if(ppsd->GetUp())
-        ppsdUpCl->Fill(pos.X(),pos.Z(),ppsd->GetEnergy());
-      else
-        ppsdLowCl->Fill(pos.X(),pos.Z(),ppsd->GetEnergy());
+  else{
+    cout << "No EMC rec points read " << endl ;
+  }
+
+  if(ppsdRecPoints ){
+    for(irecp = 0; irecp < ppsdRecPoints->GetEntries() ; irecp ++){
+      AliPHOSPpsdRecPoint * ppsd= (AliPHOSPpsdRecPoint *)ppsdRecPoints->At(irecp) ;
+      if(ppsd->GetPHOSMod()==Nmod){
+       ppsd->GetLocalPosition(pos) ;
+       if(ppsd->GetUp())
+         ppsdUpCl->Fill(pos.X(),pos.Z(),ppsd->GetEnergy());
+       else
+         ppsdLowCl->Fill(pos.X(),pos.Z(),ppsd->GetEnergy());
+      }
     }
   }
-  
+  else{
+    cout << "No PPSD/CPV rec points read " << endl ;
+  }
+    
   AliPHOSRecParticle * recParticle ;
   Int_t iRecParticle ;
-  for(iRecParticle = 0; iRecParticle < (*recParticleList)->GetEntries() ;iRecParticle++ )
-    {
-      recParticle = (AliPHOSRecParticle *) (*recParticleList)->At(iRecParticle) ;
-      
-      Int_t moduleNumberRec ;
-      Double_t recX, recZ ;
-      fGeom->ImpactOnEmc(recParticle->Theta(), recParticle->Phi(), moduleNumberRec, recX, recZ) ;
-      if(moduleNumberRec == Nmod){
+  if(recParticleList ){ 
+    for(iRecParticle = 0; iRecParticle < recParticleList->GetEntries() ;iRecParticle++ )
+      {
+       recParticle = (AliPHOSRecParticle *) recParticleList->At(iRecParticle) ;
        
-        Double_t minDistance = 5. ;
-        Int_t closestPrimary = -1 ;
-       
-        Int_t numberofprimaries ;
-        Int_t * listofprimaries  = recParticle->GetPrimaries(numberofprimaries)  ;
-        Int_t index ;
-        TParticle * primary ;
-        Double_t distance = minDistance ;
+       Int_t moduleNumberRec ;
+       Double_t recX, recZ ;
+       fGeom->ImpactOnEmc(recParticle->Theta(), recParticle->Phi(), moduleNumberRec, recX, recZ) ;
+       if(moduleNumberRec == Nmod){
          
-       for ( index = 0 ; index < numberofprimaries ; index++){
-         primary = gAlice->Particle(listofprimaries[index]) ;
-         Int_t moduleNumber ;
-         Double_t primX, primZ ;
-         fGeom->ImpactOnEmc(primary->Theta(), primary->Phi(), moduleNumber, primX, primZ) ;
-         if(moduleNumberRec == moduleNumber)
-           distance = TMath::Sqrt((recX-primX)*(recX-primX)+(recZ-primZ)*(recZ-primZ) ) ;
-         if(minDistance > distance)
-           {
-             minDistance = distance ;
-             closestPrimary = listofprimaries[index] ;
-           }
-       }
-       
-        if(closestPrimary >=0 ){
+         Double_t minDistance = 5. ;
+         Int_t closestPrimary = -1 ;
          
-          Int_t primaryType = gAlice->Particle(closestPrimary)->GetPdgCode() ;
+         Int_t numberofprimaries ;
+         Int_t * listofprimaries  = recParticle->GetPrimaries(numberofprimaries)  ;
+         Int_t index ;
+         TParticle * primary ;
+         Double_t distance = minDistance ;
          
-          if(primaryType==22)
-            recPhot->Fill(recZ,recX,recParticle->Energy()) ;
-          else
-            if(primaryType==-2112)
-              recNbar->Fill(recZ,recX,recParticle->Energy()) ; 
-        }
+         for ( index = 0 ; index < numberofprimaries ; index++){
+           primary = gAlice->Particle(listofprimaries[index]) ;
+           Int_t moduleNumber ;
+           Double_t primX, primZ ;
+           fGeom->ImpactOnEmc(primary->Theta(), primary->Phi(), moduleNumber, primX, primZ) ;
+           if(moduleNumberRec == moduleNumber)
+             distance = TMath::Sqrt((recX-primX)*(recX-primX)+(recZ-primZ)*(recZ-primZ) ) ;
+           if(minDistance > distance)
+             {
+               minDistance = distance ;
+               closestPrimary = listofprimaries[index] ;
+             }
+         }
+         
+         if(closestPrimary >=0 ){
+           
+           Int_t primaryType = gAlice->Particle(closestPrimary)->GetPdgCode() ;
+           
+           if(primaryType==22)
+             recPhot->Fill(recZ,recX,recParticle->Energy()) ;
+           else
+             if(primaryType==-2112)
+               recNbar->Fill(recZ,recX,recParticle->Energy()) ; 
+         }
+       }
       }
-    }
-  
+  }
+  else{
+    cout << "Not Rec Prticles read " << endl ;
+  }
   
   digitOccupancy->Draw("box") ;
+  sdigitOccupancy->SetLineColor(5) ;
+  sdigitOccupancy->Draw("box") ;
   emcOccupancy->SetLineColor(2) ;
   emcOccupancy->Draw("boxsame") ;
   ppsdUp->SetLineColor(3) ;
@@ -644,14 +695,14 @@ void AliPHOSAnalyze::AnalyzeCPV(Int_t Nevents)
       gAlice->TreeD()->GetEvent(0) ;
       gAlice->TreeR()->GetEvent(0) ;
       
-      TClonesArray ** recParticleList  = fPHOS->RecParticles() ;
+      TClonesArray * recParticleList  = fPHOS->RecParticles() ;
       
             
       AliPHOSRecParticle * recParticle ;
       Int_t iRecParticle ;
-      for(iRecParticle = 0; iRecParticle < (*recParticleList)->GetEntries() ;iRecParticle++ )
+      for(iRecParticle = 0; iRecParticle < recParticleList->GetEntries() ;iRecParticle++ )
        {
-         recParticle = (AliPHOSRecParticle *) (*recParticleList)->At(iRecParticle) ;
+         recParticle = (AliPHOSRecParticle *) recParticleList->At(iRecParticle) ;
          if((recParticle->GetType() == AliPHOSFastRecParticle::kGAMMA)||
             (recParticle->GetType() == AliPHOSFastRecParticle::kNEUTRALEM)){ 
            new( (*allRecParticleList)[iRecPhot] ) AliPHOSRecParticle(*recParticle) ;
@@ -1036,13 +1087,13 @@ void AliPHOSAnalyze::AnalyzeCPV(Int_t Nevents)
       gAlice->TreeD()->GetEvent(0) ;
       gAlice->TreeR()->GetEvent(0) ;
       
-      TClonesArray ** recParticleList  = fPHOS->RecParticles() ;     
+      TClonesArray * recParticleList  = fPHOS->RecParticles() ;     
       
       AliPHOSRecParticle * recParticle ;
       Int_t iRecParticle ;
-      for(iRecParticle = 0; iRecParticle < (*recParticleList)->GetEntries() ;iRecParticle++ )
+      for(iRecParticle = 0; iRecParticle < recParticleList->GetEntries() ;iRecParticle++ )
        {
-         recParticle = (AliPHOSRecParticle *) (*recParticleList)->At(iRecParticle) ;
+         recParticle = (AliPHOSRecParticle *) recParticleList->At(iRecParticle) ;
          fhAllRP->Fill(CorrectEnergy(recParticle->Energy())) ;
          
          Int_t moduleNumberRec ;
index aa3e745..81ccd84 100644 (file)
@@ -304,9 +304,12 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
        nextdigit.Reset() ; 
        
       } // loop over cluster     
-    }  //below energy theshold  
+
+      clu->EvalAll() ;
+    } // energy theshold  
     
     delete[] clusterdigitslist ; 
+
     
   } // while digit
 
index 123cdcd..65c5e6b 100644 (file)
@@ -106,7 +106,7 @@ void AliPHOSCpvRecPoint::AddDigit(AliPHOSDigit & digit, Float_t Energy)
 }
 
 //____________________________________________________________________________
-Bool_t AliPHOSCpvRecPoint::AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) 
+Bool_t AliPHOSCpvRecPoint::AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) const
 {
   // Tells if (true) or not (false) two digits are neighbors)
   
@@ -288,7 +288,60 @@ void AliPHOSCpvRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 }
 
 //____________________________________________________________________________
-Float_t  AliPHOSCpvRecPoint::GetDispersion() 
+void AliPHOSCpvRecPoint::EvalAll(){
+  AliPHOSRecPoint::EvalAll() ;
+  EvalLocalPosition() ;
+}
+//____________________________________________________________________________
+void AliPHOSCpvRecPoint::EvalLocalPosition()
+{
+  // Calculates the center of gravity in the local PHOS-module coordinates 
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  Float_t wtot = 0. ;
+  Int_t relid[4] ;
+
+  Float_t x = 0. ;
+  Float_t z = 0. ;
+  
+  AliPHOSDigit * digit ;
+
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+
+  Int_t iDigit;
+
+  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) );
+
+    Float_t xi ;
+    Float_t zi ;
+    phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+    phosgeom->RelPosInModule(relid, xi, zi);
+    Float_t w = TMath::Max( 0., fW0 + TMath::Log( fEnergyList[iDigit] / fAmp ) ) ;
+    x    += xi * w ;
+    z    += zi * w ;
+    wtot += w ;
+  }
+
+  if (wtot != 0) {
+    x /= wtot ;
+    z /= wtot ;
+  } else {
+    x = -1e6 ;
+    z = -1e6 ;
+    if (fMulDigit != 0) cout << "AliPHOSCpvRecPoint: too low log weight factor "
+                            << "to evaluate cluster's center\n";
+  }
+  fLocPos.SetX(x)  ;
+  fLocPos.SetY(0.) ;
+  fLocPos.SetZ(z)  ;
+
+}
+
+//____________________________________________________________________________
+Float_t  AliPHOSCpvRecPoint::GetDispersion() const
 {
   // Calculates the dispersion of the shower at the origine of the RecPoint
 
@@ -324,7 +377,7 @@ Float_t  AliPHOSCpvRecPoint::GetDispersion()
 }
 
 //____________________________________________________________________________
-void  AliPHOSCpvRecPoint::GetElipsAxis(Float_t * lambda)
+void  AliPHOSCpvRecPoint::GetElipsAxis(Float_t * lambda) const
 {
   // Calculates the axis of the shower ellipsoid
 
@@ -376,59 +429,6 @@ void  AliPHOSCpvRecPoint::GetElipsAxis(Float_t * lambda)
 //    lambda[1] = TMath::Sqrt( 0.5 * (dxx + dzz) - TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz ) ) ;
 }
 
-//____________________________________________________________________________
-void AliPHOSCpvRecPoint::GetLocalPosition(TVector3 &LPos)
-{
-  // Calculates the center of gravity in the local PHOS-module coordinates 
-
-  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
-
-  if( fLocPos.X() < 1000000.) { // already evaluated
-   LPos = fLocPos ;
-   return ;
-  }
-
-  Float_t wtot = 0. ;
-  Int_t relid[4] ;
-
-  Float_t x = 0. ;
-  Float_t z = 0. ;
-  
-  AliPHOSDigit * digit ;
-
-  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
-
-  Int_t iDigit;
-
-  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
-    digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) );
-
-    Float_t xi ;
-    Float_t zi ;
-    phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
-    phosgeom->RelPosInModule(relid, xi, zi);
-    Float_t w = TMath::Max( 0., fW0 + TMath::Log( fEnergyList[iDigit] / fAmp ) ) ;
-    x    += xi * w ;
-    z    += zi * w ;
-    wtot += w ;
-  }
-
-  if (wtot != 0) {
-    x /= wtot ;
-    z /= wtot ;
-  } else {
-    x = -1e6 ;
-    z = -1e6 ;
-    if (fMulDigit != 0) cout << "AliPHOSCpvRecPoint: too low log weight factor "
-                            << "to evaluate cluster's center\n";
-  }
-  fLocPos.SetX(x)  ;
-  fLocPos.SetY(0.) ;
-  fLocPos.SetZ(z)  ;
-
-  LPos = fLocPos ;
-}
 
 //____________________________________________________________________________
 void AliPHOSCpvRecPoint::GetClusterLengths(Int_t &lengX, Int_t &lengZ)
@@ -485,7 +485,7 @@ void AliPHOSCpvRecPoint::GetClusterLengths(Int_t &lengX, Int_t &lengZ)
 }
 
 //____________________________________________________________________________
-Float_t AliPHOSCpvRecPoint::GetMaximalEnergy(void)
+Float_t AliPHOSCpvRecPoint::GetMaximalEnergy(void) const
 {
   // Finds the maximum energy in the cluster
   
@@ -502,7 +502,7 @@ Float_t AliPHOSCpvRecPoint::GetMaximalEnergy(void)
 }
 
 //____________________________________________________________________________
-Int_t AliPHOSCpvRecPoint::GetMultiplicityAtLevel(const Float_t H) 
+Int_t AliPHOSCpvRecPoint::GetMultiplicityAtLevel(const Float_t H) const
 {
   // Calculates the multiplicity of digits with energy larger than H*energy 
   
@@ -517,7 +517,7 @@ Int_t AliPHOSCpvRecPoint::GetMultiplicityAtLevel(const Float_t H)
 }
 
 //____________________________________________________________________________
-Int_t  AliPHOSCpvRecPoint::GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) 
+Int_t  AliPHOSCpvRecPoint::GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) const
 { 
   // Calculates the number of local maxima in the cluster using fLocalMaxCut as the minimum
   //  energy difference between two local maxima
index 325cf4e..f848ecb 100644 (file)
@@ -41,48 +41,29 @@ public:
   virtual ~AliPHOSCpvRecPoint() ;  
 
   virtual void  AddDigit(AliPHOSDigit & digit, Float_t Energy) ;  // add a digit to the digits list  
-  Int_t       Compare(const TObject * obj) const;                         // method for sorting  
-  
-  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(){
-    // gets the list of energies makink this recpoint
-    return fEnergyList ;} 
+  Int_t       Compare(const TObject * obj) const;                 // method for sorting  
+  void        EvalAll( void ) ;
+  void        EvalLocalPosition(void ) ;  // computes the position in the PHOS module 
+  Float_t     GetDelta () const {     return fDelta ; }           // gets the fDelta data member 
+  Float_t     GetDispersion() const ;                             // computes the dispersion of the shower
+  void        GetElipsAxis(Float_t * lambda) const;               // computes the axis of shower ellipsoide
+  Float_t *   GetEnergiesList()const {return fEnergyList ;}  // gets the list of energies making this recpoint
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ; 
-  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() { 
-    // 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     GetLocMaxCut () const {return fLocMaxCut ; }        // gets the cut of the local maximum search 
+  Float_t     GetLogWeightCut ()const {return fW0 ; }             // gets the logarythmic weight for the 
+                                                                  // center of gravity calculation
+  Float_t     GetMaximalEnergy(void) const ;                      // get the highest energy in the cluster
+  Int_t       GetMaximumMultiplicity() const {return fMaxDigit ;} // gets the maximum number of digits allowed
+  Int_t       GetMultiplicity(void) const {return fMulDigit ; }   // gets the number of digits making this recpoint
+  Int_t       GetMultiplicityAtLevel(const Float_t level) const;  // computes multiplicity of digits with energy 
+                                                                  // above relative level
+  Int_t       GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) const ; // searches for the local maxima 
  
-  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 
-  void        GetClusterLengths(Int_t &lengX, Int_t &lengZ); // cluster lengths along x and z
-  Bool_t  IsEmc(void) {
-    // tells that this is not a EMC
-    return kFALSE ; 
-  } 
-  Bool_t      IsCPV(void) {
-    // true if the recpoint is in CPV
-    return (fPHOSMod <= ((AliPHOSGeometry*) fGeom)->GetNCPVModules()) ; } 
-  Bool_t      IsSortable() const { 
-    // says that emcrecpoints are sortable objects 
-    return kTRUE ; } 
+  void        GetClusterLengths(Int_t &lengX, Int_t &lengZ);      // cluster lengths along x and z
+  Bool_t      IsEmc(void) const {return kFALSE ;   }              // tells that this is not a EMC
+  Bool_t      IsCPV(void) const {return (fPHOSMod <= ((AliPHOSGeometry*) fGeom)->GetNCPVModules()) ; }     
+                                                                  // true if the recpoint is in CPV
+  Bool_t      IsSortable() const {  return kTRUE ; }              // says that emcrecpoints are sortable objects
   void        Print(Option_t * opt = "void") ; 
 
   AliPHOSCpvRecPoint & operator = (const AliPHOSCpvRecPoint & rvalue)  {
@@ -93,7 +74,7 @@ public:
 
  private:
 
-  Bool_t AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) ;
+  Bool_t AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) const ;
 
   Float_t  fDelta ;          // parameter used to sort the clusters    
   Float_t  *fEnergyList ;    //[fMulDigit] energy of digits
index ea03066..74ee395 100644 (file)
@@ -50,8 +50,8 @@ AliPHOSEmcRecPoint::AliPHOSEmcRecPoint(Float_t W0, Float_t LocMaxCut)
   fMulDigit   = 0 ;  
   fAmp   = 0. ;   
   fEnergyList = new Float_t[fMaxDigit]; 
-  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
-  fDelta     =  phosgeom->GetCrystalSize(0) ; 
+  fGeom = AliPHOSGeometry::GetInstance() ;
+  fDelta     =  ((AliPHOSGeometry *) fGeom)->GetCrystalSize(0) ; 
   fW0        = W0 ;          
   fLocMaxCut = LocMaxCut ; 
   fLocPos.SetX(1000000.)  ;      //Local position should be evaluated
@@ -105,7 +105,7 @@ void AliPHOSEmcRecPoint::AddDigit(AliPHOSDigit & digit, Float_t Energy)
 }
 
 //____________________________________________________________________________
-Bool_t AliPHOSEmcRecPoint::AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) 
+Bool_t AliPHOSEmcRecPoint::AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) const
 {
   // Tells if (true) or not (false) two digits are neighbors)
   
@@ -137,7 +137,7 @@ Int_t AliPHOSEmcRecPoint::Compare(const TObject * obj) const
   AliPHOSEmcRecPoint * clu = (AliPHOSEmcRecPoint *)obj ; 
 
  
-  Int_t phosmod1 = this->GetPHOSMod() ;
+  Int_t phosmod1 = GetPHOSMod() ;
   Int_t phosmod2 = clu->GetPHOSMod() ;
 
   TVector3 locpos1; 
@@ -276,7 +276,7 @@ void AliPHOSEmcRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 }
 
 //____________________________________________________________________________
-Float_t  AliPHOSEmcRecPoint::GetDispersion() 
+Float_t  AliPHOSEmcRecPoint::GetDispersion() const
 {
   // Calculates the dispersion of the shower at the origine of the RecPoint
 
@@ -414,17 +414,18 @@ void  AliPHOSEmcRecPoint::GetElipsAxis(Float_t * lambda)
 }
 
 //____________________________________________________________________________
-void AliPHOSEmcRecPoint::GetLocalPosition(TVector3 &LPos)
+void AliPHOSEmcRecPoint::EvalAll(void )
+{
+  AliPHOSRecPoint::EvalAll() ;
+  EvalLocalPosition() ;
+}
+//____________________________________________________________________________
+void AliPHOSEmcRecPoint::EvalLocalPosition(void )
 {
   // Calculates the center of gravity in the local PHOS-module coordinates 
 
   AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
 
-  if( fLocPos.X() < 1000000.) { // already evaluated
-   LPos = fLocPos ;
-   return ;
-  }
-
   Float_t wtot = 0. ;
  
   Int_t relid[4] ;
@@ -438,7 +439,6 @@ void AliPHOSEmcRecPoint::GetLocalPosition(TVector3 &LPos)
 
   Int_t iDigit;
 
-
   for(iDigit=0; iDigit<fMulDigit; iDigit++) {
     digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) );
 
@@ -455,15 +455,28 @@ void AliPHOSEmcRecPoint::GetLocalPosition(TVector3 &LPos)
 
   x /= wtot ;
   z /= wtot ;
-  fLocPos.SetX(x)  ;
+
+  // Correction for the depth of the shower starting point (TDR p 127)  
+  Float_t para = 0.925 ; 
+  Float_t parb = 6.52 ; 
+
+  Float_t radius = ((AliPHOSGeometry *) fGeom)->GetIPtoOuterCoverDistance() + 
+                   ((AliPHOSGeometry *) fGeom)->GetOuterBoxSize(1) ; 
+  Float_t incidencephi = TMath::ATan(x / radius) ; 
+  Float_t incidencetheta = TMath::ATan(z / radius) ;
+  Float_t depthx =  ( para * TMath::Log(fAmp) + parb ) * TMath::Sin(incidencephi) ; 
+  Float_t depthz =  ( para * TMath::Log(fAmp) + parb ) * TMath::Sin(incidencetheta) ; 
+  
+
+  fLocPos.SetX(x - depthx)  ;
   fLocPos.SetY(0.) ;
-  fLocPos.SetZ(z)  ;
+  fLocPos.SetZ(z - depthz)  ;
 
-  LPos = fLocPos ;
 }
 
 //____________________________________________________________________________
-Float_t AliPHOSEmcRecPoint::GetMaximalEnergy(void)
+Float_t AliPHOSEmcRecPoint::GetMaximalEnergy(void) const
 {
   // Finds the maximum energy in the cluster
   
@@ -480,7 +493,7 @@ Float_t AliPHOSEmcRecPoint::GetMaximalEnergy(void)
 }
 
 //____________________________________________________________________________
-Int_t AliPHOSEmcRecPoint::GetMultiplicityAtLevel(const Float_t H) 
+Int_t AliPHOSEmcRecPoint::GetMultiplicityAtLevel(const Float_t H) const
 {
   // Calculates the multiplicity of digits with energy larger than H*energy 
   
@@ -495,7 +508,7 @@ Int_t AliPHOSEmcRecPoint::GetMultiplicityAtLevel(const Float_t H)
 }
 
 //____________________________________________________________________________
-Int_t  AliPHOSEmcRecPoint::GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) 
+Int_t  AliPHOSEmcRecPoint::GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) const
 { 
   // Calculates the number of local maxima in the cluster using fLocalMaxCut as the minimum
   //  energy difference between two local maxima
@@ -567,7 +580,7 @@ Int_t  AliPHOSEmcRecPoint::GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEn
 //     AddDigit(*digit) ;
 //   }
 
-//   fAmp       = Clu.GetTotalEnergy() ;
+//   fAmp       = Clu.GetEnergy() ;
 //   fGeom      = Clu.GetGeom() ;
 //   TVector3 locpos;
 //   Clu.GetLocalPosition(locpos) ;
index 620f86f..e7e9b83 100644 (file)
@@ -43,42 +43,25 @@ public:
   virtual void  AddDigit(AliPHOSDigit & digit, Float_t Energy) ;  // add a digit to the digits list  
   Int_t       Compare(const TObject * obj) const;                         // method for sorting  
   Float_t CoreEnergy() ;
-  
-  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(){
-    // gets the list of energies makink this recpoint
-    return fEnergyList ;} 
+  void        EvalAll() ;
+  void        EvalLocalPosition() ;                                // computes the position in the PHOS module 
+  Float_t     GetDelta () const {     return fDelta ; }    
+  Float_t     GetDispersion() const ;                              // computes the dispersion of the shower
+  void        GetElipsAxis(Float_t * lambda) ;                     // computes the axis of shower ellipsoide
+  Float_t *   GetEnergiesList() const {    return fEnergyList ;}   // gets the list of energies making this recpoint
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ; 
-  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() { 
-    // 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     GetLocMaxCut ()const  {    return fLocMaxCut ; }     // gets the cut of the local maximum search  
+  Float_t     GetLogWeightCut ()const { return fW0 ; }             // gets the logarythmic weight for the 
+                                                                   // center of gravity calculation
+  Float_t     GetMaximalEnergy(void) const ;                       // get the highest energy in the cluster
+  Int_t       GetMaximumMultiplicity() const {return fMaxDigit ;}  // gets the maximum number of digits allowed
+  Int_t       GetMultiplicity(void) const { return fMulDigit ; }   // gets the number of digits making this recpoint
+  Int_t       GetMultiplicityAtLevel(const Float_t level) const ;  // computes multiplicity of digits with 
+                                                                   // energy above relative level
+  Int_t       GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) const ; // searches for the local maxima 
  
-  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 ; } 
+  Bool_t      IsEmc(void) const { return kTRUE ; }                 // true if the recpoint is in EMC
+  Bool_t      IsSortable() const {return kTRUE ; }                 // says that emcrecpoints are sortable objects 
   void        Print(Option_t * opt = "void") ; 
 
   AliPHOSEmcRecPoint & operator = (const AliPHOSEmcRecPoint & rvalue)  {
@@ -90,7 +73,7 @@ public:
 
  private:
 
-  Bool_t AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) ;
+  Bool_t AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) const ;
 
   Float_t  fDelta ;          // parameter used to sort the clusters    
   Float_t  *fEnergyList ;    //[fMulDigit] energy of digits
index 5ea9f09..f3c26f5 100644 (file)
@@ -120,7 +120,7 @@ AliPHOSRecParticle * AliPHOSIndexToObject::GimeRecParticle(Int_t index)
 
   AliPHOSRecParticle * rv = 0 ; 
 
-  AliPHOSRecParticle::RecParticlesList * rplist = *(fDetector->RecParticles()) ; 
+  AliPHOSRecParticle::RecParticlesList * rplist = fDetector->RecParticles() ; 
 
   Int_t rpentries  = 0 ; 
 
@@ -139,7 +139,7 @@ AliPHOSRecParticle * AliPHOSIndexToObject::GimeRecParticle(Int_t index)
     cout << "AliPHOSIndexToObject::GimeRecParticle: index " << index << " larger than available entries " 
           <<  rpentries << endl ; 
   else 
-    rv =  (AliPHOSRecParticle *) (*(fDetector->RecParticles()) )->At(index)  ; 
+    rv =  (AliPHOSRecParticle *) (fDetector->RecParticles() )->At(index)  ; 
   
   return rv ;
   
@@ -154,8 +154,8 @@ AliRecPoint * AliPHOSIndexToObject::GimeRecPoint(Int_t index, TString type)
 
   AliPHOSRecPoint * rv = 0 ; 
   
-  AliPHOSRecPoint::RecPointsList * emclist = *(fDetector->EmcRecPoints() ); 
-  AliPHOSRecPoint::RecPointsList * ppsdlist = *(fDetector->PpsdRecPoints() ); 
+  AliPHOSRecPoint::RecPointsList * emclist = fDetector->EmcRecPoints() ; 
+  AliPHOSRecPoint::RecPointsList * ppsdlist = fDetector->PpsdRecPoints() ; 
 
   Int_t emcentries  = 0 ; 
   Int_t ppsdentries = 0 ; 
@@ -207,7 +207,7 @@ AliPHOSTrackSegment * AliPHOSIndexToObject::GimeTrackSegment(Int_t index)
 
   AliPHOSTrackSegment * rv = 0 ; 
 
-  AliPHOSTrackSegment::TrackSegmentsList * tslist = *( fDetector->TrackSegments()) ; 
+  AliPHOSTrackSegment::TrackSegmentsList * tslist = fDetector->TrackSegments() ; 
 
   Int_t tsentries  = 0 ; 
 
index 40e0e55..f86383a 100644 (file)
@@ -46,8 +46,8 @@ AliPHOSPpsdRecPoint::AliPHOSPpsdRecPoint(void)
   // ctor
 
   fMulDigit = 0 ;  
-  AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance() ;  
-  fDelta = geom->GetCrystalSize(0) ; 
+  fGeom = AliPHOSGeometry::GetInstance() ;  
+  fDelta = ((AliPHOSGeometry *)fGeom)->GetCrystalSize(0) ; 
   fLocPos.SetX(1000000.)  ;      //Local position should be evaluated
 }
 
@@ -169,17 +169,18 @@ Int_t AliPHOSPpsdRecPoint::Compare(const TObject * obj) const
 }
 
 //____________________________________________________________________________
-void AliPHOSPpsdRecPoint::GetLocalPosition(TVector3 &LPos)
+void AliPHOSPpsdRecPoint::EvalAll( ){
+  AliPHOSRecPoint::EvalAll() ;
+  EvalLocalPosition( ) ;
+}
+
+//____________________________________________________________________________
+void AliPHOSPpsdRecPoint::EvalLocalPosition( )
 {
   // Calculates the local position in the PHOS-PPSD-module corrdinates
   
   AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
 
-  if( fLocPos.X() < 1000000.) { //allready evaluated
-   LPos = fLocPos ;
-   return ;
-  }
-
   Int_t relid[4] ;
 
   Float_t x = 0. ;
@@ -208,12 +209,10 @@ void AliPHOSPpsdRecPoint::GetLocalPosition(TVector3 &LPos)
   fLocPos.SetY(0.) ;
   fLocPos.SetZ(z)  ;
 
-  LPos = fLocPos ;
-
 }
 
 //____________________________________________________________________________
-Bool_t AliPHOSPpsdRecPoint::GetUp() 
+Bool_t AliPHOSPpsdRecPoint::GetUp() const
 {
   // Are we in the uper PPSD module ?
 
index 69165f8..36bbe4d 100644 (file)
@@ -30,34 +30,15 @@ public:
   }
   virtual void AddDigit(AliPHOSDigit & digit, Float_t Energy) ;
   Int_t   Compare(const TObject * obj) const;                    // method to sort clusters
-
-  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 { 
-    // 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) {
-    // tells that this is not a EMC
-    return kFALSE ; 
-  } 
-  Bool_t  IsSortable() const { 
-    // tells that this is a sortable object
-    return kTRUE ; 
-  }
+  void    EvalAll() ;
+  void    EvalLocalPosition() ;              // computes the position in the module of the cluster center
+  Float_t GetDelta(void) const {return fDelta ;  }              // returns the parameter used for sorting
+  Int_t   GetMultiplicity(void) const { return fMulDigit ;  }   // returns the multiplicity of digits at 
+                                                                // the origin of this recpoint
+  Int_t   GetMaximumMultiplicity() const { return   fMaxDigit ; }     // returns the maximum allowed digit multiplicity 
+  Bool_t  GetUp() const ;               // true if cluster is in upper ppsd 
+  Bool_t  IsEmc(void) const {return kFALSE ; }      // tells that this is not a EMC
+  Bool_t  IsSortable() const { return kTRUE ;  }    // tells that this is a sortable object
   virtual void  Paint(Option_t * option="");
   void    Print(Option_t * opt = "void") ; 
 
index e07602c..e2a9ccf 100644 (file)
@@ -152,19 +152,20 @@ break;
     
   }
 }
+//____________________________________________________________________________
+void AliPHOSRecPoint::EvalAll() {
+  //evaluates (if necessary) all RecPoint data members 
 
+  EvalPHOSMod() ;
+}
 //____________________________________________________________________________
-Int_t AliPHOSRecPoint::GetPHOSMod()
+void AliPHOSRecPoint::EvalPHOSMod() 
 {
   // Returns the PHOS module in which the RecPoint is found
  
-  if(fPHOSMod > 0) 
-    return fPHOSMod ;
-
   AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
 
-  Int_t relid[4] ;
-  
+  Int_t relid[4] ; 
   
   AliPHOSDigit * digit   ;
   digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[0]) ) ;
@@ -172,11 +173,10 @@ Int_t AliPHOSRecPoint::GetPHOSMod()
 
   phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
   fPHOSMod = relid[0];
-  return fPHOSMod ;
 }
 
 //______________________________________________________________________________
-Int_t * AliPHOSRecPoint::GetPrimaries(Int_t & number)
+Int_t * AliPHOSRecPoint::GetPrimaries(Int_t & number) const
 {
   // Constructs the list of primary particles which have contributed to this RecPoint
   
index 0a86afc..75a11d5 100644 (file)
@@ -45,19 +45,15 @@ class AliPHOSRecPoint : public AliRecPoint {
     assert(0==1) ; 
   }
   virtual  void   AddDigit(AliPHOSDigit & digit, Float_t Energy) = 0 ; 
-  virtual Int_t   Compare(const TObject * obj) const { 
-    // check why this is done
-    assert(0==1) ; return 1 ; 
-  }   
+  virtual Int_t   Compare(const TObject * obj) const {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){
-    // says that this is a EMC
-    return kTRUE ;
-  } 
+  virtual void    EvalAll(void) ;  
+  virtual void    EvalPHOSMod(void) ;  
+  virtual Int_t   GetPHOSMod(void) const {return fPHOSMod ; }
+  virtual Int_t * GetPrimaries(Int_t & number) const ;
+  virtual Bool_t  IsEmc(void)const { return kTRUE ;  } 
   virtual Bool_t  IsSortable() const { 
     // tells that this is a sortable object
     return kTRUE ; 
@@ -77,7 +73,6 @@ class AliPHOSRecPoint : public AliRecPoint {
 protected:
   
   Int_t fPHOSMod ;      // PHOS Module number in which the RecPoint is found
-//    AliPHOSGeometry * fGeom ; // pointer to the PHOS geometry class
   
   ClassDef(AliPHOSRecPoint,1) // RecPoint for PHOS (Base Class)
  
index acd3ae5..e14456f 100644 (file)
@@ -157,7 +157,7 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
       primaries = recpoint->GetPrimaries(nprimaries);
       cout << "DebugReconstruction>>>  " << 
        setw(2) <<recpoint->GetPHOSMod() << " "  << 
-       setw(9) << 1000.*recpoint->GetTotalEnergy() <<       " "  <<                   
+       setw(9) << 1000.*recpoint->GetEnergy() <<       " "  <<                   
        setw(6) <<  recpoint->GetIndexInList() << " "  << 
        setw(5) <<  recpoint->GetMultiplicity() <<" "  << 
        setw(8) <<  locpos.X() <<" "  << 
@@ -198,7 +198,7 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
       cout << "DebugReconstruction>>> " << 
        setw(4) << ppsdrecpoint->GetPHOSMod() << "  "  << 
        setw(4)  << detector << " "      <<
-       setw(9) << 1000000.*ppsdrecpoint->GetTotalEnergy() <<       " "  <<             
+       setw(9) << 1000000.*ppsdrecpoint->GetEnergy() <<       " "  <<             
        setw(6) <<  ppsdrecpoint->GetIndexInList() << " "  << 
        setw(5) <<  ppsdrecpoint->GetMultiplicity() <<" "  << 
        setw(8) <<  locpos.X() <<" "  << 
index 14acd77..f833b41 100644 (file)
@@ -226,7 +226,7 @@ AliPHOSEmcRecPoint * AliPHOSTrackSegment::GetEmcRecPoint() const
   
   AliPHOSEmcRecPoint  * emcrp   = GetEmcRecPoint() ; 
   
-  return emcrp->GetTotalEnergy() ;
+  return emcrp->GetEnergy() ;
 }   
 
 //____________________________________________________________________________
@@ -250,58 +250,30 @@ TVector3 AliPHOSTrackSegment::GetMomentumDirection()
 
   TVector3 posEmc ;
   emcrp->GetGlobalPosition(posEmc, mdummy) ;
-
-  // Correction for the depth of the shower starting point (TDR p 127) 
-
-  Float_t energy = emcrp->GetEnergy() ; 
-  Float_t para = 0.925 ; 
-  Float_t parb = 6.52 ; 
-
-  TVector3 localpos ; 
-  emcrp->GetLocalPosition(localpos) ; 
-
-  AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance() ; 
-  Float_t radius = geom->GetIPtoOuterCoverDistance() + geom->GetOuterBoxSize(1) ; 
-  Float_t incidencephi = TMath::ATan(localpos.X() / radius) ; 
-  Float_t incidencetheta = TMath::ATan(localpos.Z() / radius) ;
-  Float_t depthx =  ( para * TMath::Log(energy) + parb ) * TMath::Sin(incidencephi) ; 
-  Float_t depthz =  ( para * TMath::Log(energy) + parb ) * TMath::Sin(incidencetheta) ; 
-  
-  localpos.SetX(localpos.X() - depthx ) ;
-  localpos.SetZ(localpos.Z() - depthz ) ;
  
   TVector3 emcglobalpos ;
   TMatrix  dummy ;
 
   emcrp->GetGlobalPosition(emcglobalpos, dummy) ;
 
-  emcglobalpos.SetX( emcglobalpos.X() - depthx ) ;  
-  emcglobalpos.SetZ( emcglobalpos.Z() - depthz ) ;   
   
-  // The following commeneted code becomes valid once the PPSD provides 
-  // a reasonable position resolution, at least as good as EMC !
+// The following commeneted code becomes valid once the PPSD provides 
+// a reasonable position resolution, at least as good as EMC ! 
 //   TVector3 ppsdlglobalpos ;
 //   TVector3 ppsduglobalpos ;
-
 //   if( fPpsdLowRecPoint ){ // certainly a photon that has concerted
-        
 //     fPpsdLowRecPoint->GetGlobalPosition(ppsdlglobalpos, mdummy) ; 
 //     dir = emcglobalpos -  ppsdlglobalpos ; 
-     
-//     if( fPpsdUpRecPoint ){ // nop looks like a charged
-       
+//     if( fPpsdUpRecPoint ){ // not looks like a charged       
 //        fPpsdUpRecPoint->GetGlobalPosition(ppsduglobalpos, mdummy) ; 
 //        dir = ( dir +  emcglobalpos -  ppsduglobalpos ) * 0.5 ; 
 //      }
 //   }
 //   else { // looks like a neutral
-
-    dir = emcglobalpos ;  
+//    dir = emcglobalpos ;  
 //  }
 
+  dir = emcglobalpos ;  
   dir.SetZ( -dir.Z() ) ;   // why ?  
   dir.SetMag(1.) ;
     
@@ -494,7 +466,7 @@ void AliPHOSTrackSegment::Print(const char * opt)
     
     emcrp->GetGlobalPosition( pos, dummy ) ;
     
-    cout << " Global position " << pos.X() << "   " << pos.Y() << "  " << pos.Z() << "      Energy " << emcrp->GetTotalEnergy() << endl ;
+    cout << " Global position " << pos.X() << "   " << pos.Y() << "  " << pos.Z() << "      Energy " << emcrp->GetEnergy() << endl ;
   }
   
   if ( ppsdlrp != 0 ) {
index ea0e72b..f430c92 100644 (file)
@@ -439,38 +439,6 @@ void  AliPHOSTrackSegmentMakerv1::MakeTrackSegments(DigitsList * dl,
 }
 
 //____________________________________________________________________________
-void  AliPHOSTrackSegmentMakerv1::MakeTrackSegmentsCPV(DigitsList * dl, 
-                                                       AliPHOSRecPoint::RecPointsList * emcl, 
-                                                       AliPHOSRecPoint::RecPointsList * cpvl)
-{
-  // Unfold clusters in EMC and CPV and refill reconstructed point lists emcl and ppsdl
-  // Yuri Kharlov. 19 October 2000
-  
-  fNTrackSegments = 0 ; 
-
-  TArrayI * emcRecPoints     = new TArrayI(1000) ;  // these arrays keep indexes 
-  TArrayI * cpvRecPoints     = new TArrayI(1000) ;  // of RecPoints, which are kept in emcl and ppsdl
-  
-  if(fUnfoldFlag){
-    UnfoldAll(dl, emcl) ;   // Unfolds all EMC clusters
-    UnfoldAll(dl, cpvl) ;   // Unfolds all CPV clusters
-  }
-
-//    Int_t phosmod      = 1 ;
-//    Int_t emcStopedAt  = 0 ; 
-//    Int_t cpvStopedAt  = 0 ; 
-//    while(phosmod <= fGeom->GetNModules() ){
-//      FillOneModule(emcl, emcRecPoints, ppsdl, cpvRecPoints, phosmod, emcStopedAt, cpvStopedAt) ;
-//      emcRecPoints->Reset() ;
-//      cpvRecPoints->Reset() ;
-//      phosmod++ ; 
-//    }
-
-  delete emcRecPoints ; emcRecPoints = 0 ; 
-  delete cpvRecPoints ; cpvRecPoints = 0 ; 
-}
-
-//____________________________________________________________________________
 Double_t  AliPHOSTrackSegmentMakerv1::ShowerShape(Double_t r)
 { 
   // Shape of the shower (see PHOS TDR)
@@ -624,6 +592,7 @@ void  AliPHOSTrackSegmentMakerv1::UnfoldClusters(DigitsList * dl,
        eDigit = emcEnergies[iDigit] * ratio ;
        emcRP->AddDigit( *digit, eDigit ) ;
       }        
+      emcRP->EvalAll() ;
     }
     else{
       (*emcIn)[iRecPoint] = new AliPHOSCpvRecPoint( iniEmc->GetLogWeightCut(), iniEmc->GetLocMaxCut() ) ;
@@ -643,6 +612,7 @@ void  AliPHOSTrackSegmentMakerv1::UnfoldClusters(DigitsList * dl,
        eDigit = emcEnergies[iDigit] * ratio ;
        cpvRP->AddDigit( *digit, eDigit ) ;
       }
+      cpvRP->EvalAll() ;
     }
     
   }
index 681bad7..1089c99 100644 (file)
@@ -62,9 +62,6 @@ public:
                            AliPHOSRecPoint::RecPointsList * emcl, 
                            AliPHOSRecPoint::RecPointsList * ppsdl, 
                            AliPHOSTrackSegment::TrackSegmentsList * trsl ) ; // does the job
-  virtual void MakeTrackSegmentsCPV(DigitsList * DL, 
-                                AliPHOSRecPoint::RecPointsList * emcl, 
-                                AliPHOSRecPoint::RecPointsList * ppsdl ); // just unfold EMC and CPV clusters
   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)
index b858500..39bc25f 100644 (file)
@@ -68,18 +68,6 @@ AliPHOSv1::AliPHOSv1()
   fReconstructioner  = 0;
   fTrackSegmentMaker = 0;
 
-  fHits = new TClonesArray("AliPHOSHit",1000) ;
-  //  if ( 0==(fEMCModules=new TClonesArray("AliPHOSCPVModule",0)) ) {
-  //    Error("AliPHOSv1","Can not create array of EMC modules");
-  //    exit(1);
-  //  }
-
-  //  if ( 0==(fCPVModules=new TClonesArray("AliPHOSCPVModule",0)) ) {
-  //    Error("AliPHOSv1","Can not create array of CPV modules");
-  //    exit(1);
-  //  }
-
 }
 
 //____________________________________________________________________________
@@ -117,34 +105,6 @@ AliPHOSv0(name,title)
 
   fIshunt     =  1 ; // All hits are associated with primary particles
   
-  // Create array of EMC modules of the size of PHOS modules number
-  
-//  if ( 0==(fEMCModules=new TClonesArray("AliPHOSCPVModule",fGeom->GetNModules())) ) {
-//    Error("AliPHOSv1","Can not create array of EMC modules");
-//    exit(1);
-//  }
-//  TClonesArray &lemcmodule = *fEMCModules;
-//  for (Int_t i=0; i<fGeom->GetNModules(); i++) new(lemcmodule[i]) AliPHOSCPVModule();
-
-  // Create array of CPV modules for the IHEP's version of CPV
-
-//  if ( strcmp(fGeom->GetName(),"IHEP") == 0 || strcmp(fGeom->GetName(),"MIXT") == 0 ) {
-//    // Create array of CPV modules of the size of PHOS modules number
-
-//    if ( 0==(fCPVModules=new TClonesArray("AliPHOSCPVModule",fGeom->GetNCPVModules())) ) {
-//      Error("AliPHOSv1","Can not create array of CPV modules");
-//      exit(1);
-//    }
-//    TClonesArray &lcpvmodule = *fCPVModules;
-//    for (Int_t i=0; i<fGeom->GetNCPVModules(); i++) new(lcpvmodule[i]) AliPHOSCPVModule();
-//  }
-//  else {
-//    // Create an empty array of AliPHOSCPVModule to satisfy
-//    // AliPHOSv1::Streamer when writing root file
-
-//    fCPVModules=new TClonesArray("AliPHOSCPVModule",0);
-
-//  }
 }
 
 //____________________________________________________________________________
@@ -153,19 +113,10 @@ AliPHOSv1::AliPHOSv1(AliPHOSReconstructioner * Reconstructioner, const char *nam
 {
   // ctor : title is used to identify the layout
   //        GPS2 = 5 modules (EMC + PPSD)   
-  // We use 2 arrays of hits :
-  //
-  //   - fHits (the "normal" one), which retains the hits associated with
-  //     the current primary particle being tracked
-  //     (this array is reset after each primary has been tracked).
-  //
-  //   - fTmpHits, which retains all the hits of the current event. It 
-  //     is used for the digitization part.
 
   fPinElectronicNoise = 0.010 ;
 
   // We do not want to save in TreeH the raw hits
-  //fHits   = new TClonesArray("AliPHOSHit",100) ;
 
   fDigits = 0 ;
   fHits= new TClonesArray("AliPHOSHit",1000) ;
@@ -331,10 +282,10 @@ void AliPHOSv1::SDigits2Digits(){
 
 
   gAlice->TreeS()->GetEvent(0) ;
-  
 
-  // Noise induced by the PIN diode of the PbWO crystals
+  // First calculate noise induced by the PIN diode of the PbWO crystals
   Int_t iCurSDigit = 0 ;
+
   //we assume, that there is al least one EMC digit...
   if(fSDigits->GetEntries() == 0) {
     cout << "PHOS::SDigits2Digits>  No SDigits !!! Do not produce Digits " << endl ;
@@ -424,6 +375,7 @@ void AliPHOSv1::MakeBranch(Option_t* opt, char *file)
       fSDigits->Clear();
     else
       fSDigits = new TClonesArray("AliPHOSDigit",1000);
+
     fnSdigits = 0 ;
     gAlice->MakeBranchInTree(gAlice->TreeS(),branchname,&fSDigits,fBufferSize,file);  
   }
@@ -433,13 +385,14 @@ void AliPHOSv1::MakeBranch(Option_t* opt, char *file)
   if( cH ){
     char branchname[20];
     sprintf(branchname,"%s",GetName());  
-    if(fSDigits)
+
+    if(fDigits)
       fDigits->Clear();
     else
       fDigits = new TClonesArray("AliPHOSDigit",1000);
     fNdigits = 0 ;
     
-    gAlice->MakeBranchInTree(gAlice->TreeD(),branchname,&fSDigits,fBufferSize,file);  
+    gAlice->MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,fBufferSize,file);  
   }
 
   cH = strstr(opt,"R");
@@ -448,29 +401,41 @@ void AliPHOSv1::MakeBranch(Option_t* opt, char *file)
     char branchname[20];
 
     Int_t splitlevel = 0 ; 
-    
-    fEmcRecPoints->Delete() ; 
+
+    if(fEmcRecPoints)
+      fEmcRecPoints->Delete() ; 
+    else
+      fEmcRecPoints = new TObjArray(100) ;
 
     if ( fEmcRecPoints && gAlice->TreeR() ) {
       sprintf(branchname,"%sEmcRP",GetName()) ;
       gAlice->TreeR()->Branch(branchname, "TObjArray", &fEmcRecPoints, fBufferSize, splitlevel) ; 
     }
 
-    fPpsdRecPoints->Delete() ; 
+    if(fPpsdRecPoints)
+      fPpsdRecPoints->Delete() ; 
+    else
+      fPpsdRecPoints = new TObjArray(100) ;
 
     if ( fPpsdRecPoints && gAlice->TreeR() ) {
       sprintf(branchname,"%sPpsdRP",GetName()) ;
       gAlice->TreeR()->Branch(branchname, "TObjArray", &fPpsdRecPoints, fBufferSize, splitlevel) ;
     }
 
-    fTrackSegments->Delete() ; 
+    if(fTrackSegments)
+      fTrackSegments->Delete() ; 
+    else
+      fTrackSegments = new TClonesArray("AliPHOSTrackSegment",100) ;
     
     if ( fTrackSegments && gAlice->TreeR() ) { 
       sprintf(branchname,"%sTS",GetName()) ;
       gAlice->TreeR()->Branch(branchname, &fTrackSegments, fBufferSize) ;
     }
     
-    fRecParticles->Delete() ; 
+    if(fRecParticles)
+      fRecParticles->Delete() ; 
+    else
+      fRecParticles = new TClonesArray("AliPHOSRecParticle",100) ;
     
     if ( fRecParticles && gAlice->TreeR() ) { 
       sprintf(branchname,"%sRP",GetName()) ;
index 3bed84c..c5d2863 100644 (file)
@@ -42,7 +42,6 @@ public:
   virtual void   AddHit( Int_t shunt, Int_t primary, Int_t track, Int_t id, Float_t *hits, Int_t pid, TLorentzVector p, Float_t *pos) ; 
   Float_t        Calibrate(Int_t amp){ return (amp - fDigitizeA)/fDigitizeB ; }
   Int_t          Digitize(Float_t Energy){ return (Int_t ) (fDigitizeA + Energy*fDigitizeB); }
-  //  virtual void   Hit2Digit(Int_t event) ;
   virtual void   Hits2SDigits() ;
   virtual void   MakeBranch(Option_t* opt, char *file=0 ) ;
   void           Reconstruction(AliPHOSReconstructioner * Reconstructioner) ;
@@ -74,11 +73,6 @@ public:
     return *this ; 
   }
 
-  // IHEP's CPV specific functions
-
-  //  AliPHOSCPVModule &GetEMCModule(int n) { return *(AliPHOSCPVModule*)fEMCModules->operator[](n); }
-  //  AliPHOSCPVModule &GetCPVModule(int n) { return *(AliPHOSCPVModule*)fCPVModules->operator[](n); }
-
   void       CPVDigitize (TLorentzVector p, Float_t *xy, Int_t moduleNumber, TClonesArray *digits) ;
   Float_t    CPVPadResponseFunction(Float_t qhit, Float_t zg, Float_t xg) ;
   Double_t   CPVCumulPadResponse(Double_t x, Double_t y) ;
@@ -94,8 +88,6 @@ protected:
   Int_t   fnSdigits ; 
   AliPHOSReconstructioner  * fReconstructioner ;  // Clusterization and subtracking procedures
   AliPHOSTrackSegmentMaker * fTrackSegmentMaker ; // Reconstructioner of the PHOS track segment: 2 x PPSD + 1 x EMC
-  //  TClonesArray             * fEMCModules;         // Array of EMC modules
-  //  TClonesArray             * fCPVModules;         // Array of CPV modules for the IHEP's version of CPV
 
   ClassDef(AliPHOSv1,1)  // Implementation of PHOS manager class for layout EMC+PPSD
 
index a1dda2f..1c4d8ac 100644 (file)
@@ -16,7 +16,7 @@ SRCS          =  AliPHOS.cxx AliPHOSv0.cxx AliPHOSv1.cxx AliPHOSv2.cxx \
                 AliPHOSEMCAGeometry.cxx \
                 AliPHOSCPVGeometry.cxx AliPHOSCPVBaseGeometry.cxx \
                 AliPHOSPPSDGeometry.cxx AliPHOSSupportGeometry.cxx \
-                AliPHOSCPVModule.cxx AliPHOSCPVDigit.cxx AliPHOSCPVHit.cxx \
+                AliPHOSCPVModule.cxx AliPHOSCPVDigit.cxx \
                  AliPHOSDigit.cxx  \
                  AliPHOSRecPoint.cxx AliPHOSEmcRecPoint.cxx \
                 AliPHOSPpsdRecPoint.cxx AliPHOSCpvRecPoint.cxx \
index e12d287..b746f08 100644 (file)
@@ -127,7 +127,7 @@ void PHOSHistos (Text_t* infile, Int_t nevent, Int_t Module)
      {
        if ( emc->GetPHOSMod() == Module )
        {  
-         Energy = emc->GetTotalEnergy() ;
+         Energy = emc->GetEnergy() ;
         hEmcCluster->Fill(Energy); 
          printf("Energy of the EMC cluster is %f \n",Energy);
         TClonesArray * PpsdRP = PHOS->PpsdClusters() ;
@@ -138,7 +138,7 @@ void PHOSHistos (Text_t* infile, Int_t nevent, Int_t Module)
           {
             if ( Ppsd->GetPHOSMod() == Module )
               { 
-                Energy2 = Ppsd->GetTotalEnergy() ;
+                Energy2 = Ppsd->GetEnergy() ;
                 
                 if (!Ppsd->GetUp()) hConvertorEmc->Fill(Energy,Energy2) ;
               }
@@ -155,7 +155,7 @@ void PHOSHistos (Text_t* infile, Int_t nevent, Int_t Module)
      {
        if ( Ppsd->GetPHOSMod() == Module )
        { 
-         Energy = Ppsd->GetTotalEnergy() ;
+         Energy = Ppsd->GetEnergy() ;
 
         if (!Ppsd->GetUp()) hConvertorCluster->Fill(Energy) ;
         if (Ppsd->GetUp()) hVetoCluster->Fill(Energy) ;
index a04cd8f..574c21f 100644 (file)
@@ -36,7 +36,6 @@
 #pragma link C++ class AliPHOSPPSDGeometry+;
 #pragma link C++ class AliPHOSSupportGeometry+;
 #pragma link C++ class AliPHOSCPVModule+;
-#pragma link C++ class AliPHOSCPVHit+;
 #pragma link C++ class AliPHOSCPVDigit+;
 
 #endif