Reconstruction part now handle all geometry options

diff --git a/PHOS/AliPHOS.cxx b/PHOS/AliPHOS.cxx
index 3f377132c550a86be59ff8c07fd1c1d815c20cd1..bd11428e942262e119d6a0833e458d66e19b417d 100644 (file)
--- a/PHOS/AliPHOS.cxx
+++ b/PHOS/AliPHOS.cxx
@@ -48,7 +48,6 @@ AliPHOS::AliPHOS():AliDetector()
   fDigits        = 0 ;
   fEmcRecPoints  = 0 ; 
   fPpsdRecPoints = 0 ;
-  fCpvRecPoints  = 0 ;
   fTrackSegments = 0 ;
   fRecParticles  = 0 ;
 
@@ -61,7 +60,6 @@ AliPHOS::AliPHOS(const char* name, const char* title): AliDetector(name,title)
   fDigits        = 0 ; 
   fEmcRecPoints  = 0 ; 
   fPpsdRecPoints = 0 ;
-  fCpvRecPoints  = 0 ;
   fTrackSegments = 0 ;
   fRecParticles  = 0 ;
   
@@ -76,9 +74,6 @@ AliPHOS::~AliPHOS()
   if(fPpsdRecPoints)
     fPpsdRecPoints->Delete() ;
   delete fPpsdRecPoints ;
-  if(fCpvRecPoints)
-    fCpvRecPoints->Delete() ;
-  delete fCpvRecPoints ;
   if(fTrackSegments)
     fTrackSegments->Delete() ;
   delete fTrackSegments ;
@@ -392,17 +387,6 @@ void AliPHOS::SetTreeAddress()
     if (branch) branch->SetAddress(&fPpsdRecPoints) ;
   }
 
-  //Branch address for TreeR: CPVRecPoint
-  if(fCpvRecPoints)
-    fCpvRecPoints->Delete();
-  else
-    fCpvRecPoints = new AliPHOSRecPoint::RecPointsList(1) ;
-
-  if ( treeR && fCpvRecPoints ) {
-    branch = treeR->GetBranch("PHOSCpvRP");
-    if (branch) branch->SetAddress(&fCpvRecPoints) ;
-  }
-
   //Branch address for TreeR: TrackSegments
   if(fTrackSegments)
     fTrackSegments->Clear() ;

diff --git a/PHOS/AliPHOS.h b/PHOS/AliPHOS.h
index 5aece3df0a2605dd857ae3c614a6b27b4d1c689e..60782a82540d745283a113210305dee8d7dcf8f2 100644 (file)
--- a/PHOS/AliPHOS.h
+++ b/PHOS/AliPHOS.h
@@ -51,10 +51,6 @@ class AliPHOS : public AliDetector {
     // to be redefined when ppsd is present
     return & fPpsdRecPoints ;
   } 
-  virtual  AliPHOSRecPoint::RecPointsList ** CpvRecPoints() {
-    // to be redefined when cpv is present
-    return & fCpvRecPoints ;
-  }
   virtual void  SetTreeAddress();                
   virtual  AliPHOSRecParticle::RecParticlesList **  RecParticles() {
     // Getting list of RecParticles
@@ -77,7 +73,6 @@ protected:
   
   AliPHOSRecPoint::RecPointsList         *fEmcRecPoints ; // The RecPoints (clusters) list in EMC 
   AliPHOSRecPoint::RecPointsList         *fPpsdRecPoints ;// The RecPoints (clusters) list in PPSD (veto)
-  AliPHOSRecPoint::RecPointsList         *fCpvRecPoints ; // The RecPoints (clusters) list in CPV (veto)
   AliPHOSTrackSegment::TrackSegmentsList *fTrackSegments ;// The TrackSegment list in PHOS
   AliPHOSRecParticle::RecParticlesList   *fRecParticles ; // The reconstructed particles list in PHOS
 

diff --git a/PHOS/AliPHOSAnalyze.cxx b/PHOS/AliPHOSAnalyze.cxx
index 5c1acbd5ceb0b7beda3676543996c3f0db8b7e28..c10308b6fee637007040fbead03d5b3d6d2195f3 100644 (file)
--- a/PHOS/AliPHOSAnalyze.cxx
+++ b/PHOS/AliPHOSAnalyze.cxx
@@ -326,37 +326,35 @@ void AliPHOSAnalyze::DrawRecon(Int_t Nevent,Int_t Nmod){
       else if (strcmp(fGeom->GetName(),"IHEP") == 0 || strcmp(fGeom->GetName(),"MIXT") == 0) {
        fClu->SetLocalMaxCutCPV(0.03) ;
        fClu->SetLogWeightCutCPV(4.0) ;
-       fClu->SetCpvEnergyThreshold(0.09) ;
+       fClu->SetCpvEnergyThreshold(0.2) ;
       }
       fClu->SetCalibrationParameters(0., 0.00000001) ; 
       
       //========== Creates the track segment maker
       fTrs = new AliPHOSTrackSegmentMakerv1()  ;
-         //      fTrs->UnsetUnfoldFlag() ; 
+      //         fTrs->UnsetUnfoldFlag() ; 
      
-      //========== Creates the particle identifier for GPS2 only
-      if      (strcmp(fGeom->GetName(),"GPS2") == 0 || strcmp(fGeom->GetName(),"MIXT") == 0) {
-       fPID = new AliPHOSPIDv1() ;
-       fPID->SetShowerProfileCuts(0.3, 1.8, 0.3, 1.8 ) ; 
-      }          
+      //========== Creates the particle identifier
+      fPID = new AliPHOSPIDv1() ;
+      fPID->SetShowerProfileCuts(0.3, 1.8, 0.3, 1.8 ) ;       
       
       //========== Creates the Reconstructioner
       fRec = new AliPHOSReconstructioner(fClu, fTrs, fPID) ; 
       if (fDebugLevel != 0) fRec -> SetDebugReconstruction(kTRUE);     
     }
-      
+    
     if (fDebugLevel != 0 ||
        (ievent+1) % (Int_t)TMath::Power( 10, (Int_t)TMath::Log10(ievent+1) ) == 0)
       cout <<  "======= Analyze ======> Event " << ievent+1 << endl ;
     
     //=========== Connects the various Tree's for evt
     Int_t tracks = gAlice->GetEvent(ievent);
-
+    
     fPHOS->Hit2Digit(tracks) ;
-        
+    
     //=========== Do the reconstruction
     fPHOS->Reconstruction(fRec);    
-
+    
   }
   
   if(fClu)      {delete fClu      ; fClu     =0 ;}
