]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - T0/AliT0RawData.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
DA find only coorect peak
[u/mrichter/AliRoot.git] / T0 / AliT0RawData.cxx
... / ...
CommitLineData
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// T0 raw data conversion class //
21// //
22///////////////////////////////////////////////////////////////////////////////
23
24//#include <Riostream.h>
25//#include <TTree.h>
26#include <TMap.h>
27#include "AliT0.h"
28#include "AliT0RawData.h"
29#include "AliT0digit.h"
30#include "AliBitPacking.h"
31#include "AliRawDataHeader.h"
32#include "AliRawDataHeaderSim.h"
33#include "AliBitPacking.h"
34#include "AliFstream.h"
35#include "AliRunLoader.h"
36#include "AliDAQ.h"
37#include "AliT0LookUpValue.h"
38#include "AliT0LookUpKey.h"
39
40ClassImp(AliT0RawData)
41
42//_____________________________________________________________________________
43 AliT0RawData::AliT0RawData():TObject(),
44 fVerbose(0),
45 fIndex(-1) ,
46 fEventNumber(0),
47 fTimeCFD(new TArrayI(24)),
48 fADC1( new TArrayI(24)),
49 fTimeLED( new TArrayI(24)),
50 fADC0( new TArrayI(24)),
51 fFile(0x0),
52 fDataHeaderPos(0),
53 fDRMDataHeaderPos(0),
54 fTRMDataHeaderPos(0),
55 fParam(0),
56 fLookUp(0)
57
58
59{
60 /*
61- 48 channels (2 words each as in TOF DDL) for :
62word 1 :0-5bit number of PMT; word 2: 0-7 error sign, 8-31 TDC
63and the same but for amplified signal. Now I wrote the same time because
64CDF are not ready and differences didn't measured yet.
65
66- 48 channel for amplitude: very preliminary, QTC features are not
67known now, preliminary i put as T1 time signal for this PMT in first
68channel and T1+A in second, where A=Log(Amplitude);
69and the same for amplified but A=Log(10*Amplitude).
70
71- T0-A and T0-C 2 channels
72- T0A-T0C vertex information
73- Time Meaner where T0C TOF increase to the T0A TOF distance
74- 6 multiplicity signals the same way as amplitude and with the same
75uncertances
76 */
77
78 //open the output file
79 char fileName[15];
80 strcpy(fileName,AliDAQ::DdlFileName("T0",0)); //The name of the output file
81 fFile = new AliFstream(fileName);
82 memset(fBuffer,0,512*sizeof(UInt_t));
83
84 //get event number
85 AliRunLoader *runloader = AliRunLoader::Instance();
86 if (runloader) {
87 fEventNumber = runloader->GetEventNumber();
88 }
89
90 // Inverse lookup table for simulation
91
92 fParam = AliT0Parameters::Instance();
93 fParam->Init();
94 AliT0LookUpKey* lookkey= new AliT0LookUpKey();
95 AliT0LookUpValue* lookvalue= new AliT0LookUpValue();
96 TMap *lookup = fParam->GetMapLookup();
97 TMapIter iter(lookup);
98
99 for( Int_t iline=0; iline<106; iline++)
100 {
101 lookvalue = ( AliT0LookUpValue*) iter.Next();
102 lookkey = (AliT0LookUpKey*) lookup->GetValue(lookvalue);
103 fLookUp.Add(lookkey, lookvalue);
104 lookkey= new AliT0LookUpKey();
105 lookvalue= new AliT0LookUpValue();
106 }
107
108}
109
110//_____________________________________________________________________________
111
112AliT0RawData::AliT0RawData(const AliT0RawData &r):TObject(),
113 fVerbose(0),
114 fIndex(-1) ,
115 fEventNumber(0),
116 fTimeCFD(new TArrayI(24)),
117 fADC1( new TArrayI(24)),
118 fTimeLED( new TArrayI(24)),
119 fADC0( new TArrayI(24)),
120 fFile(0x0),
121 fDataHeaderPos(0),
122 fDRMDataHeaderPos(0),
123 fTRMDataHeaderPos(0),
124 fParam(0),
125 fLookUp(0)
126
127{
128 //
129 // AliT0rawData copy constructor
130 //
131
132 ((AliT0RawData &) r).Copy(*this);
133
134}
135
136//_____________________________________________________________________________
137AliT0RawData::~AliT0RawData()
138{
139 //
140 // Destructor
141 //
142 delete fTimeCFD;
143 delete fADC1;
144 delete fTimeLED;
145 delete fADC0;
146 delete fFile;
147}
148
149//_____________________________________________________________________________
150AliT0RawData &AliT0RawData::operator=(const AliT0RawData &r)
151{
152 //
153 // Assignment operator
154 //
155
156 if (this != &r) ((AliT0RawData &) r).Copy(*this);
157 return *this;
158
159}
160
161//_____________________________________________________________________________
162void AliT0RawData::GetDigits(AliT0digit *fDigits)
163//void AliT0RawData::GetDigits(fDigits)
164{
165
166 //This method packs the T0 digits in a proper 32 bits structure
167
168 //read T0 digits and fill TDC and ADC arrays
169
170
171 // Int_t error=0;
172 Int_t time, positionOfTRMHeader;
173
174 // Get the digits array
175
176 fDigits->GetTimeCFD(*fTimeCFD);
177 fDigits->GetQT0(*fADC1);
178 fDigits->GetTimeLED(*fTimeLED);
179 fDigits->GetQT1(*fADC0);
180 Int_t meantime = fDigits->MeanTime();
181 Int_t timediff = fDigits->TimeDiff();
182 Int_t mult0=fDigits->SumMult();
183 Int_t mult1=fDigits->SumMult();
184 Int_t timeA = fDigits->BestTimeC();
185 Int_t timeC = fDigits->BestTimeA();
186
187
188 // TArrayI *allData = new TArrayI(110);
189 Int_t allData[110][1];
190 for (Int_t i=0; i<110; i++) allData[i][0] = 0;
191
192 allData[0][0]=0;
193 for (Int_t i=1; i<13; i++) {
194 allData[i][0] = fTimeCFD->At(i-1);
195 allData[i+12][0] = fTimeLED->At(i-1);
196 allData[i+56][0] = fTimeCFD->At(i-1+12);
197 allData[i+68][0] = fTimeLED->At(i-1+12);
198 }
199
200 for (Int_t iii=0; iii<12; iii++) {
201 allData[2*iii+25][0] = fADC1->At(iii);
202 allData[2*iii+26][0] = fADC0->At(iii);
203 }
204 for (Int_t ii=12; ii<24; ii++) {
205 allData[2*ii+57][0] = fADC1->At(ii);
206 allData[2*ii+58][0] = fADC0->At(ii);
207 }
208
209 allData[49][0] = meantime;
210 allData[50][0] = timediff;
211 allData[51][0] = timeA;
212 allData[52][0] = timeC;
213 allData[53][0] = mult0;
214 allData[54][0] = mult1;
215 allData[55][0] = mult0;
216 allData[56][0] = mult1;
217
218 // cout.setf( ios_base::hex, ios_base::basefield );
219 //space for DRM header
220 fIndex += 6;
221
222
223 Int_t startTRM=fIndex;
224 //space for 1st TRM header
225 fIndex ++;
226 positionOfTRMHeader= fIndex;
227 //space for chain header
228 fIndex ++;
229 WriteChainDataHeader(1, 1); //
230
231 // fIndex++;
232 // Loop through all PMT
233 Int_t chain=0;
234 Int_t iTDC = 0;
235 Int_t channel=0;
236 Int_t trm1words=0;
237 Int_t itrm=7;
238 Int_t inside =0;
239 Int_t isData = 0;
240 AliT0LookUpKey * lookkey = new AliT0LookUpKey();
241 AliT0LookUpValue * lookvalue ;//= new AliT0LookUpValue(trm,tdc,chain,channel);
242 for (Int_t det = 0; det < 105; det++) {
243 time = allData[det][0];
244 if (time >0 && time !=99999) {
245 lookkey->SetKey(det);
246 lookvalue = (AliT0LookUpValue*) fLookUp.GetValue((TObject*)lookkey);
247 if (lookvalue )
248 {
249 isData++;
250 itrm= lookvalue->GetTRM();
251 if (det >56 &&inside == 0) {
252 WriteChainDataTrailer(1); // 1st chain trailer
253 fIndex++;
254 WriteChainDataHeader(2, 1);
255 // fIndex++;
256 inside++;
257 }
258 chain = lookvalue->GetChain();
259 iTDC = lookvalue->GetTDC();
260 channel = lookvalue->GetChannel();
261 FillTime(channel, iTDC, time);
262 AliDebug(1,Form("look %i itrm %i , chain %i , iTDC %i, channel %i time %i", det,itrm,chain,iTDC,channel, time));
263 }
264 else
265 {
266 cout<<" no lookup value for key "<<det<<endl;
267 // break;
268 }
269 }
270
271 }
272 if (inside==0) {
273 WriteChainDataTrailer(1); // 1st chain trailer
274 fIndex++;
275 WriteChainDataHeader(2, 1);
276 }
277 // WriteChainDataHeader(2, 1); //
278 WriteChainDataTrailer(3); // 2st chain trailer
279 WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
280
281
282 trm1words = fIndex - startTRM;
283 //space for 2st TRM header
284
285 WriteTRMDataHeader(itrm, trm1words , positionOfTRMHeader);
286
287 //DRM trailer
288 WriteTrailer(1,0,fEventNumber,5);
289
290 WriteDRMDataHeader();
291
292}
293
294//_____________________________________________________________________________
295
296void AliT0RawData::WriteDRMDataHeader()
297{
298//Write a (dummy or real) DDL DRM data header,
299//set the compression bit if compressed
300// UInt_t drmheader[4];
301 UInt_t word;
302 UInt_t baseWord=0;
303 //fill DRM headers
304 //DRM Global Header
305 word = 1;
306 AliBitPacking::PackWord(word,baseWord,0, 3); // 0001
307 word = fIndex ;
308
309 AliBitPacking::PackWord(word,baseWord,4, 20); // event words
310 word=124;
311 AliBitPacking::PackWord(word,baseWord, 21, 27); // event words
312 word=4;
313 AliBitPacking::PackWord(word,baseWord,28, 31);// 0100 marks header
314 fBuffer[0]= baseWord;
315
316
317 //DRM status header 1
318 word = 1;
319 AliBitPacking::PackWord(word,baseWord,0, 3); // 0001
320 word = 1;
321 AliBitPacking::PackWord(word,baseWord,4, 14); // slotID now 0000000001
322 word = 1;
323 AliBitPacking::PackWord(word,baseWord,15, 15); //if 1 LHC clock is coorectly recieved from CPDM
324 word=0;
325 AliBitPacking::PackWord(word,baseWord,16,27); // reserve for future use
326 word=4;
327 AliBitPacking::PackWord(word,baseWord,28,31); // 0100 marks header
328 fBuffer[1] = baseWord;
329
330 word=0;
331 baseWord=0;
332
333 //DRM status header 2
334 word = 1;
335 AliBitPacking::PackWord(word,baseWord, 0, 3); // 0001
336 word = 3;
337 AliBitPacking::PackWord(word,baseWord, 4, 14); //enable slotID now 00000000011
338 word = 0;
339 AliBitPacking::PackWord(word,baseWord, 15, 15); // something
340 word=0;
341 AliBitPacking::PackWord(word,baseWord, 16, 27); // fault ID for simulation 0
342 word=4;
343 AliBitPacking::PackWord(word,baseWord,28,31); // 0100 marks header
344 fBuffer[2]= baseWord;
345
346 word=0;
347 baseWord=0;
348 //DRM status header 3
349 word = 1;
350 AliBitPacking::PackWord(word,baseWord,0, 3); // 0001
351 word = 0;
352 AliBitPacking::PackWord(word,baseWord,4, 27); // TTC event counter
353 word=4;
354 AliBitPacking::PackWord(word,baseWord,28,31); // 0100 marks header
355 fBuffer[3]= baseWord;
356
357 // new DRM format
358 fBuffer[4]= baseWord;
359 fBuffer[5]= baseWord;
360
361 word=0;
362 baseWord=0;
363
364}
365
366//_____________________________________________________________________________
367
368void AliT0RawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
369 Int_t positionOfTRMHeader)
370{
371//Write a (dummy or real) DDL TRM data header,
372//set the compression bit if compressed
373// UInt_t trmheader;
374 UInt_t word;
375 UInt_t baseWord=0;
376 //fill TRM headers
377 //TRM Global Header
378 word = slotID;
379 AliBitPacking::PackWord(word,baseWord,0, 3); // slotID
380 word = nWordsInTRM;
381 //+this word - DRM header
382
383 AliBitPacking::PackWord(word,baseWord,4, 16); // event words
384 word=0;
385 AliBitPacking::PackWord(word,baseWord,17,18); // ACQ
386 word=0;
387 AliBitPacking::PackWord(word,baseWord,19,19); // L SEY inside LUT
388 word=0;
389 AliBitPacking::PackWord(word,baseWord,20,27); // MBZ
390 word=4;
391 AliBitPacking::PackWord(word,baseWord,28,31); // 0100 marks header
392 fBuffer[positionOfTRMHeader] = baseWord;
393
394 word=0;
395 baseWord=0;
396
397}
398
399//_____________________________________________________________________________
400
401void AliT0RawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
402{
403//Write a (dummy or real) DDL Chain data header,
404//set the compression bit if compressed
405// chainNumber 00 or 10
406 UInt_t word;
407 UInt_t baseWord=0;
408 //fill TRM headers
409 //TRM Global Header
410 word = slotID; // ask Tatiana 7 or 9
411 AliBitPacking::PackWord(word,baseWord,0, 3); // slotID
412 word = 0;
413 AliBitPacking::PackWord(word,baseWord,4, 15); // bunchID
414 word=0;
415 AliBitPacking::PackWord(word,baseWord,16,23); // PB24 temperature
416 word=0;
417 AliBitPacking::PackWord(word,baseWord,24,26); // PB24 ID
418 word=0;
419 AliBitPacking::PackWord(word,baseWord,27,27); // TS
420 word=chainNumber;
421 AliBitPacking::PackWord(word,baseWord,28,31); // 0100 marks header
422 fBuffer[fIndex] = baseWord;
423 //cout<<" chain header "<<baseWord<<" number "<<chainNumber<<endl;
424 word=0;
425 baseWord=0;
426
427}
428//_____________________________________________________________________________
429
430void AliT0RawData::WriteChainDataTrailer(UInt_t chainNumber )
431{
432//Write a (dummy or real) DDL Chain data trailer
433//set the compression bit if compressed
434// chainNumber 00 or 10
435 UInt_t word;
436 UInt_t baseWord=0;
437 word = 0; // ask Tatiana 7 or 9
438 AliBitPacking::PackWord(word,baseWord,0, 3); // status
439 word = 0;
440 AliBitPacking::PackWord(word,baseWord,4, 15); // MBZ
441 word=fEventNumber;
442 AliBitPacking::PackWord(word,baseWord,16,27); // event counter
443 word=chainNumber;
444 AliBitPacking::PackWord(word,baseWord,28,31); // chain number
445 fIndex++;
446 fBuffer[fIndex] = baseWord;
447
448 word=0;
449 baseWord=0;
450
451}
452//_____________________________________________________________________________
453
454void AliT0RawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
455{
456//Write a (dummy or real) DDL data header,
457//set the compression bit if compressed
458
459 AliRawDataHeaderSim header;
460
461 if (dummy) {
462 //if size=0 it means that this data header is a dummy data header
463 fDataHeaderPos = fFile->Tellp();
464 fFile->WriteBuffer((char*)(&header), sizeof(header));
465 } else {
466 UInt_t currentFilePos = fFile->Tellp();
467 fFile->Seekp(fDataHeaderPos);
468 header.fSize = currentFilePos-fDataHeaderPos;
469 header.SetAttribute(0); // valid data
470 if (compressed) header.SetAttribute(1);
471 fFile->WriteBuffer((char*)(&header), sizeof(header));
472 fFile->Seekp(currentFilePos);
473 }
474
475}
476
477//___ __________________________________________________________________________
478
479
480void AliT0RawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
481{
482//Write a (dummy or real) DDL Chain data trailer
483
484 UInt_t word;
485 UInt_t baseWord=0;
486 word = slot;
487 AliBitPacking::PackWord(word,baseWord,0, 3); // 0001
488 word=word1;
489 AliBitPacking::PackWord(word,baseWord,4, 15); // CRC ?
490 word = word2;
491 AliBitPacking::PackWord(word,baseWord,16,27); // event counter
492 word=word3;
493 AliBitPacking::PackWord(word,baseWord,28,31); // marks trailer
494 fIndex++;
495 fBuffer[fIndex] = baseWord;
496
497 word=0;
498 baseWord=0;
499
500}
501
502//---------------------------------------------------------------------------------------
503//---------------------------------------------------------------------------------------
504void AliT0RawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
505{
506 // put all time fields thother in 1 word
507
508 UInt_t word;
509 UInt_t baseWord=0;
510
511 word=time;
512 AliBitPacking::PackWord(word,baseWord, 0, 20); // Time
513
514 word=ch;
515 AliBitPacking::PackWord(word,baseWord, 21, 23); // number of channel
516 word=iTDC;
517 AliBitPacking::PackWord(word,baseWord, 24, 27); // TDC ID
518
519 word=0;
520 AliBitPacking::PackWord(word,baseWord, 28, 28); // E = 0 in simulation
521 word=0;
522 AliBitPacking::PackWord(word,baseWord, 29, 30); // PS bit data 00
523 word=1;
524 AliBitPacking::PackWord(word,baseWord, 31, 31); // 1
525 fIndex++;
526 fBuffer[fIndex]=baseWord;
527
528 word=0;
529 baseWord=0;
530}
531//---------------------------------------------------------------------------------------
532
533Int_t AliT0RawData::RawDataT0(AliT0digit *fDigits)
534 //Int_t AliT0RawData::RawDataT0(*fDigits)
535{
536 //This method creates the Raw data files for T0 detector
537
538
539 // const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
540 //max number of digits per DDL file times 2
541 // UInt_t fBuffer[kSize];
542 // UInt_t baseWord;
543 // UInt_t word;
544
545 fIndex=-1;
546
547
548 WriteDataHeader(kTRUE, kFALSE);
549 GetDigits(fDigits);
550 //write packing digits
551
552
553 fFile->WriteBuffer((char*) fBuffer,((fIndex+1)*sizeof(UInt_t)));
554 //write real data header on its place
555 WriteDataHeader(kFALSE, kFALSE);
556
557
558 //end for
559
560 return 0;
561
562}