TRD/AliTRDtestBeam.cxx

   1
   2 #include "AliTRDtestBeam.h"
   3
   4 #include "AliTRDRawStreamTB.h"
   5 #include "AliRawReaderMemory.h"
   6
   7 #include <iostream>
   8 #include <fstream>
   9
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <unistd.h>
  14
  15 //#include <>
  16
  17 ClassImp(AliTRDtestBeam)
  18
  19 const Long_t AliTRDtestBeam::file_head_size = 544; // ?
  20 const Long_t AliTRDtestBeam::event_head_size = 68; //?
  21 const Long_t AliTRDtestBeam::ldc_head_size = 68; //?
  22 const Long_t AliTRDtestBeam::equip_head_size = 28; //
  23 const Int_t AliTRDtestBeam::vme_in =1; //VME event in
  24 const Int_t AliTRDtestBeam::sim_in =1; //Si-strips in
  25
  26 //typedef char byte;
  27
  28 //offsets in bytes
  29 const Int_t AliTRDtestBeam::pos_run = 20; //run nr. (in file and event header)
  30 const Int_t AliTRDtestBeam::pos_length = 0; //event/equip. length
  31 const Int_t AliTRDtestBeam::pos_eqid = 8;  //equipment id.
  32 const Int_t AliTRDtestBeam::pos_sioff = 12;  //Si data size offset (3 extra words!!!)
  33
  34 using namespace std;
  35
  36 //____________________________________________________________________________
  37 AliTRDtestBeam::AliTRDtestBeam() :
  38   fDataStream(0),
  39   fHeaderIsRead(0),
  40   fEventCount(0),
  41   fLimit(4),
  42   fCurrent(0),
  43   fDdlOff(0),
  44   fSiOff(0),
  45   fQdcOff(0),
  46   fDdlSize(0),
  47   fFileHeader(0),
  48   fEventHeader(0),
  49   fEventData(0),
  50   fNSi1(0),
  51   fNSi2(0),
  52   fCher(0),
  53   fPb(0)
  54 {
  55
  56 }
  57 //____________________________________________________________________________
  58 AliTRDtestBeam::AliTRDtestBeam(const char *filename) :
  59   fDataStream(0),
  60   fHeaderIsRead(0),
  61   fEventCount(0),
  62   fLimit(4),
  63   fCurrent(0),
  64   fDdlOff(0),
  65   fSiOff(0),
  66   fQdcOff(0),
  67   fDdlSize(0),
  68   fFileHeader(0),
  69   fEventHeader(0),
  70   fEventData(0),
  71   fNSi1(0),
  72   fNSi2(0),
  73   fCher(0),
  74   fPb(0)
  75 {
  76
  77   fDataStream = new ifstream(filename, ifstream::in | ifstream::binary );
  78   cout << fDataStream->is_open() << endl;
  79   //fHeaderIsRead = kTRUE;
  80   fHeaderIsRead = kTRUE;
  81
  82   fFileHeader = new Char_t[file_head_size];
  83   fEventHeader = new Char_t[event_head_size];
  84   fEventData = new Char_t[fLimit];
  85 }
  86
  87 //____________________________________________________________________________
  88
  89 Int_t AliTRDtestBeam::NextEvent() {
  90
  91   Long_t data_size=0,ldc_off; //,ldc_id,ldc2_id;
  92   Long_t ldc_size,eq_id; //,ev_l2;
  93   Long_t event_nr,ev_l1;
  94   Long_t word;
  95
  96   if ( !fHeaderIsRead ) {
  97     fDataStream->read(fFileHeader, file_head_size);
  98     if(fDataStream->fail()) {
  99       cerr << "Error reading file header! " << endl;
 100       return false;
 101     }
 102     cout  << " Run nr.  " << Int(pos_run, fFileHeader) << endl;
 103     fHeaderIsRead=kTRUE;
 104   }
 105
 106   fDataStream->read(fEventHeader, event_head_size);
 107   if(fDataStream->fail()) {
 108     cerr << "End of file, Event " << fEventCount  << endl;
 109     return false;
 110   }
 111
 112   data_size = Int(pos_length, fEventHeader)-event_head_size; //?
 113   event_nr = Int((4+pos_run), fEventHeader); //ev.nr.
 114   //cout << " Event " << event_nr <<" size "<< data_size <<endl;
 115
 116     if (event_nr <= fEventCount-1) { //watch-out ...event counter starts at 1?
 117       cout << fEventCount << " End of file?, Event " << fEventCount << endl;
 118       return false;
 119     }
 120     //cout <<  "Run " << Int(pos_run, header)<< " , Event " <<event_nr <<endl;
 121
 122     // enough space for data?
 123     if (fLimit < data_size) {
 124       delete[] fEventData;
 125       fEventData = new Char_t[data_size];
 126       fLimit = data_size;
 127     }
 128
 129     fDataStream->read(fEventData, data_size);
 130
 131     if(fDataStream->fail()) {
 132       cerr << "End of file, Event " << fEventCount; // << endl;
 133         return false;
 134     }
 135
 136     //cout  << " ...IDs (size) : ";
 137
 138     ldc_off=0; // size of data from one DDL link
 139
 140     for ( size_t k = 0; k < 2; k++ ) { // 2 LDCs (DDL & VME)
 141
 142       ldc_size = Int(ldc_off+pos_length, fEventData); //
 143       //ldc_size1=(ldc_size-ldc_head_size);
 144       eq_id = Int(ldc_off+ldc_head_size+pos_eqid, fEventData);
 145       //cout  << eq_id <<" ("<<ldc_size<<") ";
 146
 147       ev_l1 = Int((4+ldc_off+pos_run), fEventData); //ev.nr.
 148       if ( ev_l1 != event_nr ){
 149         //cerr << "Eq_id " <<eq_id<<" event nr. mismatch? " << event_nr <<" / "<< ev_l1 <<" ...LDC data size (header:68) " <<ldc_size<<endl;
 150       }
 151
 152       if (eq_id == 1024) {  //DDL data
 153         fDdlOff = ldc_off; //+ldc_head_size+equip_head_size + 32;
 154         fDdlSize = ldc_size;
 155       }
 156
 157       if (eq_id == 550) {  //Si-strip data (+QDC)
 158         //cout << "550" << endl;
 159         fSiOff=ldc_off+ldc_head_size+equip_head_size+pos_sioff;
 160         word = Int(fSiOff, fEventData);
 161         Short_t LenSi1 = (word >> 16) & 0xffff;
 162         Short_t LenSi2 = word & 0xffff;
 163         fQdcOff=fSiOff+4*(LenSi1+LenSi2+1)+equip_head_size+4;
 164       }
 165       else if (eq_id == 1182) {  //QDC first...
 166         //cout << "1182" << endl;
 167         fQdcOff=ldc_off+ldc_head_size+equip_head_size+pos_sioff;
 168         fSiOff=fQdcOff+equip_head_size+4;
 169       }
 170
 171       ldc_off=ldc_size;
 172
 173     }
 174     //cout << endl;
 175
 176     //cout << "DDL = " << fDdlOff << endl;
 177     // cout << "Si  = " << fSiOff << endl;
 178     //cout << "QDC = " << fQdcOff << endl;
 179
 180     DecodeSi();
 181
 182     fEventCount++; //event counter
 183     return true;
 184 }
 185 //____________________________________________________________________________
 186 Int_t AliTRDtestBeam::DecodeSi() {
 187
 188   if (fSiOff < 0) return 0;
 189
 190   // cout << "decoding Si data" << endl;
 191
 192   Long_t word;
 193
 194   word=Int(fSiOff, fEventData);
 195   fNSi1 = (word >> 16) & 0xffff;
 196   fNSi2 = word & 0xffff;
 197
 198   Int_t cSi=fSiOff; //
 199   for (int i = 0; i < fNSi1; i++) {
 200     fSi1Address[i] =  ( Int(cSi, fEventData) >> 12 ) & 0x7ff;
 201     fSi1Charge[i] = Int(cSi, fEventData)  & 0xfff;
 202     cSi+=4;
 203   }
 204
 205   for (int i = 0; i < fNSi2; i++) {  //1,for Date!
 206     fSi2Address[i] =  ( Int(cSi, fEventData) >> 12 ) & 0x7ff;
 207     fSi2Charge[i] = Int(cSi, fEventData)  & 0xfff;
 208     cSi+=4;
 209   }
 210
 211   // reconstruction
 212
 213   int LenSiX = 640;
 214
 215   int qmaxX; int amaxX;
 216   int qmaxY; int amaxY;
 217
 218   qmaxX = 5;
 219   qmaxY = 5;
 220   amaxX = -1;
 221   amaxY = -1+LenSiX;
 222
 223   for( int i = 0; i < GetNSi1(); i++ ) {
 224
 225     if (fSi1Address[i] == 0) continue; // noise
 226
 227     if (fSi1Address[i] < LenSiX ) {
 228       if( fSi1Charge[i] > qmaxX ) {
 229         qmaxX = fSi1Charge[i];
 230         amaxX = fSi1Address[i];
 231       }
 232     } else  {
 233       if( fSi1Charge[i] > qmaxY ) {
 234         qmaxY = fSi1Charge[i];
 235         amaxY = fSi1Address[i];
 236       }
 237     }
 238   }
 239
 240   fX[0] = (float)(amaxX*0.05);  // [mm]
 241   fY[0] = (float)((amaxY-LenSiX)*0.05);
 242   fQx[0] = (float)qmaxX;
 243   fQy[0] = (float)qmaxY;
 244
 245   //
 246   qmaxX = 5;
 247   qmaxY = 5;
 248   amaxX = -1;
 249   amaxY = -1+LenSiX;
 250
 251   for( int i = 0; i < GetNSi2(); i++ ) {
 252
 253     if (fSi2Address[i] == 1279) continue; // noise
 254     if (fSi2Address[i] == 0) continue;    // noise
 255
 256     if(fSi2Address[i] < LenSiX) {
 257       if( fSi2Charge[i] > qmaxX ) {
 258         qmaxX = fSi2Charge[i];
 259         amaxX = fSi2Address[i];
 260       }
 261     } else {
 262       if( fSi2Charge[i] > qmaxY ) {
 263         //if (fSi2Charge[i] > 50) cout << fSi2Charge[i] << " " << i << " " <<  fSi2Address[i] << endl;
 264         qmaxY = fSi2Charge[i];
 265         amaxY = fSi2Address[i];
 266       }
 267     }
 268   }
 269
 270   fX[1] = (float)(amaxX*0.05);  // [mm]
 271   fY[1] = (float)((amaxY-LenSiX)*0.05);
 272   fQx[1] = (float)qmaxX;
 273   fQy[1] = (float)qmaxY;
 274
 275   if (fQdcOff < 0) return 0;
 276
 277   word=Int(fQdcOff, fEventData);
 278   fPb   = (Double_t)((word >> 16) & 0xFFF);
 279   fCher = (Double_t)((word ) & 0xFFF);
 280
 281   //cout << fCher << " " << fPb << endl;
 282   return 1;
 283 }
 284 //____________________________________________________________________________
 285 /**/
 286 AliTRDRawStreamTB *AliTRDtestBeam::GetTRDrawStream() {
 287
 288   // needs AliTRDRawStreamTB
 289   //cout << "Chamber reader:" << (Int_t)(fEventData+fDdlOff) << " " << fDdlSize << endl;
 290   //int ifout = open("dump.dat", O_WRONLY | O_TRUNC | O_CREAT);
 291   //write(ifout, (void*)(fEventData+fDdlOff+16), fDdlSize);
 292   //close(ifout);
 293
 294   AliRawReaderMemory *reader = new AliRawReaderMemory((UChar_t*)(fEventData+fDdlOff), (UInt_t)fDdlSize);
 295   reader->SetEquipmentID(1024);
 296   reader->ReadHeader();
 297   AliTRDRawStreamTB::RawBufferMissAligned(kTRUE);
 298   AliTRDRawStreamTB::SupressWarnings(kTRUE);
 299
 300   AliTRDRawStreamTB *tb = new AliTRDRawStreamTB(reader);
 301   tb->Init();
 302   return tb;
 303   /*
 304     return
 305
 306     AliRawReaderMemory *rmem = data->GetRawReader();
 307     rmem->ReadHeader();
 308
 309     AliTRDRawStreamTB tb(rmem);
 310     tb.Init();
 311     AliTRDRawStreamTB::SupressWarnings(kTRUE);
 312
 313   */
 314 }
 315 /**/
 316 //____________________________________________________________________________
 317
 318 Int_t AliTRDtestBeam::Int(Int_t i, Char_t *start) {
 319
 320   bool swap = kFALSE;
 321
 322   if(swap) {
 323     char *q=(char*)(start+i);
 324     char p[] = {q[3], q[2], q[1], q[0]};
 325     return *((int*) p);
 326   } else return *((int*)(start+i));
 327 }
 328
 329 //____________________________________________________________________________