]>
Commit | Line | Data |
---|---|---|
ddeb9c4f | 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 | |
1d32f273 | 64 | #include <TROOT.h> |
ddeb9c4f | 65 | #include <TH2C.h> |
be3dbaa0 | 66 | #include <TH1F.h> |
f113dfeb | 67 | #include <TMap.h> |
1d32f273 | 68 | #include <TGraph.h> |
f113dfeb | 69 | #include <TObjString.h> |
1d32f273 | 70 | #include <TTimeStamp.h> |
71 | #include <TCanvas.h> | |
ddeb9c4f | 72 | //AliRoot includes |
73 | #include "AliTPCCalROC.h" | |
74 | #include "AliAltroRawStream.h" | |
75 | #include "AliLog.h" | |
ddeb9c4f | 76 | //class header |
77 | #include "AliTPCCalibRaw.h" | |
78 | ||
79 | ClassImp(AliTPCCalibRaw) | |
80 | ||
81 | AliTPCCalibRaw::AliTPCCalibRaw() : | |
82 | AliTPCCalibRawBase(), | |
83 | fPeakDetMinus(1), | |
84 | fPeakDetPlus(2), | |
85 | fNFailL1Phase(0), | |
be3dbaa0 | 86 | fNFailL1PhaseEvent(0), |
ddeb9c4f | 87 | fFirstTimeStamp(0), |
88 | fNSecTime(600), //default 10 minutes | |
89 | fNBinsTime(60), //default 60*10 minutes = 10 hours | |
90 | fPadProcessed(kFALSE), | |
91 | fCurrentChannel(-1), | |
92 | fCurrentSector(-1), | |
93 | fLastSector(-2), | |
94 | fCurrentRow(-1), | |
95 | fCurrentPad(-1), | |
96 | fLastTimeBinProc(0), | |
97 | fPeakTimeBin(0), | |
98 | fLastSignal(0), | |
99 | fNOkPlus(0), | |
100 | fNOkMinus(0), | |
1d32f273 | 101 | fNanoSec(0), |
ddeb9c4f | 102 | fArrCurrentPhaseDist(4), |
be3dbaa0 | 103 | fArrCurrentPhase(kNRCU), |
104 | fArrFailEventNumber(100), | |
1d32f273 | 105 | fArrALTROL1Phase(100000), |
be3dbaa0 | 106 | fArrALTROL1PhaseEvent(kNRCU), |
107 | fArrALTROL1PhaseFailEvent(kNRCU), | |
1d32f273 | 108 | fHnDrift(0x0), |
109 | fVOccupancyEvent(100000), | |
110 | fVSignalSumEvent(100000), | |
111 | fVOccupancySenEvent(100000), | |
112 | fVSignalSumSenEvent(100000), | |
113 | fVNfiredPadsSenEvent(100000), | |
114 | fVTimeStampEvent(100000) | |
ddeb9c4f | 115 | { |
116 | // | |
117 | // Default ctor | |
118 | // | |
119 | SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw"); | |
120 | CreateDVhist(); | |
be3dbaa0 | 121 | for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1; |
ddeb9c4f | 122 | fFirstTimeBin=850; |
f113dfeb | 123 | fLastTimeBin=1020; |
ddeb9c4f | 124 | } |
f113dfeb | 125 | //_____________________________________________________________________ |
126 | AliTPCCalibRaw::AliTPCCalibRaw(const TMap *config) : | |
127 | AliTPCCalibRawBase(), | |
128 | fPeakDetMinus(1), | |
129 | fPeakDetPlus(2), | |
130 | fNFailL1Phase(0), | |
be3dbaa0 | 131 | fNFailL1PhaseEvent(0), |
f113dfeb | 132 | fFirstTimeStamp(0), |
133 | fNSecTime(600), //default 10 minutes | |
134 | fNBinsTime(60), //default 60*10 minutes = 10 hours | |
135 | fPadProcessed(kFALSE), | |
136 | fCurrentChannel(-1), | |
137 | fCurrentSector(-1), | |
138 | fLastSector(-2), | |
139 | fCurrentRow(-1), | |
140 | fCurrentPad(-1), | |
141 | fLastTimeBinProc(0), | |
142 | fPeakTimeBin(0), | |
143 | fLastSignal(0), | |
144 | fNOkPlus(0), | |
145 | fNOkMinus(0), | |
1d32f273 | 146 | fNanoSec(0), |
f113dfeb | 147 | fArrCurrentPhaseDist(4), |
be3dbaa0 | 148 | fArrCurrentPhase(kNRCU), |
149 | fArrFailEventNumber(100), | |
1d32f273 | 150 | fArrALTROL1Phase(100000), |
be3dbaa0 | 151 | fArrALTROL1PhaseEvent(kNRCU), |
152 | fArrALTROL1PhaseFailEvent(kNRCU), | |
1d32f273 | 153 | fHnDrift(0x0), |
154 | fVOccupancyEvent(100000), | |
155 | fVSignalSumEvent(100000), | |
156 | fVOccupancySenEvent(100000), | |
157 | fVSignalSumSenEvent(100000), | |
158 | fVNfiredPadsSenEvent(100000), | |
159 | fVTimeStampEvent(100000) | |
f113dfeb | 160 | { |
161 | // | |
162 | // Default ctor | |
163 | // | |
164 | SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw"); | |
165 | CreateDVhist(); | |
be3dbaa0 | 166 | for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1; |
f113dfeb | 167 | fFirstTimeBin=850; |
168 | fLastTimeBin=1020; | |
169 | if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi(); | |
170 | if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi(); | |
cc65e4f5 | 171 | if (config->GetValue("DebugLevel")) fDebugLevel = ((TObjString*)config->GetValue("DebugLevel"))->GetString().Atoi(); |
f113dfeb | 172 | } |
173 | ||
ddeb9c4f | 174 | //_____________________________________________________________________ |
175 | AliTPCCalibRaw::~AliTPCCalibRaw() | |
176 | { | |
177 | // | |
178 | // dtor | |
179 | // | |
180 | delete fHnDrift; | |
181 | } | |
182 | //_____________________________________________________________________ | |
183 | // AliTPCCalibRaw& AliTPCCalibRaw::operator = (const AliTPCCalibRaw &source) | |
184 | // { | |
185 | // // | |
186 | // // assignment operator | |
187 | // // | |
188 | // if (&source == this) return *this; | |
189 | // new (this) AliTPCCalibRaw(source); | |
190 | // | |
191 | // return *this; | |
192 | // } | |
193 | ||
194 | //_____________________________________________________________________ | |
195 | Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad, | |
196 | const Int_t iTimeBin, const Float_t signal) | |
197 | { | |
198 | // | |
199 | // Data filling method | |
200 | // | |
201 | if (iRow<0) return 0; | |
202 | if (iPad<0) return 0; | |
203 | if (iTimeBin<0) return 0; | |
204 | if (!fFirstTimeStamp) fFirstTimeStamp=GetTimeStamp(); | |
1d32f273 | 205 | // |
206 | Int_t iChannel = fROC->GetRowIndexes(isector)[iRow]+iPad; // global pad position in sector | |
207 | //occupancy | |
208 | fVOccupancyEvent.GetMatrixArray()[GetNevents()]++; | |
209 | fVSignalSumEvent.GetMatrixArray()[GetNevents()]+=signal; | |
210 | //occupancy in sensitive regions | |
211 | Int_t npads=(Int_t)fROC->GetNPads(isector,iRow); | |
212 | Int_t cpad=iPad-npads/2; | |
213 | if (isector<(Int_t)fROC->GetNInnerSector()){ | |
214 | //IROC case (spot) | |
215 | if ( iRow>19 && iRow<46 ){ | |
216 | if ( TMath::Abs(cpad)<7 ){ | |
217 | fVOccupancySenEvent.GetMatrixArray()[GetNevents()]++; | |
218 | fVSignalSumSenEvent.GetMatrixArray()[GetNevents()]+=signal; | |
219 | if (iChannel!=fCurrentChannel) fVNfiredPadsSenEvent.GetMatrixArray()[GetNevents()]++; | |
220 | } | |
221 | } | |
222 | } else if ( iRow>75 ){ | |
223 | //OROC case (outer corners and last three rows are sensitive) | |
224 | Int_t padEdge=(Int_t)TMath::Min(iPad,npads-iPad); | |
225 | Int_t nrows=(Int_t)fROC->GetNRows(isector); | |
226 | if ((nrows-iRow-1)<3 || padEdge<((((Int_t)iRow-76)/4+1))*2){ | |
227 | fVOccupancySenEvent.GetMatrixArray()[GetNevents()]++; | |
228 | fVSignalSumSenEvent.GetMatrixArray()[GetNevents()]+=signal; | |
229 | if (iChannel!=fCurrentChannel) fVNfiredPadsSenEvent.GetMatrixArray()[GetNevents()]++; | |
230 | } | |
231 | } | |
232 | // | |
ddeb9c4f | 233 | if ( (iTimeBin>fLastTimeBin) || (iTimeBin<fFirstTimeBin) ) return 0; |
234 | //don't process edge pads | |
235 | if (IsEdgePad(isector,iRow,iPad)) return 0; | |
236 | // Double_t x[kHnBinsDV]={1,isector,0}; | |
237 | // fHnDrift->Fill(x); | |
ddeb9c4f | 238 | if (fCurrentChannel==iChannel){ |
239 | if (fPadProcessed) return 0; | |
240 | } else { | |
241 | fPadProcessed=kFALSE; | |
242 | fNOkPlus=0; | |
243 | fNOkMinus=0; | |
244 | fPeakTimeBin=0; | |
245 | fLastSignal=0; | |
246 | } | |
247 | // Double_t x2[kHnBinsDV]={2,isector,0}; | |
248 | // fHnDrift->Fill(x2); | |
249 | ||
250 | ||
251 | if (signal>fLastSignal) ++fNOkPlus; | |
252 | else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){ | |
253 | ++fNOkMinus; | |
254 | if (!fPeakTimeBin) fPeakTimeBin=fLastTimeBinProc; | |
255 | if ( fNOkMinus>=fPeakDetMinus ) { | |
256 | Double_t x[kHnBinsDV]={fPeakTimeBin,isector,(fTimeStamp-fFirstTimeStamp)/fNSecTime}; | |
257 | fHnDrift->Fill(x); | |
258 | } | |
259 | } else { | |
260 | fNOkPlus=0; | |
261 | fNOkMinus=0; | |
262 | fPeakTimeBin=0; | |
263 | fLastSignal=0; | |
264 | } | |
265 | ||
266 | fLastTimeBinProc=iTimeBin; | |
267 | fLastSignal=TMath::Nint(signal); | |
268 | fCurrentChannel = iChannel; | |
269 | return 0; | |
5312f439 | 270 | } |
271 | //_____________________________________________________________________ | |
272 | void AliTPCCalibRaw::UpdateDDL(){ | |
273 | // | |
274 | // fill ALTRO L1 information | |
275 | // | |
be3dbaa0 | 276 | |
1d32f273 | 277 | //set nanoseconds |
278 | if (!fNanoSec) { | |
279 | TTimeStamp s; | |
280 | fNanoSec=s.GetNanoSec(); | |
281 | } | |
be3dbaa0 | 282 | // current phase |
283 | Int_t phase=(Int_t)(GetL1PhaseTB()*4.); | |
284 | //Fill pahse information of current rcu and event | |
285 | fArrCurrentPhase.GetMatrixArray()[fCurrDDLNum]=phase; | |
286 | //increase phase counter | |
287 | ++((fArrCurrentPhaseDist.GetMatrixArray())[phase]); | |
5312f439 | 288 | |
ddeb9c4f | 289 | } |
290 | //_____________________________________________________________________ | |
291 | void AliTPCCalibRaw::ResetEvent() | |
292 | { | |
293 | // | |
294 | // Reset event counters | |
295 | // | |
296 | ||
297 | fCurrentChannel=-1; | |
1d32f273 | 298 | fCurrentRow=-1; |
299 | fCurrentPad=-1; | |
ddeb9c4f | 300 | fArrCurrentPhaseDist.Zero(); |
301 | } | |
302 | //_____________________________________________________________________ | |
303 | void AliTPCCalibRaw::EndEvent() | |
304 | { | |
305 | // | |
306 | // End event analysis | |
307 | // | |
308 | ||
309 | ||
310 | //find phase of the current event | |
311 | Int_t phaseMaxEntries=-1; | |
312 | Int_t maxEntries=0; | |
313 | for (Int_t i=0;i<fArrCurrentPhaseDist.GetNrows();++i){ | |
314 | Int_t entries=(Int_t)fArrCurrentPhaseDist[i]; | |
315 | if (maxEntries<entries) { | |
316 | maxEntries=entries; | |
317 | phaseMaxEntries=i; | |
318 | } | |
319 | } | |
320 | // store phase of current event | |
cc65e4f5 | 321 | if (fArrALTROL1Phase.GetNrows()-1<=GetNevents()) |
1d32f273 | 322 | fArrALTROL1Phase.ResizeTo(GetNevents()+10000); |
ddeb9c4f | 323 | (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries; |
324 | ||
325 | //loop over RCUs and test failures | |
be3dbaa0 | 326 | UInt_t fail=0; |
327 | for (Int_t ircu=0;ircu<kNRCU;++ircu){ | |
328 | Int_t phase=(Int_t)fArrCurrentPhase[ircu]; | |
329 | if (phase<0) continue; | |
330 | if (phase!=phaseMaxEntries){ | |
331 | TVectorF *arr=MakeArrL1PhaseRCU(fCurrDDLNum,kTRUE); | |
cc65e4f5 | 332 | if (arr->GetNrows()-1<=(Int_t)fNFailL1PhaseEvent) arr->ResizeTo(arr->GetNrows()+100); |
be3dbaa0 | 333 | (arr->GetMatrixArray())[fNFailL1PhaseEvent]=phase; |
ddeb9c4f | 334 | ++fNFailL1Phase; |
be3dbaa0 | 335 | fail=1; |
ddeb9c4f | 336 | } |
be3dbaa0 | 337 | //reset current phase information |
338 | fArrCurrentPhase[ircu]=-1; | |
339 | } | |
340 | if (fail){ | |
cc65e4f5 | 341 | if (fArrFailEventNumber.GetNrows()-1<=(Int_t)fNFailL1PhaseEvent) fArrFailEventNumber.ResizeTo(fArrFailEventNumber.GetNrows()+100); |
be3dbaa0 | 342 | fArrFailEventNumber.GetMatrixArray()[fNFailL1PhaseEvent]=GetNevents(); |
ddeb9c4f | 343 | } |
be3dbaa0 | 344 | fNFailL1PhaseEvent+=fail; |
1d32f273 | 345 | //time stamps |
346 | fVTimeStampEvent.GetMatrixArray()[GetNevents()]=GetTimeStamp()-fFirstTimeStamp+fNanoSec*1e-9; | |
347 | fNanoSec=0; | |
348 | //occupance related | |
cc65e4f5 | 349 | if (fVOccupancyEvent.GetNrows()-1<=GetNevents()){ |
1d32f273 | 350 | fVOccupancyEvent.ResizeTo(GetNevents()+10000); |
351 | fVSignalSumEvent.ResizeTo(GetNevents()+10000); | |
352 | fVOccupancySenEvent.ResizeTo(GetNevents()+10000); | |
353 | fVSignalSumSenEvent.ResizeTo(GetNevents()+10000); | |
354 | fVTimeStampEvent.ResizeTo(GetNevents()+10000); | |
355 | fVNfiredPadsSenEvent.ResizeTo(GetNevents()+10000); | |
356 | } | |
ddeb9c4f | 357 | IncrementNevents(); |
358 | } | |
359 | //_____________________________________________________________________ | |
360 | TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type) | |
361 | { | |
362 | // Create a 2D histo RCU:Events indicating the there was a deviation | |
363 | // from the mean L1 phase of the event | |
364 | // | |
365 | //type: 0=Failures, 1=Phases | |
be3dbaa0 | 366 | |
367 | //number of relavant events, depending on version | |
368 | Int_t nevents=GetNevents(); | |
369 | //check version | |
370 | Bool_t newVersion=kFALSE; | |
371 | for (Int_t ircu=0; ircu<kNRCU; ++ircu){ | |
372 | const TVectorF *v=GetALTROL1PhaseEventsRCU(ircu); | |
373 | if (!v) continue; | |
7390f655 | 374 | if ((UInt_t)(v->GetNrows())==fNFailL1PhaseEvent){ |
be3dbaa0 | 375 | newVersion=kTRUE; |
376 | nevents=fNFailL1PhaseEvent; | |
377 | } | |
378 | break; | |
379 | } | |
380 | TH2C *h2 = new TH2C("hL1FailRCUEvents","L1 Failures;RCU;Event",kNRCU,0,kNRCU,nevents,0,nevents); | |
5312f439 | 381 | Int_t add=0; |
be3dbaa0 | 382 | for (Int_t ircu=0;ircu<kNRCU;++ircu) { |
383 | const TVectorF *v=GetALTROL1PhaseEventsRCU(ircu); | |
5312f439 | 384 | if (type==0){ |
5312f439 | 385 | add=1; |
386 | h2->SetMinimum(0); | |
387 | h2->SetMaximum(2); | |
388 | } else if (type==1) { | |
5312f439 | 389 | add=0; |
390 | h2->SetMinimum(0); | |
391 | h2->SetMaximum(4); | |
392 | } | |
ddeb9c4f | 393 | if (!v) continue; |
be3dbaa0 | 394 | for (Int_t iev=0;iev<nevents;++iev) { |
395 | Float_t val=(*v)(iev); | |
396 | Float_t phase=fArrALTROL1Phase.GetMatrixArray()[iev]; | |
397 | if (newVersion) { | |
398 | Int_t event=(Int_t)fArrFailEventNumber.GetMatrixArray()[iev]; | |
399 | phase=fArrALTROL1Phase.GetMatrixArray()[event]; | |
400 | } | |
401 | if (type==0) val=(val!=phase); | |
402 | h2->SetBinContent(ircu+1,iev+1,val+add); | |
ddeb9c4f | 403 | } |
404 | } | |
405 | return h2; | |
406 | } | |
407 | //_____________________________________________________________________ | |
be3dbaa0 | 408 | TH1F *AliTPCCalibRaw::MakeHistL1PhaseDist() |
409 | { | |
410 | // | |
411 | // L1 phase distribution. Should be flat in ideal case | |
412 | // | |
413 | TH1F *h=new TH1F("L1phaseDist","Normalized L1 phase distribution;phase;fraction of events",4,0,4); | |
414 | h->Sumw2(); | |
415 | for (Int_t iev=0;iev<GetNevents();++iev) h->Fill(fArrALTROL1Phase.GetMatrixArray()[iev]); | |
416 | if (GetNevents()>0) h->Scale(1./GetNevents()); | |
417 | h->SetMinimum(0); | |
418 | h->SetMaximum(1); | |
419 | return h; | |
420 | } | |
421 | //_____________________________________________________________________ | |
422 | TVectorF *AliTPCCalibRaw::MakeVectL1PhaseDist() | |
423 | { | |
424 | // | |
425 | // L1 phase distribution. Should be flat in ideal case | |
426 | // | |
427 | TVectorF *v=new TVectorF(4); | |
428 | for (Int_t iev=0;iev<GetNevents();++iev) { | |
429 | Int_t phase=(Int_t)fArrALTROL1Phase.GetMatrixArray()[iev]; | |
430 | ((v->GetMatrixArray())[phase])+=1./GetNevents(); | |
431 | } | |
432 | return v; | |
433 | } | |
434 | //_____________________________________________________________________ | |
ddeb9c4f | 435 | TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type) |
436 | { | |
437 | // | |
438 | // Create a 2D histo RCU:Events indicating the there was a deviation | |
439 | // from the mean L1 phase of the event | |
440 | // | |
441 | TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents()); | |
442 | for (Int_t ircu=0;ircu<72;++ircu) { | |
443 | const TVectorF *v=0; | |
444 | if (type==0) v=GetALTROL1PhaseFailEventsRCU(ircu); | |
445 | else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu); | |
446 | if (!v) continue; | |
447 | for (Int_t iev=0;iev<GetNevents();++iev) { | |
5312f439 | 448 | h2->SetBinContent(ircu+1,iev+1,(*v)(iev)); |
ddeb9c4f | 449 | } |
450 | } | |
451 | return h2; | |
452 | } | |
453 | //_____________________________________________________________________ | |
454 | TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type) | |
455 | { | |
456 | // | |
457 | // Create a 2D histo RCU:Events indicating the there was a deviation | |
458 | // from the mean L1 phase of the event | |
459 | // | |
460 | TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents()); | |
be3dbaa0 | 461 | for (Int_t ircu=72;ircu<kNRCU;++ircu) { |
ddeb9c4f | 462 | const TVectorF *v=0; |
463 | if (type==0) v=GetALTROL1PhaseFailEventsRCU(ircu); | |
464 | else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu); | |
465 | if (!v) continue; | |
466 | for (Int_t iev=0;iev<GetNevents();++iev) { | |
5312f439 | 467 | h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev)); |
ddeb9c4f | 468 | } |
469 | } | |
470 | return h2; | |
471 | } | |
472 | //_____________________________________________________________________ | |
473 | void AliTPCCalibRaw::CreateDVhist() | |
474 | { | |
475 | // | |
476 | // Setup the HnSparse for the drift velocity determination | |
477 | // | |
478 | if (fHnDrift) return; | |
479 | //HnSparse bins | |
480 | //time bin, roc, time | |
f113dfeb | 481 | Int_t bins[kHnBinsDV] = {fLastTimeBin-fFirstTimeBin, 72, fNBinsTime}; |
482 | Double_t xmin[kHnBinsDV] = {fFirstTimeBin,0,0}; | |
483 | Double_t xmax[kHnBinsDV] = {fLastTimeBin,72,fNBinsTime}; | |
ddeb9c4f | 484 | 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); |
485 | ||
486 | } | |
487 | //_____________________________________________________________________ | |
488 | void AliTPCCalibRaw::Analyse() | |
489 | { | |
490 | // | |
491 | // Analyse Data | |
492 | // | |
493 | ||
494 | //resize arrays | |
495 | fArrALTROL1Phase.ResizeTo(GetNevents()); | |
be3dbaa0 | 496 | for (Int_t ircu=0;ircu<kNRCU;++ircu){ |
ddeb9c4f | 497 | TVectorF *arr=MakeArrL1PhaseRCU(ircu);//MakeArrL1PhaseRCU(ircu); |
498 | if (!arr) continue; | |
be3dbaa0 | 499 | arr->ResizeTo(fNFailL1PhaseEvent); |
500 | fArrFailEventNumber.ResizeTo(fNFailL1PhaseEvent); | |
501 | // TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu); | |
502 | // arrF->ResizeTo(1); | |
ddeb9c4f | 503 | } |
cc65e4f5 | 504 | //resize occupancy arrays only save event occupancy in sensitive regions by default |
505 | //save the rest in debub mode | |
1d32f273 | 506 | fVOccupancySenEvent.ResizeTo(GetNevents()); |
cc65e4f5 | 507 | if (fDebugLevel>0){ |
508 | fVOccupancyEvent.ResizeTo(GetNevents()); | |
509 | fVSignalSumEvent.ResizeTo(GetNevents()); | |
510 | fVSignalSumSenEvent.ResizeTo(GetNevents()); | |
511 | fVNfiredPadsSenEvent.ResizeTo(GetNevents()); | |
512 | fVTimeStampEvent.ResizeTo(GetNevents()); | |
513 | } else { | |
514 | fVOccupancyEvent.ResizeTo(0); | |
515 | fVSignalSumEvent.ResizeTo(0); | |
516 | fVSignalSumSenEvent.ResizeTo(0); | |
517 | fVNfiredPadsSenEvent.ResizeTo(0); | |
518 | fVTimeStampEvent.ResizeTo(0); | |
519 | } | |
1d32f273 | 520 | //Analyse drift velocity TODO |
ddeb9c4f | 521 | |
522 | } | |
1d32f273 | 523 | //_____________________________________________________________________ |
524 | TGraph* AliTPCCalibRaw::MakeGraphOccupancy(const Int_t type, const Int_t xType) | |
525 | { | |
526 | // | |
527 | // create occupancy graph (of samples abouve threshold) | |
528 | // type=0: number of samples | |
529 | // type=1: mean data volume (ADC counts/sample) | |
530 | // type=2: data volume (ADC counts) | |
531 | // type=3: samples per ADC count | |
532 | // type=4: sample occupancy | |
533 | // | |
534 | // type=5: number of sample sensitive / number of samples | |
535 | // | |
536 | // same in sensitive regions: | |
537 | // type=10: number of samples | |
538 | // type=11: mean data volume (ADC counts/sample) | |
539 | // type=12: data volume (ADC counts) | |
540 | // type=13: samples per ADC count | |
cc65e4f5 | 541 | // type=14: sample occupancy |
1d32f273 | 542 | // |
543 | // type=16: number of samples sensitive / number of pads sensitive | |
544 | // type=17: pad occupancy in sensitive regions | |
545 | // xType=0: vs. time stamp | |
546 | // xType=1: vs. event counter | |
547 | // | |
548 | ||
549 | TString title("Event occupancy"); | |
550 | TString xTitle("Time"); | |
551 | TString yTitle("number of samples"); | |
552 | TGraph *gr=new TGraph(GetNevents()); | |
cc65e4f5 | 553 | if (fVSignalSumEvent.GetNrows()==0&&!(type==10||type==14)) return 0; |
1d32f273 | 554 | TVectorF *vOcc=&fVOccupancyEvent; |
555 | TVectorF *vSum=&fVSignalSumEvent; | |
556 | TVectorF *vPads=&fVNfiredPadsSenEvent; | |
557 | Double_t norm=557568.; | |
7c4ee1e1 | 558 | if (type!=14&&fVOccupancyEvent.GetNrows()==0){ |
559 | AliWarning("In non debug mode only occupancy in sensitive regions vs. event awailable!!!"); | |
560 | return 0; | |
561 | } | |
1d32f273 | 562 | if (type>=10){ |
563 | vOcc=&fVOccupancySenEvent; | |
564 | vSum=&fVSignalSumSenEvent; | |
565 | vPads=&fVNfiredPadsSenEvent; | |
566 | norm=33012.; | |
567 | } | |
568 | for (Int_t i=0;i<GetNevents(); ++i){ | |
569 | Double_t nAboveThreshold=vOcc->GetMatrixArray()[i]; | |
7c4ee1e1 | 570 | |
571 | Double_t nSumADC =1; | |
572 | Double_t timestamp =1; | |
573 | Double_t nPads =1; | |
574 | ||
575 | if (fVOccupancyEvent.GetNrows()>0){ | |
576 | nSumADC =vSum->GetMatrixArray()[i]; | |
577 | timestamp =fVTimeStampEvent.GetMatrixArray()[i]+fFirstTimeStamp; | |
578 | nPads =vPads->GetMatrixArray()[i]; | |
579 | } | |
1d32f273 | 580 | Double_t x=timestamp; |
581 | Double_t y=0; | |
582 | // | |
583 | if (xType==1) x=i; | |
584 | // | |
585 | if (type%10==0) y=nAboveThreshold; | |
586 | if (type%10==1&&nAboveThreshold>0) y=nSumADC/nAboveThreshold; | |
587 | if (type%10==2) y=nSumADC; | |
588 | if (type%10==3&&nSumADC>0) y=nAboveThreshold/nSumADC; | |
589 | if (type%10==4) y=nAboveThreshold/(norm*(fLastTimeBin-fFirstTimeBin)); | |
590 | if (type==5) y=fVOccupancySenEvent.GetMatrixArray()[i]/fVOccupancyEvent.GetMatrixArray()[i]; | |
591 | if (type==16&&nPads>0) y=nAboveThreshold/nPads; | |
592 | if (type==17) y=nPads/norm; | |
593 | // | |
594 | gr->SetPoint(i,x,y); | |
595 | } | |
596 | if (xType==1) xTitle="Event"; | |
597 | if (type%10==1) yTitle="Mean ADC counts/sample"; | |
598 | else if (type%10==2) yTitle="Data volume [ADC counts]"; | |
599 | else if (type%10==3) yTitle="samples per ADC count"; | |
600 | else if (type%10==4) yTitle="sample occupancy"; | |
601 | if (type==5) yTitle="N samples (sensitive) / N samples"; | |
602 | if (type%10==6) yTitle="N samples / N pads"; | |
603 | if (type==17) yTitle="Pad Occupancy"; | |
604 | if (type>=10) yTitle+=" (sensitive)"; | |
605 | title=yTitle+":"+xTitle; | |
606 | title+=";"+xTitle+";"+yTitle; | |
607 | gr->SetTitle(title.Data()); | |
608 | gr->SetEditable(kFALSE); | |
609 | return gr; | |
610 | } | |
611 | //_____________________________________________________________________ | |
7442bceb | 612 | // TGraph* AliTPCCalibRaw::MakeGraphNoiseEvents() |
613 | // { | |
1d32f273 | 614 | // |
7442bceb | 615 | // Not implemented for the moment |
1d32f273 | 616 | // |
7442bceb | 617 | // return 0; |
618 | // } | |
1d32f273 | 619 | //_____________________________________________________________________ |
620 | TCanvas* AliTPCCalibRaw::MakeCanvasOccupancy(const Int_t xType, Bool_t sen) | |
621 | { | |
622 | // | |
623 | // Create a canvas with occupancy information of all 'type's (see MakeGraphOccupancy) | |
624 | // xType=0: vs. timestamp | |
625 | // xType=1: vs. event number | |
626 | // | |
627 | // sen=kTRUE: for sensitive regions | |
628 | // | |
629 | ||
630 | TString name("RawOccupancy_"); | |
631 | TString title("Raw Occupancy vs. "); | |
632 | if (xType==0){ | |
633 | name+="Time"; | |
634 | title+="time"; | |
635 | } else if (xType==1){ | |
636 | name+="Event"; | |
637 | title+="event"; | |
638 | } | |
639 | if (sen){ | |
640 | name+="Sen"; | |
641 | title+=" (sensitive)"; | |
642 | } | |
643 | TCanvas *c=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(name.Data()); | |
644 | if (!c) c=new TCanvas(name.Data(),title.Data()); | |
645 | c->Clear(); | |
646 | c->Divide(2,2); | |
647 | for (Int_t i=0;i<4;++i){ | |
648 | c->cd(i+1); | |
649 | TGraph *gr=MakeGraphOccupancy(i+10*(Int_t)sen,xType); | |
650 | gr->Draw("alp"); | |
651 | } | |
652 | return c; | |
653 | } | |
ddeb9c4f | 654 | |
7442bceb | 655 | //_____________________________________________________________________ |
656 | void AliTPCCalibRaw::Merge(AliTPCCalibRaw * const sig) | |
657 | { | |
658 | // | |
659 | // Merge sig with this instance | |
660 | // | |
661 | ||
662 | if (!sig) return; | |
663 | ||
664 | //Add last time bin distribution histogram | |
665 | fHnDrift->Add(sig->fHnDrift); | |
666 | ||
667 | //Add occupancy data | |
668 | ||
669 | } | |
670 | ||
671 | //_____________________________________________________________________ | |
672 | Long64_t AliTPCCalibRaw::Merge(TCollection * const list) | |
673 | { | |
674 | // | |
675 | // Merge all objects of this type in list | |
676 | // | |
677 | ||
678 | Long64_t nmerged=1; | |
679 | ||
680 | TIter next(list); | |
681 | AliTPCCalibRaw *ce=0; | |
682 | TObject *o=0; | |
683 | ||
684 | while ( (o=next()) ){ | |
685 | ce=dynamic_cast<AliTPCCalibRaw*>(o); | |
686 | if (ce){ | |
687 | Merge(ce); | |
688 | ++nmerged; | |
689 | } | |
690 | } | |
691 | ||
692 | return nmerged; | |
693 | } | |
694 |