Adding raw decoder selecting samples with gamma2 shape
authorkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Oct 2007 09:15:05 +0000 (09:15 +0000)
committerkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Oct 2007 09:15:05 +0000 (09:15 +0000)
PHOS/AliPHOSRawDecoder.h
PHOS/AliPHOSRawDecoderv1.cxx [new file with mode: 0644]
PHOS/AliPHOSRawDecoderv1.h [new file with mode: 0644]
PHOS/AliPHOSRawDigiProducer.cxx
PHOS/AliPHOSRecoParam.cxx
PHOS/AliPHOSRecoParam.h
PHOS/AliPHOSReconstructor.cxx
PHOS/PHOSbaseLinkDef.h
PHOS/libPHOSbase.pkg

index 5947e79..1c24b0e 100644 (file)
@@ -45,7 +45,6 @@ protected:
   AliCaloRawStream* fCaloStream; // PHOS/EMCAL raw data stream
   Bool_t fPedSubtract;           // pedestals subtraction (kTRUE="yes")
 
-private:
 
   Double_t fEnergy; // "digit" energy
   Double_t fTime;   // "digit" time
diff --git a/PHOS/AliPHOSRawDecoderv1.cxx b/PHOS/AliPHOSRawDecoderv1.cxx
new file mode 100644 (file)
index 0000000..579d427
--- /dev/null
@@ -0,0 +1,335 @@
+/**************************************************************************
+ * Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+// This class decodes the stream of ALTRO samples to extract
+// the PHOS "digits" of current event. Uses fitting procedure
+// to separate reasonable samples
+// 
+// Typical use case:
+//     AliRawReader* rf = new AliRawReaderDate("2006run2211.raw");
+//     AliPHOSRawDecoder dc(rf);
+//     while (rf->NextEvent()) {
+//       dc.SetOldRCUFormat(kTRUE);
+//       dc.SubtractPedestals(kTRUE);
+//       while ( dc.NextDigit() ) {
+//         Int_t module = dc.GetModule();
+//         Int_t column = dc.GetColumn();
+//         Int_t row = dc.GetRow();
+//         Double_t amplitude = dc.GetEnergy();
+//         Double_t time = dc.GetTime();
+//         Bool_t IsLowGain = dc.IsLowGain();
+//            ..........
+//       }
+//     }
+
+// Author: Dmitri Peressounko
+
+// --- ROOT system ---
+#include "TMath.h"
+#include "TMinuit.h"
+
+// --- AliRoot header files ---
+#include "AliPHOSRawDecoderv1.h"
+#include "AliPHOSPulseGenerator.h"
+
+
+ClassImp(AliPHOSRawDecoderv1)
+
+//-----------------------------------------------------------------------------
+  AliPHOSRawDecoderv1::AliPHOSRawDecoderv1():AliPHOSRawDecoder()
+{
+  //Default constructor.
+}
+
+//-----------------------------------------------------------------------------
+AliPHOSRawDecoderv1::AliPHOSRawDecoderv1(AliRawReader* rawReader,  AliAltroMapping **mapping):
+  AliPHOSRawDecoder(rawReader,mapping)
+{
+  //Construct a decoder object.
+  //Is is user responsibility to provide next raw event 
+  //using AliRawReader::NextEvent().
+
+  if(!gMinuit) 
+    gMinuit = new TMinuit(100);
+
+}
+
+//-----------------------------------------------------------------------------
+AliPHOSRawDecoderv1::~AliPHOSRawDecoderv1()
+{
+  //Destructor.
+}
+
+//-----------------------------------------------------------------------------
+AliPHOSRawDecoderv1::AliPHOSRawDecoderv1(const AliPHOSRawDecoderv1 &phosDecoder ):
+  AliPHOSRawDecoder(phosDecoder)
+{
+  //Copy constructor.
+}
+
+//-----------------------------------------------------------------------------
+AliPHOSRawDecoderv1& AliPHOSRawDecoderv1::operator = (const AliPHOSRawDecoderv1 &phosDecode)
+{
+  //Assignment operator.
+
+  //  if(this != &phosDecode) {
+  //  }
+
+  return *this;
+}
+
+//-----------------------------------------------------------------------------
+Bool_t AliPHOSRawDecoderv1::NextDigit()
+{
+  //Extract an energy deposited in the crystal,
+  //crystal' position (module,column,row),
+  //time and gain (high or low).
+  //First collects sample, then evaluates it and if it has
+  //reasonable shape, fits it with Gamma2 function and extracts 
+  //energy and time.
+  
+  AliCaloRawStream* in = fCaloStream;
+  
+  Int_t    iBin     = 0;
+  Int_t    tLength  = 0;
+  fEnergy = -111;
+  Float_t pedMean = 0;
+  Int_t   nPed = 0;
+  Float_t baseLine = 1.0;
+  const Float_t nPreSamples = 10;
+  
+  while ( in->Next() ) { 
+    
+    if(!tLength) {
+      tLength = in->GetTimeLength();
+      if(tLength!=fSamples->GetSize()) {
+       delete fSamples ;
+       fSamples = new TArrayI(tLength);
+      }
+      else{
+       for(Int_t i=0; i<fSamples->GetSize(); i++){
+         fSamples->AddAt(0,i) ;
+       }
+      }
+    }
+    
+    // Fit the full sample
+    if(in->IsNewHWAddress() && iBin>0) {
+      
+      Double_t pedestal =0. ;
+      if(fPedSubtract){ 
+       if (nPed > 0)
+         pedestal = (Double_t)(pedMean/nPed); 
+       else
+         return kFALSE;
+      }
+      
+      //calculate energy
+      //first estimate if this sample looks like gamma2 function
+      Double_t aMean=0. ;
+      Double_t aRMS=0. ;
+      Int_t tStart = 0 ;
+      Int_t cnts=0 ;
+      for(Int_t i=0; i<fSamples->GetSize(); i++){
+       if(fSamples->At(i)>0){
+         Double_t de=fSamples->At(i)-pedestal ;
+         aMean+=de ;
+         aRMS+=de*de ;
+         cnts++;
+         if(de>2 && tStart==0)
+           tStart=i ;
+         if(fSamples->At(i)>fEnergy)
+           fEnergy=fSamples->At(i) ;
+       }
+      }
+      if(cnts>0){
+       aMean/=cnts; 
+       aRMS=aRMS/cnts-aMean*aMean;
+      }
+      
+      if(fPedSubtract){ 
+       fEnergy-=pedestal ;
+      }
+      
+      //IF sample has reasonable mean and RMS, try to fit it with gamma2
+      if(fEnergy>2.&& cnts >20 && aMean>0. && aRMS>2.){ //more or less reasonable sample
+       
+       gMinuit->mncler();                     // Reset Minuit's list of paramters
+       gMinuit->SetPrintLevel(-1) ;           // No Printout
+       gMinuit->SetFCN(AliPHOSRawDecoderv1::UnfoldingChiSquare) ;  
+       // To set the address of the minimization function 
+       
+       gMinuit->SetObjectFit((TObject*)fSamples) ;         // To tranfer pointer to UnfoldingChiSquare
+       Int_t ierflg ;
+       gMinuit->mnparm(0, "p",  pedestal, 0.1, 0, 0, ierflg) ;
+       if(ierflg != 0){ 
+         //      Warning("NextDigit", "Uunable to set initial value for fit procedure : ped = %f\n", pedestal ) ;
+         fEnergy=0. ;
+         fTime=-999. ;
+         return kTRUE ; //will scan further
+       }
+       gMinuit->mnparm(1, "t0",  1.*tStart, 0.1, 0, 0, ierflg) ;
+       if(ierflg != 0){
+         //      Warning("NextDigit", "Unable to set initial value for fit procedure : t0\n" ) ;
+         fEnergy=0. ;
+         fTime=-999. ;
+         return kTRUE ; //will scan further
+       }
+       gMinuit->mnparm(2, "Energy", fEnergy*0.018 , 0.001*fEnergy, 0, 0, ierflg) ;
+       if(ierflg != 0){
+         //      Warning("NextDigit", "Unable to set initial value for fit procedure : E=%f\n", fEnergy*0.018) ;
+         fEnergy=0. ;
+         fTime=-999. ;
+         return kTRUE ; //will scan further
+       }
+       gMinuit->mnparm(3, "Slope", 0.09 , 0.001, 0.001, 1., ierflg) ;
+       if(ierflg != 0){
+         //      Warning("NextDigit", "Unable to set initial value for fit procedure : Slope\n") ;
+         fEnergy=0. ;
+         fTime=-999. ;
+         return kTRUE ; //will scan further
+       }
+       
+       Double_t p0 = 1. ; // "Tolerance" Evaluation stops when EDM = 0.0001*p0 ; The number of function call slightly
+       //  depends on it. 
+       Double_t p1 = 1.0 ;
+       Double_t p2 = 0.0 ;
+       gMinuit->mnexcm("SET STR", &p2, 0, ierflg) ;   // force TMinuit to reduce function calls  
+       gMinuit->mnexcm("SET GRA", &p1, 1, ierflg) ;   // force TMinuit to use my gradient  
+       //      gMinuit->SetMaxIterations(100);
+       gMinuit->mnexcm("SET NOW", &p2 , 0, ierflg) ;  // No Warnings
+       
+       gMinuit->mnexcm("MIGRAD", &p0, 0, ierflg) ;    // minimize 
+       
+       Double_t err ;
+       Double_t p,t0,efit,slope ;
+       gMinuit->GetParameter(0,p, err) ;    
+       gMinuit->GetParameter(1,t0, err) ;    
+       gMinuit->GetParameter(2,efit, err) ;    
+       gMinuit->GetParameter(3,slope, err) ;    
+       
+       efit=efit*4.*TMath::Exp(-2.)/slope/slope ; //slope can not be zero - par limits
+       
+       Double_t fmin,fedm,errdef ;
+       Int_t npari,nparx,istat;
+       gMinuit->mnstat(fmin,fedm,errdef,npari,nparx,istat) ;
+       
+       if(fmin < cnts*(efit/10.) ){ //Chi^2 of a good sample
+         if(efit<1050.&& efit>0.){
+           fEnergy=efit ;
+           fTime=t0 ;
+         }
+       }
+       else{
+         fEnergy=0 ; //bad sample
+         fTime=-999.;
+       }
+       if(fLowGainFlag)
+         fEnergy *= fPulseGenerator->GetRawFormatHighLowGainFactor(); // *16 
+       
+       if (fEnergy < baseLine) fEnergy = 0;
+      }
+      else{ //bad sample
+       fEnergy=0. ;
+       fTime=-999. ;
+      }
+      
+      return kTRUE;
+    }
+    
+    fLowGainFlag = in->IsLowGain();
+    fTime = fPulseGenerator->GetRawFormatTimeTrigger() * in->GetTime();
+    fModule = in->GetModule()+1;
+    fRow    = in->GetRow()   +1;
+    fColumn = in->GetColumn()+1;
+    
+    
+    // Fill array with samples
+    iBin++;                                                             
+    if(tLength-iBin < nPreSamples) {
+      pedMean += in->GetSignal();
+      nPed++;
+    }
+    fSamples->AddAt(in->GetSignal(),tLength-iBin);
+    
+  } // in.Next()
+  
+  return kFALSE;
+}
+//_____________________________________________________________________________
+void AliPHOSRawDecoderv1::UnfoldingChiSquare(Int_t & /*nPar*/, Double_t * Grad, Double_t & fret, Double_t * x, Int_t iflag)
+{
+  // Calculates the Chi square for the samples minimization
+  // Number of parameters, Gradient, Chi squared, parameters, what to do
+
+  TArrayI * samples = (TArrayI*)gMinuit->GetObjectFit() ;
+
+  fret = 0. ;     
+  if(iflag == 2)
+    for(Int_t iparam = 0 ; iparam < 4 ; iparam++)    
+      Grad[iparam] = 0 ; // Will evaluate gradient
+  
+  Int_t nSamples=samples->GetSize() ;
+  Double_t p =x[0] ;
+  Double_t t0=x[1] ;
+  Double_t en=x[2] ;
+  Double_t a =x[3] ;
+  
+  for(Int_t i = 0 ; i < nSamples ; i++) {
+    if(samples->At(i)==0)
+      continue ;
+    Double_t dt=i*1.-t0 ;
+    Double_t diff=samples->At(i)-Gamma2(dt,p,en,a) ;
+    Double_t w=1. ; //TMath::Ceil(TMath::Abs(samples->At(i)-ped)/10.) ;
+    //    if(w==0)w=1. ;
+    diff/=w ;
+    if(iflag == 2){  // calculate gradient
+      Grad[0] += -2.*diff/w ; //derivative over pedestal
+      if(dt>=0.){
+       Grad[1] += -2.*en*diff*(a*dt-2.*dt)*dt*TMath::Exp(-a*dt)/w ; //derivative over t0
+       Grad[2] += -2.*diff*dt*dt*TMath::Exp(-a*dt)/w ;
+       Grad[3] +=  2.*en*diff*dt*dt*dt*TMath::Exp(-a*dt)/w ;
+      }
+    }
+    fret += diff*diff ;
+  }
+  /*
+  if(nSamples){
+    fret/=nSamples ;
+    if(iflag == 2){
+      for(Int_t iparam = 0 ; iparam < 4 ; iparam++)    
+       Grad[iparam] /= nSamples ;
+    }
+  }
+  */
+  
+  
+}
+//-----------------------------------------------------------------------------
+Double_t AliPHOSRawDecoderv1::Gamma2(Double_t dt,Double_t p,Double_t en,Double_t a){
+  //Function for fitting samples
+  //parameters:
+  //p-pedestal
+  //en-amplutude
+  //a-decay time
+
+  if(dt<0.)
+    return p ; //pedestal
+  else
+    return p+en*dt*dt*TMath::Exp(-dt*a) ;
+}
+
diff --git a/PHOS/AliPHOSRawDecoderv1.h b/PHOS/AliPHOSRawDecoderv1.h
new file mode 100644 (file)
index 0000000..db17b26
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALIPHOSRAWDECODERV1_H
+#define ALIPHOSRAWDECODERV1_H
+/* Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                          */
+
+/* $Id$ */
+
+// This class extracts the PHOS "digits" of current event
+// (amplitude,time, position,gain) from the raw stream 
+// provided by AliRawReader. See cxx source for use case.
+
+#include "AliRawReader.h"
+#include "AliCaloRawStream.h"
+#include "AliPHOSRawDecoder.h"
+
+
+class AliPHOSRawDecoderv1 : public AliPHOSRawDecoder {
+
+public:
+
+  AliPHOSRawDecoderv1();
+  AliPHOSRawDecoderv1(AliRawReader* rawReader, AliAltroMapping **mapping = NULL);
+  AliPHOSRawDecoderv1(const AliPHOSRawDecoderv1& rawDecoder);
+  AliPHOSRawDecoderv1& operator = (const AliPHOSRawDecoderv1& rawDecoder);
+  virtual ~AliPHOSRawDecoderv1();
+
+  virtual Bool_t NextDigit();
+
+  static Double_t Gamma2(Double_t dt,Double_t p,Double_t en,Double_t a) ; // Shape of correct sample
+                                                 //class member function (not object member function)
+  static void UnfoldingChiSquare(Int_t & nPar, Double_t * Grad, Double_t & fret, Double_t * x, Int_t iflag)  ;
+                                            // Chi^2 of the fit. Should be static to be passed to MINUIT
+private:
+  
+  ClassDef(AliPHOSRawDecoderv1,1)
+};
+
+#endif
index 7a7a85b..582b539 100644 (file)
@@ -93,9 +93,10 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawDecoder*
     else {
       if (decoder->GetEnergy() >= 1023) continue;
       for (iOldDigit=iDigit-1; iOldDigit>=0; iOldDigit--) {
-        if ((dynamic_cast<AliPHOSDigit*>(digits->At(iOldDigit)))->GetId() == absId) {
-          digits->RemoveAt(iOldDigit);
-          new((*digits)[iOldDigit]) AliPHOSDigit(-1,absId,(Float_t)decoder->GetEnergy(),time);
+       AliPHOSDigit * dig = dynamic_cast<AliPHOSDigit*>(digits->At(iOldDigit)) ;
+        if (dig->GetId() == absId) {
+         dig->SetEnergy((Float_t)decoder->GetEnergy()) ;
+         dig->SetTime(time) ;
           seen = kTRUE;
           break;
         }
@@ -105,7 +106,7 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, AliPHOSRawDecoder*
         iDigit++;
       }
     }
-
+    
   }
 
   digits->Compress();
