Possibility to set offset in SZ runs
[u/mrichter/AliRoot.git] / PHOS / AliPHOSRawDecoder.cxx
1 /**************************************************************************
2  * Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved.      *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 // This class decodes the stream of ALTRO samples to extract
19 // the PHOS "digits" of current event.
20 // 
21 // Typical use case:
22 //     AliRawReader* rf = new AliRawReaderDate("2006run2211.raw");
23 //     AliPHOSRawDecoder dc(rf);
24 //     while (rf->NextEvent()) {
25 //       dc.SubtractPedestals(kTRUE);
26 //       while ( dc.NextDigit() ) {
27 //         Int_t module = dc.GetModule();
28 //         Int_t column = dc.GetColumn();
29 //         Int_t row = dc.GetRow();
30 //         Double_t amplitude = dc.GetEnergy();
31 //         Double_t time = dc.GetTime();
32 //         Bool_t IsLowGain = dc.IsLowGain();
33 //            ..........
34 //       }
35 //     }
36
37 // Author: Boris Polichtchouk
38
39 // --- ROOT system ---
40 #include "TArrayI.h"
41 #include "TMath.h"
42
43 // --- AliRoot header files ---
44 #include "AliPHOSRawDecoder.h"
45 #include "AliRawReader.h"
46
47 ClassImp(AliPHOSRawDecoder)
48
49 //-----------------------------------------------------------------------------
50 AliPHOSRawDecoder::AliPHOSRawDecoder():
51   fRawReader(0),fCaloStream(0),fPedSubtract(kFALSE),fEnergy(-111),fTime(-111),fQuality(0.),fPedestalRMS(0.),
52   fAmpOffset(0),fModule(-1),fColumn(-1),fRow(-1),fNewModule(-1),fNewColumn(-1),fNewRow(-1),fNewAmp(0),fNewTime(0), 
53   fLowGainFlag(kFALSE),fNewLowGainFlag(kFALSE),fOverflow(kFALSE),fSamples(0),fTimes(0)
54 {
55   //Default constructor.
56 }
57
58 //-----------------------------------------------------------------------------
59 AliPHOSRawDecoder::AliPHOSRawDecoder(AliRawReader* rawReader,  AliAltroMapping **mapping):
60   fRawReader(0),fCaloStream(0),fPedSubtract(kFALSE),fEnergy(-111),fTime(-111),fQuality(0.),fPedestalRMS(0.),
61   fAmpOffset(0),fModule(-1),fColumn(-1),fRow(-1),fNewModule(-1),fNewColumn(-1),fNewRow(-1),fNewAmp(0),fNewTime(0),
62   fLowGainFlag(kFALSE),fNewLowGainFlag(kFALSE),fOverflow(kFALSE),fSamples(0),fTimes(0)
63 {
64   //Construct a decoder object.
65   //Is is user responsibility to provide next raw event 
66   //using AliRawReader::NextEvent().
67
68   fRawReader =  rawReader;
69   fCaloStream = new AliCaloRawStream(rawReader,"PHOS",mapping);
70   fSamples = new TArrayI(100);
71   fTimes = new TArrayI(100);
72 }
73
74 //-----------------------------------------------------------------------------
75 AliPHOSRawDecoder::~AliPHOSRawDecoder()
76 {
77   //Destructor.
78
79   if(fCaloStream){ delete fCaloStream; fCaloStream=0;}
80   if(fSamples){ delete fSamples; fSamples=0 ;}
81   if(fTimes){ delete fTimes; fTimes=0 ;}
82 }
83
84 //-----------------------------------------------------------------------------
85 AliPHOSRawDecoder::AliPHOSRawDecoder(const AliPHOSRawDecoder &phosDecoder ):
86   fRawReader(phosDecoder.fRawReader),fCaloStream(phosDecoder.fCaloStream),
87   fPedSubtract(phosDecoder.fPedSubtract),
88   fEnergy(phosDecoder.fEnergy),fTime(phosDecoder.fTime),fQuality(phosDecoder.fQuality),fPedestalRMS(phosDecoder.fPedestalRMS),
89   fAmpOffset(phosDecoder.fAmpOffset),fModule(phosDecoder.fModule),fColumn(phosDecoder.fColumn),
90   fRow(phosDecoder.fRow),fNewModule(phosDecoder.fNewModule),fNewColumn(phosDecoder.fNewColumn),
91   fNewRow(phosDecoder.fNewRow),fNewAmp(phosDecoder.fNewAmp),fNewTime(phosDecoder.fNewTime),
92   fLowGainFlag(phosDecoder.fLowGainFlag),fNewLowGainFlag(phosDecoder.fNewLowGainFlag),
93   fOverflow(phosDecoder.fOverflow),fSamples(phosDecoder.fSamples),
94   fTimes(phosDecoder.fTimes)
95 {
96   //Copy constructor.
97 }
98
99 //-----------------------------------------------------------------------------
100 AliPHOSRawDecoder& AliPHOSRawDecoder::operator = (const AliPHOSRawDecoder &phosDecode)
101 {
102   //Assignment operator.
103
104   if(this != &phosDecode) {
105     fRawReader = phosDecode.fRawReader;
106
107     if(fCaloStream) delete fCaloStream;
108     fCaloStream = phosDecode.fCaloStream;
109
110     fEnergy = phosDecode.fEnergy;
111     fTime = phosDecode.fTime;
112     fQuality = phosDecode.fQuality ;
113     fPedestalRMS = phosDecode.fPedestalRMS ;
114     fAmpOffset = phosDecode.fAmpOffset ;
115     fModule = phosDecode.fModule;
116     fColumn = phosDecode.fColumn;
117     fRow = phosDecode.fRow;
118     fNewModule = phosDecode.fNewModule;
119     fNewColumn = phosDecode.fNewColumn;
120     fNewRow = phosDecode.fNewRow;
121     fNewAmp = phosDecode.fNewAmp ;
122     fNewTime= phosDecode.fNewTime ;
123     fLowGainFlag = phosDecode.fLowGainFlag;
124     fNewLowGainFlag = phosDecode.fNewLowGainFlag;
125     fOverflow = phosDecode.fOverflow ;
126     
127     if(fSamples) delete fSamples;
128     fSamples = phosDecode.fSamples;
129
130     if(fTimes) delete fTimes;
131     fTimes = phosDecode.fTimes;
132   }
133
134   return *this;
135 }
136
137 //-----------------------------------------------------------------------------
138
139 Bool_t AliPHOSRawDecoder::NextDigit()
140 {
141   //Extract an energy deposited in the crystal,
142   //crystal' position (module,column,row),
143   //time and gain (high or low).
144   
145   AliCaloRawStream* in = fCaloStream;
146   
147   Int_t    iBin     = 0;
148   Int_t    mxSmps   = fSamples->GetSize();
149   Int_t    tLength  = 0;
150   fEnergy = -111;
151   Float_t pedMean = 0;
152   Float_t pedRMS = 0;
153   Int_t   nPed = 0;
154   Float_t baseLine = 1.0;
155   const Int_t kPreSamples = 10;
156   
157   fSamples->Reset();
158   while ( in->Next() ) { 
159
160      if(!tLength) {
161        tLength = in->GetTimeLength();
162        if(tLength>mxSmps) {
163          fSamples->Set(tLength);
164        }
165      }
166      
167      // Fit the full sample
168      if(in->IsNewHWAddress() && iBin>0) {
169        
170        iBin=0;
171        //First remember new sample
172        fNewLowGainFlag = in->IsLowGain();
173        fNewModule = in->GetModule()+1;
174        fNewRow    = in->GetRow()   +1;
175        fNewColumn = in->GetColumn()+1;
176        fNewAmp = in->GetSignal() ;
177        fNewTime=in->GetTime() ;                                                                                                                               
178        
179        // Temporarily we take the energy as a maximum amplitude
180        // and the pedestal from the 0th point (30 Aug 2006).
181        // Time is not evaluated for the moment (12.01.2007). 
182        // Take is as a first time bin multiplied by the sample tick time
183        
184        if(fPedSubtract) {
185          if (nPed > 0){
186            fPedestalRMS=(pedRMS-pedMean*pedMean/nPed)/nPed ;
187            if(fPedestalRMS > 0.) 
188             fPedestalRMS = TMath::Sqrt(fPedestalRMS) ;
189            fEnergy -= (Double_t)(pedMean/nPed); // pedestal subtraction
190          }
191          else
192            return kFALSE;
193        }
194        else{
195          fEnergy-=fAmpOffset ;
196        }
197        if (fEnergy < baseLine) fEnergy = 0;
198
199        return kTRUE;
200      }
201
202      fLowGainFlag = in->IsLowGain();
203 //     fTime =   in->GetTime();
204      fTime = 1;
205      fModule = in->GetModule()+1;
206      fRow    = in->GetRow()   +1;
207      fColumn = in->GetColumn()+1;
208
209     if(fLowGainFlag==fNewLowGainFlag && fModule==fNewModule &&
210        fRow==fNewRow && fColumn==fNewColumn ){
211        if(fNewAmp>fEnergy)  fEnergy = (Double_t)fNewAmp ;
212        fNewModule=-1 ;
213     } 
214
215      //Calculate pedestal if necessary
216      if(fPedSubtract && in->GetTime() < kPreSamples) {
217        pedMean += in->GetSignal();
218        pedRMS+=in->GetSignal()*in->GetSignal() ;
219        nPed++;
220      }
221      if((Double_t)in->GetSignal() > fEnergy) fEnergy = (Double_t)in->GetSignal();
222      iBin++ ;
223      
224    } // in.Next()
225    
226    return kFALSE;
227 }