@@ -369,84 +367,84 @@ void AliPHOSAnalyze::DrawRecon(Int_t Nevent,Int_t Nmod){
 //-------------------------------------------------------------------------------------
 void AliPHOSAnalyze::ReadAndPrintCPV(Int_t EvFirst, Int_t EvLast)
 {
-  //
-  // Read and print generated and reconstructed hits in CPV
-  // for events from EvFirst to Nevent.
-  // If only EvFirst is defined, print only this one event.
-  // Author: Yuri Kharlov
-  // 12 October 2000
-  //
-
-  if (EvFirst!=0 && EvLast==0) EvLast=EvFirst;
-  for ( Int_t ievent=EvFirst; ievent<=EvLast; ievent++) {  
+//   //
+//   // Read and print generated and reconstructed hits in CPV
+//   // for events from EvFirst to Nevent.
+//   // If only EvFirst is defined, print only this one event.
+//   // Author: Yuri Kharlov
+//   // 12 October 2000
+//   //
+
+//   if (EvFirst!=0 && EvLast==0) EvLast=EvFirst;
+//   for ( Int_t ievent=EvFirst; ievent<=EvLast; ievent++) {  
     
-    //========== Event Number>
-    cout << endl <<  "==== ReadAndPrintCPV ====> Event is " << ievent+1 << endl ;
+//     //========== Event Number>
+//     cout << endl <<  "==== ReadAndPrintCPV ====> Event is " << ievent+1 << endl ;
     
-    //=========== Connects the various Tree's for evt
-    Int_t ntracks = gAlice->GetEvent(ievent);
+//     //=========== Connects the various Tree's for evt
+//     Int_t ntracks = gAlice->GetEvent(ievent);
 
-    //========== Creating branches ===================================
-    AliPHOSRecPoint::RecPointsList ** emcRecPoints = fPHOS->EmcRecPoints() ;
-    gAlice->TreeR()->SetBranchAddress( "PHOSEmcRP" , emcRecPoints  ) ;
+//     //========== Creating branches ===================================
+//     AliPHOSRecPoint::RecPointsList ** emcRecPoints = fPHOS->EmcRecPoints() ;
+//     gAlice->TreeR()->SetBranchAddress( "PHOSEmcRP" , emcRecPoints  ) ;
     
-    AliPHOSRecPoint::RecPointsList ** cpvRecPoints = fPHOS->CpvRecPoints() ;
-    gAlice->TreeR()->SetBranchAddress( "PHOSCpvRP", cpvRecPoints ) ;
+//     AliPHOSRecPoint::RecPointsList ** cpvRecPoints = fPHOS->PpsdRecPoints() ;
+//     gAlice->TreeR()->SetBranchAddress( "PHOSPpsdRP", cpvRecPoints ) ;
 
-    // Read and print CPV hits
+//     // Read and print CPV hits
       
-    AliPHOSCPVModule cpvModule;
-    TClonesArray    *cpvHits;
-    Int_t           nCPVhits;
-    AliPHOSCPVHit   *cpvHit;
-    TLorentzVector   p;
-    Float_t          xgen, zgen;
-    Int_t            ipart;
-    Int_t            nGenHits = 0;
-    for (Int_t itrack=0; itrack<ntracks; itrack++) {
-      //=========== Get the Hits Tree for the Primary track itrack
-      gAlice->ResetHits();
-      gAlice->TreeH()->GetEvent(itrack);
-      Int_t iModule = 0 ;      
-      for (iModule=0; iModule < fGeom->GetNCPVModules(); iModule++) {
-       cpvModule = fPHOS->GetCPVModule(iModule);
-       cpvHits   = cpvModule.Hits();
-       nCPVhits  = cpvHits->GetEntriesFast();
-       for (Int_t ihit=0; ihit<nCPVhits; ihit++) {
-         nGenHits++;
-         cpvHit = (AliPHOSCPVHit*)cpvHits->UncheckedAt(ihit);
-         p      = cpvHit->GetMomentum();
-         xgen   = cpvHit->X();
-         zgen   = cpvHit->Y();
-         ipart  = cpvHit->GetIpart();
-         printf("CPV hit in module %d: ",iModule+1);
-         printf(" p = (%f, %f, %f, %f) GeV,\n",
-                p.Px(),p.Py(),p.Pz(),p.Energy());
-         printf("                  (X,Z) = (%8.4f, %8.4f) cm, ipart = %d\n",
-                xgen,zgen,ipart);
-       }
-      }
-    }
-
-    // Read and print CPV reconstructed points
-
-    //=========== Gets the Reconstruction TTree
-    gAlice->TreeR()->GetEvent(0) ;
-    printf("Recpoints: %d\n",(*fPHOS->CpvRecPoints())->GetEntries());
-    TIter nextRP(*fPHOS->CpvRecPoints() ) ;
-    AliPHOSCpvRecPoint *cpvRecPoint ;
-    Int_t nRecPoints = 0;
-    while( ( cpvRecPoint = (AliPHOSCpvRecPoint *)nextRP() ) ) {
-      nRecPoints++;
-      TVector3  locpos;
-      cpvRecPoint->GetLocalPosition(locpos);
-      Int_t phosModule = cpvRecPoint->GetPHOSMod();
-      printf("CPV recpoint in module %d: (X,Z) = (%f,%f) cm\n",
-            phosModule,locpos.X(),locpos.Z());
-    }
-    printf("This event has %d generated hits and %d reconstructed points\n",
-          nGenHits,nRecPoints);
-  }
+//     AliPHOSCPVModule cpvModule;
+//     TClonesArray    *cpvHits;
+//     Int_t           nCPVhits;
+//     AliPHOSCPVHit   *cpvHit;
+//     TLorentzVector   p;
+//     Float_t          xgen, zgen;
+//     Int_t            ipart;
+//     Int_t            nGenHits = 0;
+//     for (Int_t itrack=0; itrack<ntracks; itrack++) {
+//       //=========== Get the Hits Tree for the Primary track itrack
+//       gAlice->ResetHits();
+//       gAlice->TreeH()->GetEvent(itrack);
+//       Int_t iModule = 0 ;   
+//       for (iModule=0; iModule < fGeom->GetNCPVModules(); iModule++) {
+//     cpvModule = fPHOS->GetCPVModule(iModule);
+//     cpvHits   = cpvModule.Hits();
+//     nCPVhits  = cpvHits->GetEntriesFast();
+//     for (Int_t ihit=0; ihit<nCPVhits; ihit++) {
+//       nGenHits++;
+//       cpvHit = (AliPHOSCPVHit*)cpvHits->UncheckedAt(ihit);
+//       p      = cpvHit->GetMomentum();
+//       xgen   = cpvHit->X();
+//       zgen   = cpvHit->Y();
+//       ipart  = cpvHit->GetIpart();
+//       printf("CPV hit in module %d: ",iModule+1);
+//       printf(" p = (%f, %f, %f, %f) GeV,\n",
+//              p.Px(),p.Py(),p.Pz(),p.Energy());
+//       printf("                  (X,Z) = (%8.4f, %8.4f) cm, ipart = %d\n",
+//              xgen,zgen,ipart);
+//     }
+//       }
+//     }
+
+//     // Read and print CPV reconstructed points
+
+//     //=========== Gets the Reconstruction TTree
+//     gAlice->TreeR()->GetEvent(0) ;
+//     printf("Recpoints: %d\n",(*fPHOS->CpvRecPoints())->GetEntries());
+//     TIter nextRP(*fPHOS->CpvRecPoints() ) ;
+//     AliPHOSCpvRecPoint *cpvRecPoint ;
+//     Int_t nRecPoints = 0;
+//     while( ( cpvRecPoint = (AliPHOSCpvRecPoint *)nextRP() ) ) {
+//       nRecPoints++;
+//       TVector3  locpos;
+//       cpvRecPoint->GetLocalPosition(locpos);
+//       Int_t phosModule = cpvRecPoint->GetPHOSMod();
+//       printf("CPV recpoint in module %d: (X,Z) = (%f,%f) cm\n",
+//          phosModule,locpos.X(),locpos.Z());
+//     }
+//     printf("This event has %d generated hits and %d reconstructed points\n",
+//        nGenHits,nRecPoints);
+//   }
 }
 
 //____________________________________________________________________________

diff --git a/PHOS/AliPHOSClusterizer.h b/PHOS/AliPHOSClusterizer.h
index 8f6447ec79e6cd424ffcdbf7e7d30f812f287198..c3e05b7dbf42cd2ec3dbbcefcf6ecc70324dd83c 100644 (file)
--- a/PHOS/AliPHOSClusterizer.h
+++ b/PHOS/AliPHOSClusterizer.h
@@ -43,8 +43,7 @@ public:
 
   virtual void MakeClusters(const DigitsList * dl,
                            AliPHOSRecPoint::RecPointsList * emccl,
-                           AliPHOSRecPoint::RecPointsList * ppsdl,
-                           AliPHOSRecPoint::RecPointsList * cpvl) = 0 ; 
+                           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 ; 

diff --git a/PHOS/AliPHOSClusterizerv1.cxx b/PHOS/AliPHOSClusterizerv1.cxx
index 156b57c206a7e8913306596960813c9df29f588b..fa3997ea23471f486ca30139edcd7324aa422da1 100644 (file)
--- a/PHOS/AliPHOSClusterizerv1.cxx
+++ b/PHOS/AliPHOSClusterizerv1.cxx
@@ -137,12 +137,6 @@ void AliPHOSClusterizerv1::FillandSort(const DigitsList * dl, TObjArray * tl)
   
   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()) ; 
     fGeom->AbsToRelNumbering(id, relid) ;