index aefa5e3..3862fe7 100644 (file)
@@ -27,7 +27,7 @@ ClassImp(AliPHOSRecoParam)
 //-----------------------------------------------------------------------------
 AliPHOSRecoParam::AliPHOSRecoParam() : TNamed(),
   fClusteringThreshold(9999),fLocMaxCut(9999),fMinE(9999),fW0(9999),
-  fSubtractPedestals(kTRUE)
+  fSubtractPedestals(kTRUE),fDecoderVersion("")
 {
   //Default constructor.
 }
@@ -36,7 +36,7 @@ AliPHOSRecoParam::AliPHOSRecoParam() : TNamed(),
 AliPHOSRecoParam::AliPHOSRecoParam(const AliPHOSRecoParam& recoParam):
   TNamed(recoParam),fClusteringThreshold(recoParam.fClusteringThreshold),
   fLocMaxCut(recoParam.fLocMaxCut),fMinE(recoParam.fMinE),fW0(recoParam.fW0),
-  fSubtractPedestals(recoParam.fSubtractPedestals)
+  fSubtractPedestals(recoParam.fSubtractPedestals),fDecoderVersion(recoParam.fDecoderVersion)
 {
   //Copy constructor.
 }
@@ -52,6 +52,7 @@ AliPHOSRecoParam& AliPHOSRecoParam::operator = (const AliPHOSRecoParam& recoPara
     fMinE = recoParam.fMinE;
     fW0 = recoParam.fW0;
     fSubtractPedestals = recoParam.fSubtractPedestals;
+    fDecoderVersion=recoParam.fDecoderVersion ;
   }
 
   return *this;
