TPCQAda.cxx.diff Change export to amore db. Updated after a given time interval.
[u/mrichter/AliRoot.git] / TPC / AliTPCCalibRaw.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 ////////////////////////////////////////////////////////////////////////////////////////
19 //                                                                                    //
20 //     Implementation of the TPC Raw drift velocity and Altro L1 Phase  calibration   //
21 //                                                                                    //
22 //               Origin: Jens Wiechula, J.Wiechula@gsi.de                             //
23 //                                                                                    //
24 ////////////////////////////////////////////////////////////////////////////////////////
25 //
26 //
27 // *************************************************************************************
28 // *                                Class Description                                  *
29 // *************************************************************************************
30 /*
31
32 ----example---
33 TFile f("CalibAltro.root");
34 AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
35 {
36 TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
37 if (!c1) c1=new TCanvas("c1","c1");
38 c1->Clear();
39
40 TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
41 Bool_t first=kTRUE;
42 Int_t i,iev;
43 for (i=0;i<216;++i) {
44   TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
45   if (!v) continue;
46   for (iev=0;iev<al->GetNevents();++iev) {
47     h2f->SetBinContent(i+1,iev+1,(*v)(iev));
48   }
49 //   TH1F h(*v);
50 //   h.SetLineColor(i/216.*50+50);
51 //   ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
52 //   c1->Modified();
53 //   c1->Update();
54   first=kFALSE;
55 }
56 h2f->Draw("col");
57 }
58
59 */
60
61
62
63 //Root includes
64 #include <TH2C.h>
65 #include <TMap.h>
66 #include <TObjString.h>
67
68 //AliRoot includes
69 #include "AliTPCCalROC.h"
70 #include "AliAltroRawStream.h"
71 #include "AliLog.h"
72 //class header
73 #include "AliTPCCalibRaw.h"
74
75 ClassImp(AliTPCCalibRaw)
76
77 AliTPCCalibRaw::AliTPCCalibRaw() :
78   AliTPCCalibRawBase(),
79   fPeakDetMinus(1),
80   fPeakDetPlus(2),
81   fNFailL1Phase(0),
82   fFirstTimeStamp(0),
83   fNSecTime(600), //default 10 minutes
84   fNBinsTime(60), //default 60*10 minutes = 10 hours
85   fPadProcessed(kFALSE),
86   fCurrentChannel(-1),
87   fCurrentSector(-1),
88   fLastSector(-2),
89   fCurrentRow(-1),
90   fCurrentPad(-1),
91   fLastTimeBinProc(0),
92   fPeakTimeBin(0),
93   fLastSignal(0),
94   fNOkPlus(0),
95   fNOkMinus(0),
96   fArrCurrentPhaseDist(4),
97   fArrALTROL1Phase(1000),
98   fArrALTROL1PhaseEvent(216),
99   fArrALTROL1PhaseFailEvent(216),
100   fHnDrift(0x0)
101 {
102   //
103   // Default ctor
104   //
105   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
106   CreateDVhist();
107   fFirstTimeBin=850;
108   fLastTimeBin=1020;
109 }
110 //_____________________________________________________________________
111 AliTPCCalibRaw::AliTPCCalibRaw(const TMap *config) :
112 AliTPCCalibRawBase(),
113 fPeakDetMinus(1),
114 fPeakDetPlus(2),
115 fNFailL1Phase(0),
116 fFirstTimeStamp(0),
117 fNSecTime(600), //default 10 minutes
118 fNBinsTime(60), //default 60*10 minutes = 10 hours
119 fPadProcessed(kFALSE),
120 fCurrentChannel(-1),
121 fCurrentSector(-1),
122 fLastSector(-2),
123 fCurrentRow(-1),
124 fCurrentPad(-1),
125 fLastTimeBinProc(0),
126 fPeakTimeBin(0),
127 fLastSignal(0),
128 fNOkPlus(0),
129 fNOkMinus(0),
130 fArrCurrentPhaseDist(4),
131 fArrALTROL1Phase(1000),
132 fArrALTROL1PhaseEvent(216),
133 fArrALTROL1PhaseFailEvent(216),
134 fHnDrift(0x0)
135 {
136   //
137   // Default ctor
138   //
139   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
140   CreateDVhist();
141   fFirstTimeBin=850;
142   fLastTimeBin=1020;
143   if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
144   if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
145 }
146
147 //_____________________________________________________________________
148 AliTPCCalibRaw::~AliTPCCalibRaw()
149 {
150   //
151   // dtor
152   //
153   delete fHnDrift;  
154 }
155 //_____________________________________________________________________
156 // AliTPCCalibRaw& AliTPCCalibRaw::operator = (const  AliTPCCalibRaw &source)
157 // {
158 //   //
159 //   // assignment operator
160 //   //
161 //   if (&source == this) return *this;
162 //   new (this) AliTPCCalibRaw(source);
163 //   
164 //   return *this;
165 // }
166
167 //_____________________________________________________________________
168 Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
169              const Int_t iTimeBin, const Float_t signal)
170 {
171   //
172   // Data filling method
173   //
174   if (iRow<0) return 0;
175   if (iPad<0) return 0;
176   if (iTimeBin<0) return 0;
177   if (!fFirstTimeStamp) fFirstTimeStamp=GetTimeStamp();
178   if ( (iTimeBin>fLastTimeBin) || (iTimeBin<fFirstTimeBin)   ) return 0;
179   //don't process edge pads
180   if (IsEdgePad(isector,iRow,iPad)) return 0;
181 //   Double_t x[kHnBinsDV]={1,isector,0};
182 //   fHnDrift->Fill(x);
183   Int_t iChannel  = fROC->GetRowIndexes(isector)[iRow]+iPad; //  global pad position in sector
184   if (fCurrentChannel==iChannel){
185     if (fPadProcessed) return 0;
186   } else {
187     fPadProcessed=kFALSE;
188     fNOkPlus=0;
189     fNOkMinus=0;
190     fPeakTimeBin=0;
191     fLastSignal=0;
192   }
193 //   Double_t x2[kHnBinsDV]={2,isector,0};
194 //   fHnDrift->Fill(x2);
195   
196
197   if (signal>fLastSignal) ++fNOkPlus;
198   else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){
199     ++fNOkMinus;
200     if (!fPeakTimeBin) fPeakTimeBin=fLastTimeBinProc;
201     if ( fNOkMinus>=fPeakDetMinus ) {
202       Double_t x[kHnBinsDV]={fPeakTimeBin,isector,(fTimeStamp-fFirstTimeStamp)/fNSecTime};
203       fHnDrift->Fill(x);
204     } 
205   } else {
206     fNOkPlus=0;
207     fNOkMinus=0;
208     fPeakTimeBin=0;
209     fLastSignal=0;
210   }
211
212   fLastTimeBinProc=iTimeBin;
213   fLastSignal=TMath::Nint(signal);
214   fCurrentChannel = iChannel;
215   return 0;
216 }
217 //_____________________________________________________________________
218 void AliTPCCalibRaw::UpdateDDL(){
219   //
220   // fill ALTRO L1 information
221   //
222 //   if (fCurrDDLNum!=fPrevDDLNum){
223     TVectorF *arr=MakeArrL1PhaseRCU(fCurrDDLNum,kTRUE);
224     if (arr->GetNrows()<=fNevents) arr->ResizeTo(arr->GetNrows()+1000);
225     // phase as a position of a quarter time bin
226     Int_t phase=(Int_t)(GetL1PhaseTB()*4.);
227 //     printf("DDL: %03d, phase: %d (%f))\n",fCurrDDLNum,phase,GetL1PhaseTB());
228     //Fill pahse information of current rcu and event
229     (arr->GetMatrixArray())[fNevents]=phase;
230     //increase phase counter
231     ++((fArrCurrentPhaseDist.GetMatrixArray())[phase]);
232 //     printf("RCUId: %03d (%03d), DDL: %03d, sector: %02d\n",fCurrRCUId, fPrevRCUId, fCurrDDLNum, isector);
233 //   }
234   
235 }
236 //_____________________________________________________________________
237 void AliTPCCalibRaw::ResetEvent()
238 {
239   //
240   // Reset event counters
241   //
242
243   fCurrentChannel=-1;
244   fArrCurrentPhaseDist.Zero();
245 }
246 //_____________________________________________________________________
247 void AliTPCCalibRaw::EndEvent()
248 {
249   //
250   // End event analysis
251   //
252
253   
254   //find phase of the current event
255   Int_t phaseMaxEntries=-1;
256   Int_t maxEntries=0;
257   for (Int_t i=0;i<fArrCurrentPhaseDist.GetNrows();++i){
258     Int_t entries=(Int_t)fArrCurrentPhaseDist[i];
259     if (maxEntries<entries) {
260       maxEntries=entries;
261       phaseMaxEntries=i;
262     }
263   }
264   // store phase of current event
265   if (fArrALTROL1Phase.GetNrows()<=GetNevents())
266     fArrALTROL1Phase.ResizeTo(GetNevents()+1000);
267   (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
268   
269   //loop over RCUs and test failures
270   for (Int_t ircu=0;ircu<216;++ircu){
271     const TVectorF *arr=GetALTROL1PhaseEventsRCU(ircu);//MakeArrL1PhaseRCU(ircu);
272     if (!arr) continue;
273     TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu,kTRUE);
274     if (arrF->GetNrows()<=fNevents) arrF->ResizeTo(arrF->GetNrows()+1000);
275     if ((arr->GetMatrixArray())[fNevents]!=phaseMaxEntries){
276       (arrF->GetMatrixArray())[fNevents]=1;
277       ++fNFailL1Phase;
278       }
279   }
280   IncrementNevents();
281 }
282 //_____________________________________________________________________
283 TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
284 {
285   // Create a 2D histo RCU:Events indicating the there was a deviation
286   // from the mean L1 phase of the event
287   //
288   //type: 0=Failures, 1=Phases
289   TH2C *h2 = new TH2C("hL1FailRCUEvents","L1 Failures;RCU;Event",216,0,216,GetNevents(),0,GetNevents());
290   Int_t add=0;
291   for (Int_t ircu=0;ircu<216;++ircu) {
292     const TVectorF *v=0;
293     if (type==0){
294       v=GetALTROL1PhaseFailEventsRCU(ircu);
295       add=1;
296       h2->SetMinimum(0);
297       h2->SetMaximum(2);
298     } else if (type==1) {
299       v=GetALTROL1PhaseEventsRCU(ircu);
300       add=0;
301       h2->SetMinimum(0);
302       h2->SetMaximum(4);
303     }
304     if (!v) continue;
305     for (Int_t iev=0;iev<GetNevents();++iev) {
306       h2->SetBinContent(ircu+1,iev+1,(*v)(iev)+add);
307     }
308   }
309   return h2;
310 }
311 //_____________________________________________________________________
312 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
313 {
314   //
315   // Create a 2D histo RCU:Events indicating the there was a deviation
316   // from the mean L1 phase of the event
317   //
318   TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents());
319   for (Int_t ircu=0;ircu<72;++ircu) {
320     const TVectorF *v=0;
321     if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
322     else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
323     if (!v) continue;
324     for (Int_t iev=0;iev<GetNevents();++iev) {
325       h2->SetBinContent(ircu+1,iev+1,(*v)(iev));
326     }
327   }
328   return h2;
329 }
330 //_____________________________________________________________________
331 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
332 {
333   //
334   // Create a 2D histo RCU:Events indicating the there was a deviation
335   // from the mean L1 phase of the event
336   //
337   TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents());
338   for (Int_t ircu=72;ircu<216;++ircu) {
339     const TVectorF *v=0;
340     if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
341     else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
342     if (!v) continue;
343     for (Int_t iev=0;iev<GetNevents();++iev) {
344       h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev));
345     }
346   }
347   return h2;
348 }
349 //_____________________________________________________________________
350 void AliTPCCalibRaw::CreateDVhist()
351 {
352   //
353   // Setup the HnSparse for the drift velocity determination
354   //
355   if (fHnDrift) return;
356   //HnSparse bins
357   //time bin, roc, time
358   Int_t    bins[kHnBinsDV] = {fLastTimeBin-fFirstTimeBin, 72, fNBinsTime};
359   Double_t xmin[kHnBinsDV] = {fFirstTimeBin,0,0};
360   Double_t xmax[kHnBinsDV] = {fLastTimeBin,72,fNBinsTime};
361   fHnDrift=new THnSparseI("fHnDrift",Form("Drift velocity using last time bin;time bin[#times 100ns];ROC;Time bin [#times %us]",fNSecTime),kHnBinsDV, bins, xmin, xmax);
362     
363 }
364 //_____________________________________________________________________
365 void AliTPCCalibRaw::Analyse()
366 {
367   //
368   // Analyse Data
369   //
370
371   //resize arrays
372   fArrALTROL1Phase.ResizeTo(GetNevents());
373   for (Int_t ircu=0;ircu<216;++ircu){
374     TVectorF *arr=MakeArrL1PhaseRCU(ircu);//MakeArrL1PhaseRCU(ircu);
375     if (!arr) continue;
376     TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu);
377     arr->ResizeTo(GetNevents());
378     arrF->ResizeTo(GetNevents());
379   }
380
381   //Analyse drift velocity
382   
383 }
384