@@ -188,7 +182,7 @@ Bool_t AliPHOSClusterizerv1::IsInEmc(AliPHOSDigit * digit)
 //____________________________________________________________________________
 Bool_t AliPHOSClusterizerv1::IsInPpsd(AliPHOSDigit * digit) 
 {
-  // Tells if (true) or not (false) the digit is in a PHOS-EMC module
+  // Tells if (true) or not (false) the digit is in a PHOS-PPSD module
  
   Bool_t rv = kFALSE ; 
 
@@ -203,7 +197,7 @@ Bool_t AliPHOSClusterizerv1::IsInPpsd(AliPHOSDigit * digit)
 //____________________________________________________________________________
 Bool_t AliPHOSClusterizerv1::IsInCpv(AliPHOSDigit * digit) 
 {
-  // Tells if (true) or not (false) the digit is in a PHOS-EMC module
+  // Tells if (true) or not (false) the digit is in a PHOS-CPV module
  
   Bool_t rv = kFALSE ; 
 
@@ -218,8 +212,7 @@ Bool_t AliPHOSClusterizerv1::IsInCpv(AliPHOSDigit * digit)
 //____________________________________________________________________________
 void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl, 
                                        AliPHOSRecPoint::RecPointsList * emcl, 
-                                       AliPHOSRecPoint::RecPointsList * ppsdl, 
-                                       AliPHOSRecPoint::RecPointsList * cpvl)
+                                       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
@@ -261,23 +254,15 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
 
       } else { 
        
-       // start a new PPSD cluster
+       // start a new PPSD/CPV cluster
        if(fNumberOfPpsdClusters >= ppsdl->GetSize()) ppsdl->Expand(2*fNumberOfPpsdClusters+1);
-       if(fNumberOfCpvClusters  >= cpvl ->GetSize()) cpvl ->Expand(2*fNumberOfCpvClusters +1);
-       if      (IsInPpsd(digit)) {
+       if      (IsInPpsd(digit)) 
          (*ppsdl)[fNumberOfPpsdClusters] = new AliPHOSPpsdRecPoint() ;
-         clu =  (AliPHOSPpsdRecPoint *) ppsdl->At(fNumberOfPpsdClusters)  ;  
-         fNumberOfPpsdClusters++ ; 
-       }
-       else if (IsInCpv(digit) ) {
-         (*cpvl) [fNumberOfCpvClusters]  = new AliPHOSCpvRecPoint(fW0CPV, fLocMaxCutCPV) ;
-         clu =  (AliPHOSCpvRecPoint  *) cpvl ->At(fNumberOfCpvClusters)  ;  
-         fNumberOfCpvClusters++ ; 
-       }
-       else {
-         cout << "AliPHOSClusterizerv1::MakeClusters: unknown configuration " << fGeom->GetName() << endl;
-         assert(0==1);
-       }
+       else
+         (*ppsdl)[fNumberOfPpsdClusters] = new AliPHOSCpvRecPoint(fW0CPV, fLocMaxCutCPV) ;
+       clu =  (AliPHOSPpsdRecPoint *) ppsdl->At(fNumberOfPpsdClusters)  ;  
+       fNumberOfPpsdClusters++ ; 
+
        clu->AddDigit(*digit, Calibrate(digit->GetAmp()) ) ;    
        clusterdigitslist[iDigitInCluster] = digit  ;   
        iDigitInCluster++ ; 
@@ -285,7 +270,7 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
         nextdigit.Reset() ;
        
        // Here we remove resting EMC digits, which cannot make cluster
-
+       
         if( notremoved ) { 
          while( ( digit = (AliPHOSDigit *)nextdigit() ) ) {
             if( IsInEmc(digit) ) 
@@ -299,7 +284,7 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
       } // else        
       
       nextdigit.Reset() ;
-
+      
       AliPHOSDigit * digitN ; 
       index = 0 ;
       while (index < iDigitInCluster){ // scan over digits already in cluster 
@@ -321,7 +306,7 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
          } // switch
          
        } // while digitN
-
+       
       endofloop: ;
        nextdigit.Reset() ; 
        

diff --git a/PHOS/AliPHOSClusterizerv1.h b/PHOS/AliPHOSClusterizerv1.h
index 3f39659137bde4e74fb9d44a12ba75eb516c3bd3..56cf8c31808cb399c2c5620b18c2b067e9689f0a 100644 (file)
--- a/PHOS/AliPHOSClusterizerv1.h
+++ b/PHOS/AliPHOSClusterizerv1.h
@@ -51,8 +51,7 @@ public:
   virtual Bool_t IsInCpv (AliPHOSDigit * digit) ;             // Tells if id digit is in CPV
   virtual void MakeClusters(const DigitsList * dl, 
                            AliPHOSRecPoint::RecPointsList * emcl, 
-                           AliPHOSRecPoint::RecPointsList * ppsdl,
-                           AliPHOSRecPoint::RecPointsList * cpvl) ; // does the job 
+                           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 ; }