index 50d62b4..156d72d 100644 (file)
@@ -25,12 +25,14 @@ public:
   Float_t GetMinE() const { return fMinE; }
   Float_t GetLogWeight() const { return fW0; }
   Bool_t  SubtractPedestals() const { return fSubtractPedestals; }
+  const char* DecoderVersion()const{ return fDecoderVersion.Data() ; }
 
   void SetClusteringThreshold(Float_t cluth) { fClusteringThreshold=cluth; }
   void SetLocalMaxCut(Float_t cut) { fLocMaxCut=cut;}
   void SetMinE(Float_t minE) { fMinE=minE; }
   void SetLogWeight(Float_t w) { fW0=w; }
   void SetSubtractPedestals(Bool_t subtract) { fSubtractPedestals=subtract; } 
+  void SetDecoderVersion(const char* version="v1"){fDecoderVersion=version ;}
 
 protected:
 
@@ -39,6 +41,7 @@ protected:
   Float_t fMinE;
   Float_t fW0;
   Bool_t  fSubtractPedestals;
+  TString fDecoderVersion ;
 
   ClassDef(AliPHOSRecoParam,1)
 };
index fd687ea..9d06eb5 100644 (file)
@@ -45,6 +45,7 @@
 #include "AliPHOSEmcRecPoint.h"
 #include "AliPHOSRecParticle.h"
 #include "AliPHOSRawDecoder.h"
