]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITSDDLRawData.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Remove AliTRDv2
[u/mrichter/AliRoot.git] / ITS / AliITSDDLRawData.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-2003, 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//This class contains all the necessary methods to create the Raw Data
20//files (slides) for the ITS data challenges for:
21//SPD
22//SDD
23//SSD
24
25#include <stdlib.h>
26#include <TClonesArray.h>
27#include <TTree.h>
28#include "AliITSdigit.h"
29#include "AliITSDDLRawData.h"
30#include "AliRawDataHeader.h"
31#include "AliITSRawStreamSPD.h"
32#include "AliITSRawStreamSDD.h"
33#include "AliITSRawStreamSSD.h"
34#include "AliBitPacking.h"
35#include "AliDAQ.h"
36
37ClassImp(AliITSDDLRawData)
38
39////////////////////////////////////////////////////////////////////////////////////////
40AliITSDDLRawData::AliITSDDLRawData(){
41 //Default constructor
42 fIndex=-1;
43 fHalfStaveModule=-1;
44 fVerbose=0;
45}
46
47////////////////////////////////////////////////////////////////////////////////////////
48
49AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) :
50 TObject(source){
51 //Copy Constructor
52 this->fIndex=source.fIndex;
53 this->fHalfStaveModule=source.fHalfStaveModule;
54 this->fVerbose=source.fVerbose;
55 return;
56}
57
58////////////////////////////////////////////////////////////////////////////////////////
59
60AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){
61 //Assigment operator
62 this->fIndex=source.fIndex;
63 this->fHalfStaveModule=source.fHalfStaveModule;
64 this->fVerbose=source.fVerbose;
65 return *this;
66}
67
68////////////////////////////////////////////////////////////////////////////////////////
69//STRIP
70//
71
72void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){
73 //This method packs the SSD digits in a proper 32 bits structure
74 Int_t ix;
75 Int_t iz;
76 Int_t is;
77 UInt_t word;
78 UInt_t baseWord;
79 Int_t ndigits = ITSdigits->GetEntries();
80 AliITSdigit *digs;
81 ofstream ftxt;
82 if(ndigits){
83 if (fVerbose==2){
84 ftxt.open("SSDdigits.txt",ios::app);
85 }
86 for (Int_t digit=0;digit<ndigits;digit++) {
87 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
88 iz=digs->GetCoord1(); // If iz==0, N side and if iz=1 P side
89 ix=digs->GetCoord2(); // Strip Numbar
90 is=digs->GetCompressedSignal(); // ADC Signal
91 // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
92 if (fVerbose==2)
93 ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
94 baseWord=0;
95 word=is-1;
96 AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
97 word=ix;
98 AliBitPacking::PackWord(word,baseWord,10,19);//Strip Number
99 word=iz;
100 AliBitPacking::PackWord(word,baseWord,20,20);//ADC Channel ID (N or P side)
101 word=mod;
102 AliBitPacking::PackWord(word,baseWord,21,31);//ADC module ID
103 fIndex++;
104 buf[fIndex]=baseWord;
105 }//end for
106 }//end if
107 if (fVerbose==2)
108 ftxt.close();
109 return;
110}//end GetDigitsSSD
111
112////////////////////////////////////////////////////////////////////////////////////////
113//Silicon Drift Detector
114//
115
116void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){
117 //This method packs the SSD digits in a proper 32 bits structure
118 Int_t ix;
119 Int_t iz;
120 Int_t is;
121 UInt_t word;
122 UInt_t baseWord;
123 Int_t ndigits = ITSdigits->GetEntries();
124 AliITSdigit *digs;
125 ofstream ftxt;
126 if(ndigits){
127 //cout<<"Mudule "<<mod<<" number of digits "<<ndigits<<endl;
128 if (fVerbose==2)
129 ftxt.open("SDDdigits.txt",ios::app);
130 for (Int_t digit=0;digit<ndigits;digit++) {
131 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
132 iz=digs->GetCoord1(); // Anode
133 ix=digs->GetCoord2(); // Time
134 is=digs->GetCompressedSignal(); // ADC Signal
135 if (fVerbose==2)
136 ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl;
137 // cout<<"Amplitude value:"<<is<<" Time Bucket:"<<ix<<" Anode:"<<iz<<endl;
138 if (is>255){Error("GetDigitsSDD", "bits words is needed)!!!");}
139 baseWord=0;
140 /*
141 //10 bits words for amplitude value
142 word=is;
143 AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
144 word=ix;
145 AliBitPacking::PackWord(word,baseWord,10,17);//Time bucket
146 word=iz;
147 AliBitPacking::PackWord(word,baseWord,18,26);//Anode Number
148 word=mod;
149 AliBitPacking::PackWord(word,baseWord,27,31);//Module number
150 */
151
152 //8bits words for amplitude value
153 word=is;
154 AliBitPacking::PackWord(word,baseWord,0,7);//ADC data
155 word=ix;
156 AliBitPacking::PackWord(word,baseWord,8,15);//Time bucket
157 word=iz;
158 AliBitPacking::PackWord(word,baseWord,16,24);//Anode Number
159 word=mod;
160 AliBitPacking::PackWord(word,baseWord,25,31);//Module number
161
162 fIndex++;
163 buf[fIndex]=baseWord;
164 }//end for
165 }//end if
166 if(fVerbose==2)
167 ftxt.close();
168 return;
169}//end GetDigitsSDD
170
171////////////////////////////////////////////////////////////////////////////////////////
172//PIXEL
173//
174
175void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, UInt_t *buf){
176 //This method packs the SPD digits in a proper 32 structure
177 //Since data is zero suppressed,the coordinates for the chip having zero digits
178 //doesn't get listed in the galice.root file. However the SPD format requires
179 //the empty chip to be written with chip header and chip trailer.
180 Int_t ix;
181 Int_t iz;
182 Int_t chipNo=0;
183 UInt_t baseWord=0;
184 UInt_t hitRow=0;
185 Int_t chipHitCount=0; //Number of Hit in the current chip
186 Int_t previousChip=-1; //Previuos chip respect to the actual aone
187 Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module
188 //cout<<" Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl;
189 AliITSdigit *digs;
190 fHalfStaveModule++; //It's a private variable used to distinguish between the firs
191 //and the second module of an Half Stave Module
192 ofstream ftxt;
193 if(ndigits){
194 //loop over digits
195 if (fVerbose==2)
196 ftxt.open("SPDdigits.txt",ios::app);
197 for (Int_t digit=0;digit<ndigits;digit++){
198 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
199 /*---------------------------------------------------------------------------
200 * Each module contains 5 read out chips of 256 rows and 32 columns.
201 * So, the cell number in Z direction varies from 0 to 159. Therefore,
202 * to get the chip address (0 to 4), we need to divide column number by 32.
203 * ---------------------------------------------------------------------*/
204 iz=digs->GetCoord1(); // Cell number in Z direction
205 ix=digs->GetCoord2(); // Cell number in X direction
206 chipNo=iz/32;
207 if(fVerbose==2)
208 ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
209 hitRow=iz-chipNo*32;
210 if(fHalfStaveModule){
211 chipNo+=5;
212 fHalfStaveModule=-1;
213 }//end if
214 if(previousChip==-1){
215 //loop over chip without digits
216 //Even if there aren't digits for a given chip
217 //the chip header and the chip trailer are stored
218 for(Int_t i=0;i<(iz/32);i++){
219 if(chipNo>4)
220 WriteChipHeader(i+5,(mod/2),baseWord);
221 else
222 WriteChipHeader(i,(mod/2),baseWord);
223 WriteChipTrailer(buf,chipHitCount,baseWord);
224 chipHitCount=0;
225 }//end for
226 WriteChipHeader(chipNo,(mod/2),baseWord);
227 chipHitCount++;
228 WriteHit(buf,ix,hitRow,baseWord);
229 previousChip=chipNo;
230 }//end if
231 else{
232 if(previousChip!=chipNo){
233 WriteChipTrailer(buf,chipHitCount,baseWord);
234 chipHitCount=0;
235 for(Int_t i=previousChip+1;i<chipNo;i++){
236 WriteChipHeader(i,(mod/2),baseWord);
237 WriteChipTrailer(buf,0,baseWord);
238 chipHitCount=0;
239 }//end for
240 WriteChipHeader(chipNo,(mod/2),baseWord);
241 previousChip=chipNo;
242 }//end if
243 chipHitCount++;
244 WriteHit(buf,ix,hitRow,baseWord);
245 }//end else
246 }//end for
247 //Even if there aren't digits for a given chip
248 //the chip header and the chip trailer are stored
249 Int_t end=4;
250 if(chipNo>4)end+=5;
251 WriteChipTrailer(buf,chipHitCount,baseWord);
252 chipHitCount=0;
253 for(Int_t i=chipNo+1;i<=end;i++){
254 WriteChipHeader(i,(mod/2),baseWord);
255 WriteChipTrailer(buf,0,baseWord);
256 chipHitCount=0;
257 }//end for
258 }//end if
259 else{
260 //In this module there aren't digits but
261 //the chip header and chip trailer are store anyway
262 if(fHalfStaveModule){
263 chipNo=5;
264 fHalfStaveModule=-1;
265 }//end if
266 for(Int_t i=0;i<5;i++){
267 WriteChipHeader(chipNo+i,(mod/2),baseWord);
268 WriteChipTrailer(buf,chipHitCount,baseWord);
269 chipHitCount=0;
270 }//end for
271 }//end else
272 if(fVerbose==2)
273 ftxt.close();
274 return;
275}//end GetDigitsSPD
276
277/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
278
279Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch){
280 //This method creates the Raw data files for SPD detectors
281 const Int_t kSize=21000; //256*32*5=40960 max number of digits per module
282 UInt_t buf[kSize]; //One buffer cell can contain 2 digits
283 fIndex=-1;
284
285 TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
286 char fileName[15];
287 ofstream outfile; // logical name of the output file
288 AliRawDataHeader header;
289
290 //loop over DDLs
291 for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSPD");i++){
292 strcpy(fileName,AliDAQ::DdlFileName("ITSSPD",i)); //The name of the output file.
293#ifndef __DECCXX
294 outfile.open(fileName,ios::binary);
295#else
296 outfile.open(fileName);
297#endif
298 //write Dummy DATA HEADER
299 UInt_t dataHeaderPosition=outfile.tellp();
300 outfile.write((char*)(&header),sizeof(header));
301 //Loops over Modules of a particular DDL
302 for (Int_t mod=0; mod<AliITSRawStreamSPD::kModulesPerDDL; mod++){
303 Int_t moduleNumber = AliITSRawStreamSPD::GetModuleNumber(i, mod);
304 digits->Clear();
305 branch->GetEvent(moduleNumber);
306 //For each Module, buf contains the array of data words in Binary format
307 //fIndex gives the number of 32 bits words in the buffer for each module
308 GetDigitsSPD(digits,moduleNumber,i,buf);
309 outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
310 for(Int_t i=0;i<(fIndex+1);i++){
311 buf[i]=0;
312 }//end for
313 fIndex=-1;
314 }//end for
315
316 //Write REAL DATA HEADER
317 UInt_t currentFilePosition=outfile.tellp();
318 outfile.seekp(dataHeaderPosition);
319 header.fSize=currentFilePosition-dataHeaderPosition;
320 outfile.write((char*)(&header),sizeof(header));
321 outfile.close();
322 }//end for
323
324 return 0;
325}
326
327/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
328
329Int_t AliITSDDLRawData::RawDataSSD(TBranch* branch){
330 //This method creates the Raw data files for SSD detectors
331 const Int_t kSize=1536;//768*2 Number of stripe * number of sides(N and P)
332 UInt_t buf[kSize];
333 fIndex=-1;
334
335 TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
336 char fileName[15];
337 ofstream outfile; // logical name of the output file
338 AliRawDataHeader header;
339
340 //loop over DDLs
341 for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSSD");i++){
342 strcpy(fileName,AliDAQ::DdlFileName("ITSSSD",i)); //The name of the output file.
343#ifndef __DECCXX
344 outfile.open(fileName,ios::binary);
345#else
346 outfile.open(fileName);
347#endif
348 //write Dummy DATA HEADER
349 UInt_t dataHeaderPosition=outfile.tellp();
350 outfile.write((char*)(&header),sizeof(header));
351
352 //Loops over Modules of a particular DDL
353 for (Int_t mod=0; mod<AliITSRawStreamSSD::kModulesPerDDL; mod++){
354 Int_t moduleNumber = AliITSRawStreamSSD::GetModuleNumber(i, mod);
355 if(moduleNumber!=-1){
356 digits->Clear();
357 branch->GetEvent(moduleNumber);
358 //For each Module, buf contains the array of data words in Binary format
359 //fIndex gives the number of 32 bits words in the buffer for each module
360 GetDigitsSSD(digits,mod,moduleNumber,i,buf);
361 outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
362 fIndex=-1;
363 }//end if
364 }//end for
365
366 //Write REAL DATA HEADER
367 UInt_t currentFilePosition=outfile.tellp();
368 outfile.seekp(dataHeaderPosition);
369 header.fSize=currentFilePosition-dataHeaderPosition;
370 header.SetAttribute(0); // valid data
371 outfile.write((char*)(&header),sizeof(header));
372 outfile.close();
373 }//end for
374
375 return 0;
376}
377
378/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
379
380Int_t AliITSDDLRawData::RawDataSDD(TBranch* branch){
381 //This method creates the Raw data files for SDD detectors
382 const Int_t kSize=131072; //256*512
383 UInt_t buf[kSize];
384 fIndex=-1;
385
386 TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
387 char fileName[15];
388 ofstream outfile; // logical name of the output file
389 AliRawDataHeader header;
390
391 //loop over DDLs
392 for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSDD");i++){
393 strcpy(fileName,AliDAQ::DdlFileName("ITSSDD",i)); //The name of the output file.
394#ifndef __DECCXX
395 outfile.open(fileName,ios::binary);
396#else
397 outfile.open(fileName);
398#endif
399 //write Dummy DATA HEADER
400 UInt_t dataHeaderPosition=outfile.tellp();
401 outfile.write((char*)(&header),sizeof(header));
402
403 //Loops over Modules of a particular DDL
404 for (Int_t mod=0; mod<AliITSRawStreamSDD::kModulesPerDDL; mod++){
405 Int_t moduleNumber = AliITSRawStreamSDD::GetModuleNumber(i, mod);
406 if(moduleNumber!=-1){
407 digits->Clear();
408 branch->GetEvent(moduleNumber);
409 //For each Module, buf contains the array of data words in Binary format
410 //fIndex gives the number of 32 bits words in the buffer for each module
411 // cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl;
412 GetDigitsSDD(digits,mod,moduleNumber,i,buf);
413 outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
414 fIndex=-1;
415 }//end if
416 }//end for
417
418 //Write REAL DATA HEADER
419 UInt_t currentFilePosition=outfile.tellp();
420 outfile.seekp(dataHeaderPosition);
421 header.fSize=currentFilePosition-dataHeaderPosition;
422 header.SetAttribute(0); // valid data
423 outfile.write((char*)(&header),sizeof(header));
424 outfile.close();
425 }//end for
426
427 return 0;
428}
429
430/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
431
432void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t /*EventCnt*/,UInt_t &BaseWord){
433 //This method writes a chip header
434 //cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<EventCnt<<endl;
435 BaseWord=0;
436 AliBitPacking::PackWord(ChipAddr,BaseWord,0,3);
437// AliBitPacking::PackWord(EventCnt,BaseWord,4,10);
438 AliBitPacking::PackWord(0,BaseWord,4,10);
439 AliBitPacking::PackWord(0x7,BaseWord,11,13);
440 AliBitPacking::PackWord(0x1,BaseWord,14,15);
441 return;
442}//end WriteChipHeader
443
444/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
445
446void AliITSDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,UInt_t BaseWord){
447 //This method reads a chip header
448 UInt_t temp=AliBitPacking::UnpackWord(BaseWord,0,3);
449 ChipAddr=(Int_t)temp;
450 temp=AliBitPacking::UnpackWord(BaseWord,4,10);
451 EventCnt=(Int_t)temp;
452 if(fVerbose)
453 Info("ReadChipHeader", "Chip:&d Half Stave module:%d",ChipAddr,EventCnt);
454 return;
455}//end ReadChipHeader
456
457/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
458
459void AliITSDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord){
460 //This method writes a chip trailer
461 //pixel fill word
462 if((ChipHitCount%2)!=0){
463 AliBitPacking::PackWord(0xC000,BaseWord,0,15);
464 }
465 AliBitPacking::PackWord(ChipHitCount,BaseWord,16,29);
466 AliBitPacking::PackWord(0x0,BaseWord,30,31);
467 fIndex++;
468 buf[fIndex]=BaseWord;
469 BaseWord=0;
470 return;
471}//end WriteChipTrailer
472
473/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
474
475void AliITSDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,UInt_t BaseWord){
476 //This method reads a chip trailer
477 UInt_t temp=AliBitPacking::UnpackWord(BaseWord,16,29);
478 ChipHitCount=(Int_t)temp;
479 return;
480}//end ReadChipTrailer
481
482/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
483
484void AliITSDDLRawData::WriteHit(UInt_t *buf,Int_t RowAddr,Int_t HitAddr,UInt_t &BaseWord){
485 //This method writs an hit
486 if(!BaseWord){
487 AliBitPacking::PackWord(HitAddr,BaseWord,0,4);
488 AliBitPacking::PackWord(RowAddr,BaseWord,5,12);
489 AliBitPacking::PackWord(2,BaseWord,14,15);
490 }//end if
491 else{
492 AliBitPacking::PackWord(HitAddr,BaseWord,16,20);
493 AliBitPacking::PackWord(RowAddr,BaseWord,21,28);
494 AliBitPacking::PackWord(2,BaseWord,30,31);
495 fIndex++;
496 buf[fIndex]=BaseWord;
497 BaseWord=0;
498 }//end else
499 return;
500}//end WriteHit
501