diff --git a/PHOS/AliPHOSCpvRecPoint.h b/PHOS/AliPHOSCpvRecPoint.h
index 0a904148de041d6741a41461638d721d5f468dba..1feea02929407dae7aa99d4885016c15e1458dd2 100644 (file)
--- a/PHOS/AliPHOSCpvRecPoint.h
+++ b/PHOS/AliPHOSCpvRecPoint.h
@@ -73,6 +73,10 @@ public:
     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()) ; } 

diff --git a/PHOS/AliPHOSEmcRecPoint.cxx b/PHOS/AliPHOSEmcRecPoint.cxx
index 24cf5bc29ff7afb7055ca2cf071e25d222626456..bc06a2efd6b637f5d712517dcbfdb1b4bc85cbd6 100644 (file)
--- a/PHOS/AliPHOSEmcRecPoint.cxx
+++ b/PHOS/AliPHOSEmcRecPoint.cxx
@@ -310,6 +310,42 @@ Float_t  AliPHOSEmcRecPoint::GetDispersion()
 
   return TMath::Sqrt(d) ;
 }
+//______________________________________________________________________________
+Float_t AliPHOSEmcRecPoint::CoreEnergy()
+{
+  //This function calculates energy in the core, 
+  //i.e. within radius rad = 3cm. Beyond this radius
+  //in accoradnce with shower profile energy deposition 
+  // should be less than 2%
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  Float_t eCore = 0 ;
+  Float_t coreRadius = 3 ;
+
+  TVector3 locpos;
+  GetLocalPosition(locpos);
+  Float_t x = locpos.X() ;
+  Float_t z = locpos.Z() ;
+
+  AliPHOSDigit * digit ;
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+  
+  Int_t iDigit;
+  for(iDigit=0; iDigit < fMulDigit; iDigit++) {
+    digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
+    Int_t relid[4] ;
+    Float_t xi ;
+    Float_t zi ;
+    phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+    phosgeom->RelPosInModule(relid, xi, zi);    
+    Float_t distance = TMath::Sqrt((xi-x)*(xi-x)+(zi-z)*(zi-z)) ;
+    if(distance < coreRadius)
+      eCore += fEnergyList[iDigit] ;
+  }
+
+return eCore ;
+}
 
 //____________________________________________________________________________
 void  AliPHOSEmcRecPoint::GetElipsAxis(Float_t * lambda)