+#include "AliPHOSRawDecoderv1.h"
 #include "AliPHOSRawDigiProducer.h"
 #include "AliPHOSPulseGenerator.h"
 
@@ -123,7 +124,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   else 
     pid->TrackSegments2RecParticles("") ;
 
-       
+
   // This function creates AliESDtracks from AliPHOSRecParticles
   //         and
   // writes them to the ESD
@@ -136,7 +137,6 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
 
   AliDebug(2,Form("%d rec. particles, option %s",nOfRecParticles,GetOption()));
 
-
   //#########Calculate trigger and set trigger info###########
  
   AliPHOSTrigger tr ;
@@ -230,24 +230,32 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
       xyz[ixyz] = rp->GetPos()[ixyz];
     
     AliDebug(2,Form("Global position xyz=(%f,%f,%f)",xyz[0],xyz[1],xyz[2]));
-    
+   
     //Create digits lists
     Int_t  digitMult  = emcRP->GetDigitsMultiplicity();
     Int_t *digitsList = emcRP->GetDigitsList();
+    Float_t *rpElist   = emcRP->GetEnergiesList() ;
     Short_t *amplList  = new Short_t[digitMult];
     Short_t *timeList  = new Short_t[digitMult];
     Short_t *digiList  = new Short_t[digitMult];
 