diff --git a/PHOS/AliPHOSEmcRecPoint.h b/PHOS/AliPHOSEmcRecPoint.h
index f6cf9d868b837d668738b06b5f13cc737507e374..27217a3728276cf6f6e4548b307e8de83b00fb27 100644 (file)
--- a/PHOS/AliPHOSEmcRecPoint.h
+++ b/PHOS/AliPHOSEmcRecPoint.h
@@ -42,6 +42,7 @@ public:
 
   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 CoreEnergy() ;
   
   Float_t     GetDelta (){ 
     // gets the fDelta data member 

diff --git a/PHOS/AliPHOSPIDv1.cxx b/PHOS/AliPHOSPIDv1.cxx
index 30a71f4f8d86c2714a657de40b2382ce3ae109bd..672ca21c372a08f884f0449739ba37c5c29ffc27 100644 (file)
--- a/PHOS/AliPHOSPIDv1.cxx
+++ b/PHOS/AliPHOSPIDv1.cxx
@@ -95,24 +95,21 @@ void  AliPHOSPIDv1::MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl,
   Int_t pcdetector ;    // 1 hit and 0 no hit
 
   while ( (tracksegment = (AliPHOSTrackSegment *)next()) ) {
-    Int_t module = tracksegment->GetPHOSMod();
-    cout << "PHOS module: " << module << endl;
-    if ( module <= fGeom->GetNCPVModules()) continue;
     new( (*rpl)[index] ) AliPHOSRecParticle(tracksegment) ;
     rp = (AliPHOSRecParticle *)rpl->At(index) ; 
     AliPHOSEmcRecPoint * recp = tracksegment->GetEmcRecPoint() ;
     AliPHOSPpsdRecPoint * rpcpv = tracksegment->GetPpsdUpRecPoint() ;
     AliPHOSPpsdRecPoint * rppc  = tracksegment->GetPpsdLowRecPoint() ;
- 
-//     Float_t * lambda = new Float_t[2]; 
-//     recp->GetElipsAxis(lambda) ; 
-
-//     // Looking at the lateral development of the shower
-//     if ( ( lambda[0] > fLambda1m && lambda[0] < fLambda1M ) && // shower profile cut
-//      ( lambda[1] > fLambda2m && lambda[1] < fLambda2M ) )         
-//       //    Float_t R ;
-//       //R=(lambda[0]-1.386)*(lambda[0]-1.386)+1.707*1.707*(lambda[1]-1.008)*(lambda[1]-1.008) ;
-//       //if(R<0.35*0.35)
+    
+    //     Float_t * lambda = new Float_t[2]; 
+    //     recp->GetElipsAxis(lambda) ; 
+    
+    //     // Looking at the lateral development of the shower
+    //     if ( ( lambda[0] > fLambda1m && lambda[0] < fLambda1M ) && // shower profile cut
+    //          ( lambda[1] > fLambda2m && lambda[1] < fLambda2M ) )         
+    //       //    Float_t R ;
+    //       //R=(lambda[0]-1.386)*(lambda[0]-1.386)+1.707*1.707*(lambda[1]-1.008)*(lambda[1]-1.008) ;
+    //       //if(R<0.35*0.35)
 
     Float_t Dispersion;
     Dispersion = recp->GetDispersion();
@@ -120,8 +117,8 @@ void  AliPHOSPIDv1::MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl,
       showerprofile = 0 ;   // NARROW PROFILE   
     else      
       showerprofile = 1 ;// WIDE PROFILE
-  
-
+    
+    
     // Looking at the photon conversion detector
     if( tracksegment->GetPpsdLowRecPoint() == 0 )   
       pcdetector = 0 ;  // No hit
@@ -131,7 +128,7 @@ void  AliPHOSPIDv1::MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl,
       else
        pcdetector = 0 ;
     }
-  
+    
     // Looking at the photon conversion detector
     if( tracksegment->GetPpsdUpRecPoint() == 0 )
       cpvdetector = 0 ;  // No hit

diff --git a/PHOS/AliPHOSReconstructioner.cxx b/PHOS/AliPHOSReconstructioner.cxx
index 0d6dee6d6a91792aff6e543b920cdd8d779adc49..acd3ae5db2c77fb9d6de2d99cf91536255bfa1b8 100644 (file)
--- a/PHOS/AliPHOSReconstructioner.cxx
+++ b/PHOS/AliPHOSReconstructioner.cxx
@@ -71,7 +71,6 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
  void AliPHOSReconstructioner::Make(DigitsList * dl, 
                                    AliPHOSRecPoint::RecPointsList * emccl, 
                                    AliPHOSRecPoint::RecPointsList * ppsdl, 
-                                   AliPHOSRecPoint::RecPointsList * cpvcl, 
                                    AliPHOSTrackSegment::TrackSegmentsList * trsl, 
                                    AliPHOSRecParticle::RecParticlesList * rpl)
 {
@@ -82,7 +81,7 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
   if  (fDebugReconstruction)
     cout << "\n\nDebugReconstruction>>> " << "Start making reconstructed points (clusterizing!!)" << endl;
   
-  fClusterizer->MakeClusters(dl, emccl, ppsdl, cpvcl);
+  fClusterizer->MakeClusters(dl, emccl, ppsdl);
 
   if  (fDebugReconstruction){
     cout << "DebugReconstruction>>> " << "AliPHOSReconstructioner: Digit list entries is " << dl->GetEntries() << endl ;
@@ -214,7 +213,7 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
   
   
   if  (fDebugReconstruction)  cout << "DebugReconstruction>>>> Start making track segments(unfolding+tracksegments)" << endl;
-  fTrackSegmentMaker->MakeTrackSegments(dl, emccl, ppsdl, cpvcl, trsl) ;   
+  fTrackSegmentMaker->MakeTrackSegments(dl, emccl, ppsdl, trsl) ;   
   
   // mark the position of the TrackSegments in the array
   AliPHOSTrackSegment * trs ; 
@@ -260,7 +259,7 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
     
   }
   if  (fDebugReconstruction)  cout << "DebugReconstruction>>>> Start making reconstructed particles" << endl;
-
+  
   if (fPID) {
     fPID->MakeParticles(trsl, rpl) ; 
   

diff --git a/PHOS/AliPHOSReconstructioner.h b/PHOS/AliPHOSReconstructioner.h
index 8b00ea866ada2997bb8a67f9b0a568e32b08cdce..ba659072bc8f7647432e437ef4f4d06d9e551540 100644 (file)
--- a/PHOS/AliPHOSReconstructioner.h
+++ b/PHOS/AliPHOSReconstructioner.h
@@ -45,7 +45,6 @@ public:
   void Make(TClonesArray * DL, 
            AliPHOSRecPoint::RecPointsList * emccl, 
            AliPHOSRecPoint::RecPointsList * ppsdl, 
-           AliPHOSRecPoint::RecPointsList * cpvl,
            AliPHOSTrackSegment::TrackSegmentsList * trsl, 
            AliPHOSRecParticle::RecParticlesList * rpl)    ; // does the job
 

diff --git a/PHOS/AliPHOSTrackSegmentMaker.h b/PHOS/AliPHOSTrackSegmentMaker.h
index 5295138eec4fb3fabb9e72272ecdb70b63a15a48..367738bdc5a119f7fc6421bbefa05eab2606dc80 100644 (file)
--- a/PHOS/AliPHOSTrackSegmentMaker.h
+++ b/PHOS/AliPHOSTrackSegmentMaker.h
@@ -37,7 +37,6 @@ public:
   virtual void MakeTrackSegments(DigitsList * DL, 
                                 AliPHOSRecPoint::RecPointsList * emcl, 
                                 AliPHOSRecPoint::RecPointsList * ppsdl,
-                                AliPHOSRecPoint::RecPointsList * cpvl,
                                 AliPHOSTrackSegment::TrackSegmentsList * trsl ) = 0 ; // does the job
   virtual void SetMaxEmcPpsdDistance(Float_t r) = 0 ; 
   virtual void SetUnfoldFlag() = 0 ;

diff --git a/PHOS/AliPHOSTrackSegmentMakerv1.cxx b/PHOS/AliPHOSTrackSegmentMakerv1.cxx
index 40648709a61b3a2652522f662d56928214790676..8a39460eac79153a08c11f82ad534a3b6ecca3e9 100644 (file)
--- a/PHOS/AliPHOSTrackSegmentMakerv1.cxx
+++ b/PHOS/AliPHOSTrackSegmentMakerv1.cxx
@@ -187,10 +187,14 @@ void  AliPHOSTrackSegmentMakerv1::FillOneModule(AliPHOSRecPoint::RecPointsList *
     ppsdRecPoint = (AliPHOSPpsdRecPoint *) ppsdIn->At(index) ;
     if(ppsdRecPoint->GetPHOSMod() != phosmod )   
       break ;
-    if(ppsdRecPoint->GetUp() ) 
+    if(phosmod <= fGeom->GetNCPVModules())   //in CPV
       ppsdOutUp->AddAt(index,inPpsdUp++) ;
-    else  
-      ppsdOutLow->AddAt(index,inPpsdLow++) ;
+    else{                                   //in PPSD
+      if(ppsdRecPoint->GetUp() ) 
+       ppsdOutUp->AddAt(index,inPpsdUp++) ;
+      else  
+       ppsdOutLow->AddAt(index,inPpsdLow++) ;
+    }
   }
   ppsdOutLow->Set(inPpsdLow);
   ppsdOutUp->Set(inPpsdUp);
@@ -378,7 +382,6 @@ void  AliPHOSTrackSegmentMakerv1::MakePairs(TArrayI * emcRecPoints,
 void  AliPHOSTrackSegmentMakerv1::MakeTrackSegments(DigitsList * dl, 
                                                    AliPHOSRecPoint::RecPointsList * emcl, 
                                                    AliPHOSRecPoint::RecPointsList * ppsdl, 
-                                                   AliPHOSRecPoint::RecPointsList * cpvl, 
                                                    AliPHOSTrackSegment::TrackSegmentsList * trsl)
 {
   // Makes the track segments out of the list of EMC and PPSD Recpoints and stores them in a list
@@ -397,10 +400,10 @@ void  AliPHOSTrackSegmentMakerv1::MakeTrackSegments(DigitsList * dl,
 
   if(fUnfoldFlag){
     UnfoldAll(dl, emcl) ; // Unfolds all EMC clusters
-    UnfoldAll(dl, cpvl) ; // Unfolds all CPV clusters
+    UnfoldAll(dl, ppsdl) ; // Unfolds all CPV clusters
   }
 
-  Int_t phosmod  = fGeom->GetNCPVModules() + 1 ;
+  Int_t phosmod  = 1 ;
   while(phosmod <= fGeom->GetNModules() ){
     
     FillOneModule(emcl, emcRecPoints, ppsdl, ppsdRecPointsUp, ppsdRecPointsLow, phosmod, emcStopedAt, ppsdStopedAt) ;
@@ -485,44 +488,56 @@ Double_t  AliPHOSTrackSegmentMakerv1::ShowerShape(Double_t r)
 //____________________________________________________________________________
 void  AliPHOSTrackSegmentMakerv1::UnfoldAll(DigitsList * dl, AliPHOSRecPoint::RecPointsList * emcIn) 
 {
-  // Performs unfolding of all EMC clusters, sorts them and resets indexes in RecPoints
+  // Performs unfolding of all EMC/CPV but NOT ppsd clusters, sorts them and resets indexes in RecPoints
 
   AliPHOSEmcRecPoint *  emcRecPoint  ; 
   Int_t index ;
   Int_t nEmcUnfolded = emcIn->GetEntries() ;
-  
-  for(index = 0 ; index < nEmcUnfolded; index++){
 
-    emcRecPoint = (AliPHOSEmcRecPoint *) emcIn->At(index) ;
-    
-    Int_t nMultipl = emcRecPoint->GetMultiplicity() ; 
-    Int_t * maxAt = new Int_t[nMultipl] ;
-    Float_t * maxAtEnergy = new Float_t[nMultipl] ;
-    Int_t nMax = emcRecPoint->GetNumberOfLocalMax(maxAt, maxAtEnergy) ;
-    
-    if( nMax > 1 ) {     // if cluster is very flat (no pronounced maximum) then nMax = 0       
-      UnfoldClusters(dl, emcIn, emcRecPoint, nMax, maxAt, maxAtEnergy) ;
-      emcIn->Remove(emcRecPoint); 
-      emcIn->Compress() ;
-      index-- ;
-      nEmcUnfolded-- ;
-    }
-    
-    delete[] maxAt ; 
-    delete[] maxAtEnergy ; 
-  } //Unfolding finished
+  Int_t nModulesToUnfold ;
 
-  emcIn->Sort() ;
+  if(emcIn->GetEntries() > 0){
 
-  // to set index to new and correct index of old RecPoints
-  for( index = 0 ; index < emcIn->GetEntries() ; index++){
+    if(((AliPHOSRecPoint *)emcIn->At(0))->IsEmc())
+      nModulesToUnfold = fGeom->GetNModules() ; 
+    else
+      nModulesToUnfold = fGeom->GetNCPVModules() ;
+    
+    for(index = 0 ; index < nEmcUnfolded; index++){
+      
+      emcRecPoint = (AliPHOSEmcRecPoint *) emcIn->At(index) ;
+      if(emcRecPoint->GetPHOSMod()> nModulesToUnfold)
+       break ;
+      
+      Int_t nMultipl = emcRecPoint->GetMultiplicity() ; 
+      Int_t * maxAt = new Int_t[nMultipl] ;
+      Float_t * maxAtEnergy = new Float_t[nMultipl] ;
+      Int_t nMax = emcRecPoint->GetNumberOfLocalMax(maxAt, maxAtEnergy) ;
+      
+      if( nMax > 1 ) {     // if cluster is very flat (no pronounced maximum) then nMax = 0       
+       UnfoldClusters(dl, emcIn, emcRecPoint, nMax, maxAt, maxAtEnergy) ;
+       emcIn->Remove(emcRecPoint); 
+       emcIn->Compress() ;
+       index-- ;
+       nEmcUnfolded-- ;
+      }
+      
+      delete[] maxAt ; 
+      delete[] maxAtEnergy ; 
+    } //Unfolding finished
     
-    ((AliPHOSEmcRecPoint *) emcIn->At(index))->SetIndexInList(index) ;   
+    emcIn->Sort() ;
     
+    // to set index to new and correct index of old RecPoints
+    for( index = 0 ; index < emcIn->GetEntries() ; index++){
+      
+      ((AliPHOSEmcRecPoint *) emcIn->At(index))->SetIndexInList(index) ;   
+      
+    }
+    
+    emcIn->Sort() ;
   }
 
-  emcIn->Sort() ;
-
 }
 //____________________________________________________________________________
 void  AliPHOSTrackSegmentMakerv1::UnfoldClusters(DigitsList * dl, 

diff --git a/PHOS/AliPHOSTrackSegmentMakerv1.h b/PHOS/AliPHOSTrackSegmentMakerv1.h
index f193b69e073e31a830490d143d20c8ae3693663c..ce203ded756901623a7fc541ac376ad64a407e28 100644 (file)
--- a/PHOS/AliPHOSTrackSegmentMakerv1.h
+++ b/PHOS/AliPHOSTrackSegmentMakerv1.h
@@ -61,7 +61,6 @@ public:
   void    MakeTrackSegments(DigitsList * DL, 
                            AliPHOSRecPoint::RecPointsList * emcl, 
                            AliPHOSRecPoint::RecPointsList * ppsdl, 
-                           AliPHOSRecPoint::RecPointsList * cpvl, 
                            AliPHOSTrackSegment::TrackSegmentsList * trsl ) ; // does the job
   virtual void MakeTrackSegmentsCPV(DigitsList * DL, 
                                 AliPHOSRecPoint::RecPointsList * emcl, 

diff --git a/PHOS/AliPHOSv1.cxx b/PHOS/AliPHOSv1.cxx
index 6857de2da210636082ee70db61e799f96c31e456..56e5a4e9b6b17db216689fc784b1b2e93f72c86e 100644 (file)
--- a/PHOS/AliPHOSv1.cxx
+++ b/PHOS/AliPHOSv1.cxx
@@ -211,13 +211,7 @@ AliPHOSv1::~AliPHOSv1()
     delete fPpsdRecPoints ;
     fPpsdRecPoints = 0 ; 
   }
-  
-  if ( fCpvRecPoints ) {
-    fCpvRecPoints->Delete() ; 
-    delete fCpvRecPoints ; 
-    fCpvRecPoints = 0 ; 
-  }
-  
+    
   if ( fTrackSegments ) {
     fTrackSegments->Delete() ; 
     delete fTrackSegments ;
@@ -412,13 +406,6 @@ void AliPHOSv1::Reconstruction(AliPHOSReconstructioner * Reconstructioner)
     gAlice->TreeR()->Branch(branchname, "TObjArray", &fPpsdRecPoints, fBufferSize, splitlevel) ;
   }
 
-  fCpvRecPoints->Delete() ; 
-
-  if ( fCpvRecPoints && gAlice->TreeR() ) {
-    sprintf(branchname,"%sCpvRP",GetName()) ;
-    gAlice->TreeR()->Branch(branchname, "TObjArray", &fCpvRecPoints, fBufferSize, splitlevel) ;
-  }
-
   fTrackSegments->Delete() ; 
 
   if ( fTrackSegments && gAlice->TreeR() ) { 
@@ -428,20 +415,17 @@ void AliPHOSv1::Reconstruction(AliPHOSReconstructioner * Reconstructioner)
 
   fRecParticles->Delete() ; 
 
-  if (strcmp(fGeom->GetName(),"GPS2") == 0 || strcmp(fGeom->GetName(),"MIXT") == 0) {
-    if ( fRecParticles && gAlice->TreeR() ) { 
-      sprintf(branchname,"%sRP",GetName()) ;
-      gAlice->TreeR()->Branch(branchname, &fRecParticles, fBufferSize) ;
-    }
+  if ( fRecParticles && gAlice->TreeR() ) { 
+    sprintf(branchname,"%sRP",GetName()) ;
+    gAlice->TreeR()->Branch(branchname, &fRecParticles, fBufferSize) ;
   }
   
   // 3.
 
-  fReconstructioner->Make(fDigits, fEmcRecPoints, fPpsdRecPoints,
-                         fCpvRecPoints, fTrackSegments, fRecParticles);
+  fReconstructioner->Make(fDigits, fEmcRecPoints, fPpsdRecPoints, fTrackSegments, fRecParticles);
 
-  printf("Reconstruction: %d %d %d %d %d\n",
-        fEmcRecPoints->GetEntries(),fPpsdRecPoints->GetEntries(),fCpvRecPoints->GetEntries(),
+  printf("Reconstruction: %d %d %d %d\n",
+        fEmcRecPoints->GetEntries(),fPpsdRecPoints->GetEntries(),
         fTrackSegments->GetEntries(),fRecParticles->GetEntries());
 
   // 4. Expand or Shrink the arrays to the proper size
@@ -454,9 +438,6 @@ void AliPHOSv1::Reconstruction(AliPHOSReconstructioner * Reconstructioner)
   size = fPpsdRecPoints->GetEntries() ;
   fPpsdRecPoints->Expand(size) ;
 
-  size = fCpvRecPoints->GetEntries() ;
-  fCpvRecPoints->Expand(size) ;
-
   size = fTrackSegments->GetEntries() ;
   fTrackSegments->Expand(size) ;
 
@@ -493,7 +474,6 @@ void AliPHOSv1::ResetReconstruction()
 
   if ( fEmcRecPoints  )  fEmcRecPoints ->Delete();
   if ( fPpsdRecPoints )  fPpsdRecPoints->Delete();
-  if ( fCpvRecPoints  )  fCpvRecPoints ->Delete();
   if ( fTrackSegments )  fTrackSegments->Delete();
   if ( fRecParticles  )  fRecParticles ->Delete();
   
@@ -560,8 +540,9 @@ void AliPHOSv1::StepManager(void)
 
       if ( xyze[3] != 0 ) { // there is deposited energy 
                gMC->CurrentVolOffID(5, relid[0]) ;  // get the PHOS Module number
-       if ( name == "MIXT" && strcmp(gMC->CurrentVolOffName(5),"PHO1") == 0 )
+       if ( name == "MIXT" && strcmp(gMC->CurrentVolOffName(5),"PHO1") == 0 ){
          relid[0] += fGeom->GetNModules() - fGeom->GetNPPSDModules();
+       }
                gMC->CurrentVolOffID(3, relid[1]) ;  // get the Micromegas Module number 
       // 1-> fGeom->GetNumberOfModulesPhi() * fGeom->GetNumberOfModulesZ() upper
       //   > fGeom->GetNumberOfModulesPhi() * fGeom->GetNumberOfModulesZ() lower
@@ -713,6 +694,7 @@ void AliPHOSv1::StepManager(void)
 
        Int_t moduleNumber;
        gMC->CurrentVolOffID(10,moduleNumber);
+
        if ( name == "MIXT" && strcmp(gMC->CurrentVolOffName(10),"PHO1") == 0 )
          moduleNumber += fGeom->GetNModules() - fGeom->GetNPPSDModules();
        moduleNumber--;
@@ -756,18 +738,17 @@ void AliPHOSv1::StepManager(void)
 
     if ( xyze[3] != 0 ) {
       gMC->CurrentVolOffID(10, relid[0]) ; // get the PHOS module number ;
-      if ( name == "MIXT" && strcmp(gMC->CurrentVolOffName(5),"PHO1") == 0 )
-       relid[0] += fGeom->GetNModules() - fGeom->GetNPPSDModules();
+      if ( name == "MIXT" && strcmp(gMC->CurrentVolOffName(10),"PHO1") == 0 )
+       relid[0] += fGeom->GetNModules() - fGeom->GetNPPSDModules();      
+
       relid[1] = 0   ;                    // means PBW04
       gMC->CurrentVolOffID(4, relid[2]) ; // get the row number inside the module
       gMC->CurrentVolOffID(3, relid[3]) ; // get the cell number inside the module
       
       // get the absolute Id number
-      
       fGeom->RelToAbsNumbering(relid, absid) ; 
 
       // add current hit to the hit list
-      
       AddHit(fIshunt, primary,tracknumber, absid, xyze, trackpid);
 
     } // there is deposited energy