+
     // Convert Float_t* and Int_t* to Short_t* to save memory
     for (Int_t iDigit=0; iDigit<digitMult; iDigit++) {
+
       AliPHOSDigit *digit = static_cast<AliPHOSDigit *>(fDigitsArr->At(digitsList[iDigit]));
       amplList[iDigit] =
-       (Short_t)(TMath::Min(digit->GetEnergy()*gev500,kBigShort)); // Energy in units of GeV/500
-      timeList[iDigit] =
-       (Short_t)(TMath::Min(digit->GetTime()*nsec100,kBigShort)); // time in units of 0.01 ns
+       (Short_t)(TMath::Min(rpElist[iDigit]*gev500,kBigShort)); // Energy in units of GeV/500
+// We should add here not full energy of digit, but unfolded one, stored in RecPoint
+//       amplList[iDigit] =
+//     (Short_t)(TMath::Min(digit->GetEnergy()*gev500,kBigShort)); // Energy in units of GeV/500
+     timeList[iDigit] =
+       (Short_t)(TMath::Max(-kBigShort,TMath::Min(digit->GetTime()*nsec100,kBigShort))); // time in units of 0.01 ns
       digiList[iDigit] = (Short_t)(digit->GetId());
     }
     
+
+
     //Primaries
     Int_t  primMult  = 0;
     Int_t *primInts =  emcRP->GetPrimaries(primMult);
@@ -265,7 +273,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     ec->SetM02(emcRP->GetM2x()) ;               //second moment M2x
     ec->SetM20(emcRP->GetM2z()) ;               //second moment M2z
     ec->SetNExMax(emcRP->GetNExMax());          //number of local maxima
-    ec->SetEmcCpvDistance(-1);                  //not yet implemented
+    ec->SetEmcCpvDistance(ts->GetCpvDistance("r"));                  //Only radius, what about separate x,z????
     ec->SetClusterChi2(-1);                     //not yet implemented
     ec->SetM11(-1) ;                            //not yet implemented
  
@@ -321,14 +329,20 @@ void  AliPHOSReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
 
   rawReader->Reset() ; 
 
-  AliPHOSRawDecoder dc(rawReader);
+  AliPHOSRawDecoder * dc ;
+
+  if(strcmp(fgkRecoParamEmc->DecoderVersion(),"v1")==0) 
+    dc=new AliPHOSRawDecoderv1(rawReader);
+  else
+    dc=new AliPHOSRawDecoder(rawReader);
+
   TString option = GetOption();
   if (option.Contains("OldRCUFormat"))
-    dc.SetOldRCUFormat(kTRUE);
+    dc->SetOldRCUFormat(kTRUE);
   else
-    dc.SetOldRCUFormat(kFALSE);
+    dc->SetOldRCUFormat(kFALSE);
   
-  dc.SubtractPedestals(fgkRecoParamEmc->SubtractPedestals());
+  dc->SubtractPedestals(fgkRecoParamEmc->SubtractPedestals());
   
   TClonesArray *digits = new TClonesArray("AliPHOSDigit",1);
   digits->SetName("DIGITS");
@@ -336,12 +350,23 @@ void  AliPHOSReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
   digitsTree->Branch("PHOS", &digits, bufsize);
 
   AliPHOSRawDigiProducer pr;
-  pr.MakeDigits(digits,&dc);
+  pr.MakeDigits(digits,dc);
+
+  delete dc ;
 
   //ADC counts -> GeV
-  for(Int_t i=0; i<digits->GetEntries(); i++) {
-    AliPHOSDigit* digit = (AliPHOSDigit*)digits->At(i);
-    digit->SetEnergy(digit->GetEnergy()/AliPHOSPulseGenerator::GeV2ADC());
+  if(strcmp(fgkRecoParamEmc->DecoderVersion(),"v1")==0){ //"Energy" calculated as fit
+    for(Int_t i=0; i<digits->GetEntries(); i++) {
+      AliPHOSDigit* digit = (AliPHOSDigit*)digits->At(i);
+      digit->SetEnergy(digit->GetEnergy()*0.005); //We assume here 5 MeV/ADC channel
+      digit->SetTime(digit->GetTime()*1.e-7) ;    //Here we assume sample step==100 ns TO BE FIXED!!!!!!!!!!!!!
+    }
+  }
+  else{ //Digits energy calculated as maximal energy
+    for(Int_t i=0; i<digits->GetEntries(); i++) {
+      AliPHOSDigit* digit = (AliPHOSDigit*)digits->At(i);
+      digit->SetEnergy(digit->GetEnergy()/AliPHOSPulseGenerator::GeV2ADC());
+    }
   }
   
   // Clean up digits below the noise threshold
index bf7ab0d..014f63b 100644 (file)
@@ -28,6 +28,7 @@
 #pragma link C++ class AliPHOSEmcCalibData+;
 #pragma link C++ class AliPHOSPulseGenerator+;
 #pragma link C++ class AliPHOSRawDecoder+;
+#pragma link C++ class AliPHOSRawDecoderv1+;
 #pragma link C++ class AliPHOSRawDigiProducer+;
 #pragma link C++ class AliPHOSEmcBadChannelsMap+;
 #pragma link C++ class AliPHOSSurvey+;
index 1f4204f..c1dc9fa 100644 (file)
@@ -15,6 +15,7 @@ SRCS          =  AliPHOS.cxx \
                  AliPHOSEmcCalibData.cxx \
                 AliPHOSPulseGenerator.cxx \
                 AliPHOSRawDecoder.cxx \
+                AliPHOSRawDecoderv1.cxx \
                 AliPHOSRawDigiProducer.cxx \
                 AliPHOSEmcBadChannelsMap.cxx \
                 AliPHOSSurvey.cxx \