ITS/AliITSspdTestBeam.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 /*
  17   $Id$
  18 */
  19
  20 // A set of classes/routines that can read the SPD test beam data of 2002
  21 // and create AliITSdigits. The posibility to use these routines to do the
  22 // same for later and other detectors has yet to be demonstrated. At present
  23 // there remains a bug in that the TreeE of event headders isn't created
  24 // properly. See the macro AliITSspdTestBeam2Digits.C. The geometry from
  25 // the class AliITSvSPD002 must be read in, one way or the other, so that
  26 // the Geometry transoformation class AliITSgeom will prpoerly be inilized.
  27
  28 #include <stdlib.h>
  29 #include <stddef.h>
  30 #include <iomanip>
  31 #include <Riostream.h>
  32 #include <fstream>
  33 #include <TArrayI.h>
  34
  35 #include "AliITSspdTestBeam.h"
  36
  37 ClassImp(AliITSspdTestBeam)
  38
  39 //----------------------------------------------------------------------
  40 AliITSspdTestBeam::AliITSspdTestBeam(){
  41     // Default Constructor for the Task AliITSspdTestBeam.
  42     // Inputs:
  43     //    none.
  44     // Outputs:
  45     //    none.
  46     // Return:
  47     //     A default constructed AliITSspdTestBeam class
  48
  49     fRH           = 0;
  50     fRT           = 0;
  51     fNBrst        = 0;
  52     fBrstSize     = 0;
  53     fBrst         = 0;
  54     fNData        = 0;
  55     fData         = 0;
  56     fHData        = 0;
  57     fTData        = 0;
  58     SetTerminationWord();
  59     fNEvents      = 0;
  60     fBuffSize     = 0;
  61     fBuff         = 0;
  62     fITS          = 0;
  63     fNfiles       = 0;
  64     fMaxFiles     = 0;
  65     fFiles        = 0;
  66     fNeventsStart = 0;
  67     fNeventsEnd   = 0;
  68 }
  69 //----------------------------------------------------------------------
  70 AliITSspdTestBeam::AliITSspdTestBeam(const Char_t *filename,const Char_t *opt,
  71                                      AliITS *its){
  72     // Standard Constructor for the Task AliITSspdTestBeam.
  73     // Inputs:
  74     //    const Char_t *filename   File where to read in the SPD test beam data
  75     //    const Char_t *opt        Option, 2002 => 2002 test beam data.
  76     // Outputs:
  77     //    none.
  78     // Return:
  79     //     A default constructed AliITSspdTestBeam class
  80
  81     fRH           = 0;
  82     fRT           = 0;
  83     fNBrst        = 0;
  84     fBrstSize     = 0;
  85     fBrst         = 0;
  86     fNData        = 0;
  87     fData         = 0;
  88     fHData        = 0;
  89     fTData        = 0;
  90     SetTerminationWord();
  91     fNEvents      = 0;
  92     fBuffSize     = 0;
  93     fBuff         = 0;
  94     fITS          = 0;
  95     fNfiles       = 0;
  96     fMaxFiles     = 0;
  97     fFiles        = 0;
  98     fNeventsStart = 0;
  99     fNeventsEnd   = 0;
 100     //
 101     fITS          = its;
 102     fNfiles       = 0;
 103     OpenInputFile(filename,0,-1);
 104     if(strcmp(opt,"2002")) cout << "2002 assumed" << endl;
 105 }
 106
 107 //----------------------------------------------------------------------
 108 AliITSspdTestBeam::~AliITSspdTestBeam(){
 109     // Destructor. Frees up any memory allocated or closes any files opened.
 110     // Inputs:
 111     //    none.
 112     // Outputs:
 113     //    none.
 114     // Return:
 115     //     nothing.
 116     Int_t i,np;
 117
 118     np = GetNumberOfPilots();
 119     fRH = 0;  // Just a Pointer into fBuff.
 120     fRT = 0;  // Just a Pointer into fBuff.
 121     if(fBrst){delete[] fBrst; fBrst = 0;}
 122     if(fNData)for(i=0;i<np;i++){
 123         if(fNData[i]) delete[] fNData[i];
 124     } // end if
 125     if(fNData) {delete[] fNData; fNData = 0;}
 126     if(fData)for(i=0;i<np;i++){
 127         if(fData[i]) delete[] fData[i];
 128     } // end if
 129     if(fData) delete[] fData;
 130     fData = 0;
 131     if(fHData)for(i=0;i<np;i++){
 132         if(fHData[i]) delete[] fHData[i];
 133     } // end if
 134     if(fHData) delete[] fHData;
 135     fHData = 0;
 136     if(fTData)for(i=0;i<np;i++){
 137         if(fTData[i]) delete[] fTData[i];
 138     } // end if
 139     if(fTData) delete[] fTData;
 140     fTData = 0;
 141     for(i=0;i<fMaxFiles;i++){
 142         if(fFiles[i]!=0) delete fFiles[i];
 143     } // end for i
 144     if(fBrstSize)for(i=0;i<np;i++){
 145         if(fBrstSize[i]) delete[] fBrstSize[i];
 146     } // end if
 147     if(fBrstSize) {delete[] fBrstSize; fBrstSize = 0;}
 148     delete[] fBuff;
 149     fITS = 0; //delete fITS;
 150     delete[] fFiles;
 151     delete[] fNeventsStart;
 152     delete[] fNeventsEnd;
 153 }
 154 //----------------------------------------------------------------------
 155 Int_t AliITSspdTestBeam::OpenInputFile(const Char_t *filename,Int_t start,Int_t end){
 156     // Opens input file for reading spd test beam data.
 157     // Inputs:
 158     //    const Char_t *filename    file name to read data from
 159     // Outputs:
 160     //    none.
 161     // Return:
 162     //    An error number. 0=success, -1=failure.
 163     Int_t stat = 0,i;
 164
 165     if(fMaxFiles==0) {
 166         fMaxFiles     = 5;
 167         fFiles        = new ifstream*[fMaxFiles];
 168         fNeventsStart = new Int_t[fMaxFiles];
 169         fNeventsEnd   = new Int_t[fMaxFiles];
 170     } // end if
 171     if(fNfiles==fMaxFiles){// Need to expand array of open files.
 172         ifstream **tmp = new ifstream*[fMaxFiles];
 173         TArrayI st(fMaxFiles);
 174         TArrayI  en(fMaxFiles);
 175         for(i=0;i<fMaxFiles;i++) { // copy pointers into tmp
 176             tmp[i]    = fFiles[i];
 177             fFiles[i] = 0;
 178             st[i]     = fNeventsStart[i];
 179             en[i]     = fNeventsEnd[i];
 180         } // end for i
 181         delete fFiles;
 182         fMaxFiles    += 5;  // expand by 5.
 183         fFiles        = new ifstream*[fMaxFiles];
 184         fNeventsStart = new Int_t[fMaxFiles];
 185         fNeventsEnd   = new Int_t[fMaxFiles];
 186         for(i=0;i<fMaxFiles;i++) { // copy pointers back into fFiles
 187             fFiles[i]        = 0;  // and zero rest.
 188             fNeventsStart[i] = 0;
 189             fNeventsEnd[i]   = 0;
 190             if(i<fNfiles) {
 191                 fFiles[i]        = tmp[i];
 192                 tmp[i]           = 0;
 193                 fNeventsStart[i] = st[i];
 194                 fNeventsEnd[i]   = en[i];
 195             } // end if i<fNfiles
 196         } // end for i
 197         // the array of pointers tmp is deleted automatically.
 198         delete [] tmp;
 199     } // end if
 200     // Open file
 201     fFiles[fNfiles] = new ifstream(filename,ios::in|ios::binary);
 202     if(fFiles[fNfiles]==0){// file open error
 203         cout << "Error opening input file " << filename << endl;
 204         stat = -1;
 205         return stat;
 206     } // end if
 207     fNeventsStart[fNfiles] = start;
 208     fNeventsEnd[fNfiles]   = end;
 209     fNfiles++;
 210     return stat;
 211 }
 212 //----------------------------------------------------------------------
 213 Int_t AliITSspdTestBeam::Read(Int_t i){
 214     // Read in one buffer's worth of the file.
 215     // Inputs:
 216     //    Int_t i  Which file from the array of files to be read in.
 217     // Outputs:
 218     //    none.
 219     // Return:
 220     //    size of file.
 221     Int_t filesize=0;
 222
 223     fFiles[i]->seekg(0,ios::end);
 224     filesize  = fFiles[i]->tellg();
 225     fFiles[i]->seekg(0,ios::beg);
 226     if(fBuff) delete[] fBuff;
 227     fBuffSize = filesize;
 228     fBuff     = new UChar_t[fBuffSize];
 229     fFiles[i]->read((Char_t*)fBuff,fBuffSize);
 230     fFiles[i] ->close();
 231     return filesize;
 232 }
 233 //----------------------------------------------------------------------
 234 Int_t AliITSspdTestBeam::Decode(){
 235     // Decode the fBuff read in.
 236     // Inputs:
 237     //    none.
 238     // Outputs:
 239     //    none.
 240     // Return:
 241     //    sets up the array fData fRH, and fRT
 242     Int_t stat=0;
 243     UInt_t *tr;
 244     union {
 245         UInt_t  *wd;
 246         UChar_t *bt;
 247     }u; // end union
 248     Int_t size;
 249     Int_t *ivnt,iburst,ip,np,i,j;
 250     AliITSspdTestBeamData  *d;
 251     AliITSspdTestBeamBurst *b;
 252
 253     np = GetNumberOfPilots();
 254     ivnt = new Int_t[np];
 255     for(i=0;i<np;i++) ivnt[i] = 0;
 256     fRH  = (AliITSspdTestBeamHeader*) &(fBuff[0]); // Sets up the Run Header.
 257     fRT  = (AliITSspdTestBeamTail*)&(fBuff[fBuffSize-fRT->SizeOf()]);
 258     // Check termination
 259     tr   = (UInt_t*) &(fBuff[fBuffSize-(fRT->SizeOf())-sizeof(UInt_t)]);
 260     if(!(*tr==fTermination)){
 261         cout << "Error Termination word not found at "<<tr<<endl;
 262         exit(-1);
 263     } // end if
 264     if(fNData)for(i=0;i<np;i++){
 265         if(fNData[i]) delete[] fNData[i];
 266     } // end if
 267     if(fNData) {delete[] fNData; fNData = 0;}
 268     if(fData)for(i=0;i<np;i++){
 269         if(fData[i]) delete[] fData[i];
 270     } // end if
 271     if(fData) {delete[] fData; fData = 0;}
 272     if(fHData)for(i=0;i<np;i++){
 273         if(fHData[i]) delete[] fHData[i];
 274     } // end if
 275     if(fHData) {delete[] fHData; fHData = 0;}
 276     if(fTData)for(i=0;i<np;i++){
 277         if(fTData[i]) delete[] fTData[i];
 278     } // end if
 279     if(fTData) {delete[] fTData; fTData = 0;}
 280     if(fBrstSize)for(i=0;i<np;i++){
 281         if(fBrstSize[i]) delete[] fBrstSize[i];
 282     } // end if
 283     if(fBrstSize) {delete[] fBrstSize; fBrstSize = 0;}
 284     fNEvents  = fRH->GetNumberOfEvents();
 285     fNBrst    = fNEvents/fRH->GetBurstSize();
 286     fBrst     = new AliITSspdTestBeamBurst*[fNBrst];
 287     fBrstSize = new Int_t*[np];
 288     fNData    = new Int_t*[np];
 289     fData     = new AliITSspdTestBeamData**[np];
 290     fHData    = new AliITSspdTestBeamData**[np];
 291     fTData    = new AliITSspdTestBeamData**[np];
 292     for(i=0;i<np;i++){
 293         fBrstSize[i] = new Int_t[fNBrst];
 294         fNData[i]    = new Int_t[fNEvents];
 295         fData[i]     = new AliITSspdTestBeamData*[fNEvents];
 296         fHData[i]    = new AliITSspdTestBeamData*[fNEvents];
 297         fTData[i]    = new AliITSspdTestBeamData*[fNEvents];
 298         for(j=0;j<fNEvents;j++){
 299             fNData[i][j] = 0;
 300             fData[i][j]  = 0;
 301             fHData[i][j] = 0;
 302             fTData[i][j] = 0;
 303         } // end for j
 304     } // end for i
 305     if(fBrst){delete[] fBrst; fBrst = 0;}
 306     size      = fRH->SizeOf();
 307     u.bt      = &fBuff[size];
 308     //
 309     for(iburst=0;(*(u.wd) != fTermination)&&(u.wd<tr);iburst++){ // loop over Bursts
 310         b   = (AliITSspdTestBeamBurst *) u.wd;
 311         fBrst[iburst] = b;
 312         u.bt += b->SizeOf(); // increment wd byte wise
 313         for(ip=0;ip<np;ip++){  // loop over pilots
 314             // Get size of data stored for this pilot.
 315             fBrstSize[ip][iburst] = (UInt_t) u.wd;
 316             u.bt += sizeof(UInt_t); // increment wd byte wise
 317             for(i=0;i<fBrstSize[ip][iburst];i++){ // loop over data
 318                 d = (AliITSspdTestBeamData *) u.wd;
 319                 switch (d->Mode()){
 320                 case AliITSTestBeamData::kData :
 321                     fNData[ip][ivnt[ip]]++;
 322                     // set pointer to first data member
 323                     if(fData[ip][ivnt[ip]] == 0 ) fData[ip][ivnt[ip]] = d;
 324                     break;
 325                 case AliITSTestBeamData::kHead :
 326                     fNData[ip][ivnt[ip]]   = 0;
 327                     fData[ip][ivnt[ip]]    = 0;
 328                     fHData[ip][ivnt[ip]++] = d;
 329                     break;
 330                 case AliITSTestBeamData::kTail  :
 331                 case AliITSTestBeamData::kAbort :
 332                     fTData[ip][ivnt[ip]] = d;
 333                     break;
 334                 default:
 335                     cout << "Unknown Data Type: wd="<<hex<<*(u.wd)<<dec<<endl;
 336                     break;
 337                 } // end switch
 338                 u.bt += d->SizeOf(); // increment wd byte wise
 339             } // end for i (next data word).
 340         } // end for loop over pilots (ip).
 341     } // end for loop over bursts
 342     delete[] ivnt;
 343     return stat;
 344 }
 345 //============================================================================
 346 void AliITSspdTestBeamHeader::Print(ostream *os)const{
 347     // print out the header information
 348     // Inputs:
 349     //    ostream *os  Pointer to the output stream.
 350     // Outputs:
 351     //    none.
 352     // Return:
 353     //    none.
 354 /*
 355 #if defined __GNUC__
 356 #if __GNUC__ > 2
 357     ios::fmtflags fmt;
 358 #else
 359     Int_t fmt;
 360 #endif
 361 #else
 362 #if defined __ICC || defined __ECC
 363     ios::fmtflags fmt;
 364 #else
 365     Int_t fmt;
 366 #endif
 367 #endif
 368 */
 369     *os<<"Version: "<<fUnion.fHead.fVersion<<" Written: "<<fUnion.fHead.fDate;
 370     *os<<" " << fUnion.fHead.fTime << endl;
 371     *os<<"Buffer Size [0], [1], [2]: " << fUnion.fHead.fBuffSize[0] << ",";
 372     *os<<fUnion.fHead.fBuffSize[1]<<"," <<fUnion.fHead.fBuffSize[2] << endl;
 373     *os<<"Test Pulse: " << fUnion.fHead.fTestPulse << endl;
 374     *os<<"Trigger Mode General, [0], [1], [2]: " << fUnion.fHead.fTriggerMode;
 375     *os<<","<<fUnion.fHead.fTrigger[0]<<","<<fUnion.fHead.fTrigger[1]<< ",";
 376     *os<<fUnion.fHead.fTrigger[2] << endl;
 377     *os<<"Number of Events: " << fUnion.fHead.fNEvents << " Burst Size: ";
 378     *os<<fUnion.fHead.fBurstSize << endl;
 379     return;
 380 }
 381 //----------------------------------------------------------------------
 382 ostream &operator<<(ostream &os,AliITSspdTestBeamHeader &p){
 383     // Standard output operator. See Print
 384     // Inputs:
 385     //    ostream                 &os  the output stream.
 386     //    AliITSspdTestBeamHeader &p   the data to be printed out.
 387     // Outputs:
 388     //    none.
 389     // Return:
 390     //    ostream &os pointing now to the end of the present stream.
 391
 392     p.Print(&os);
 393     return os;
 394 }
 395 //============================================================================
 396 void AliITSspdTestBeamTail::Print(ostream *os)const{
 397     // print out the Tail information
 398     // Inputs:
 399     //    ostream *os  Pointer to the output stream.
 400     // Outputs:
 401     //    none.
 402     // Return:
 403     //    none.
 404 /*
 405 #if defined __GNUC__
 406 #if __GNUC__ > 2
 407     ios::fmtflags fmt;
 408 #else
 409     Int_t fmt;
 410 #endif
 411 #else
 412 #if defined __ICC || defined __ECC
 413     ios::fmtflags fmt;
 414 #else
 415     Int_t fmt;
 416 #endif
 417 #endif
 418 */
 419     *os << "Number of Events: "<< fUnion.fTail.fEvents << " Written: "
 420         << fUnion.fTail.fDate;
 421     *os << " " << fUnion.fTail.fTime << endl;
 422     *os <<"Termination Flag: " << fUnion.fTail.fTermMode << endl;
 423     return;
 424 }
 425 //----------------------------------------------------------------------
 426 ostream &operator<<(ostream &os,AliITSspdTestBeamTail &p){
 427     // Standard output operator. See Print
 428     // Inputs:
 429     //    ostream                 &os  the output stream.
 430     //    AliITSspdTestBeamHeader &p   the data to be printed out.
 431     // Outputs:
 432     //    none.
 433     // Return:
 434     //    ostream &os pointing now to the end of the present stream.
 435
 436     p.Print(&os);
 437     return os;
 438 }
 439 //============================================================================
 440 void AliITSspdTestBeamBurst::Print(ostream *os)const{
 441     // print out the Burst information
 442     // Inputs:
 443     //    ostream *os  Pointer to the output stream.
 444     // Outputs:
 445     //    none.
 446     // Return:
 447     //    none.
 448 /*
 449 #if defined __GNUC__
 450 #if __GNUC__ > 2
 451     ios::fmtflags fmt;
 452 #else
 453     Int_t fmt;
 454 #endif
 455 #else
 456 #if defined __ICC || defined __ECC
 457     ios::fmtflags fmt;
 458 #else
 459     Int_t fmt;
 460 #endif
 461 #endif
 462 */
 463     *os << "Burst Number: "<< fUnion.fBrst.fNumber << " Transfers: "
 464         << fUnion.fBrst.fTransfers << endl;
 465     return;
 466 }
 467 //----------------------------------------------------------------------
 468 ostream &operator<<(ostream &os,AliITSspdTestBeamBurst &p){
 469     // Standard output operator. See Print
 470     // Inputs:
 471     //    ostream                 &os  the output stream.
 472     //    AliITSspdTestBeamHeader &p   the data to be printed out.
 473     // Outputs:
 474     //    none.
 475     // Return:
 476     //    ostream &os pointing now to the end of the present stream.
 477
 478     p.Print(&os);
 479     return os;
 480 }
 481 //======================================================================
 482 void AliITSspdTestBeamData::Print(ostream *os)const{
 483     // print out the the Test Beam Data information
 484     // Inputs:
 485     //    ostream *os  Pointer to the output stream.
 486     // Outputs:
 487     //    none.
 488     // Return:
 489     //    none.
 490 /*
 491 #if defined __GNUC__
 492 #if __GNUC__ > 2
 493     ios::fmtflags fmt;
 494 #else
 495     Int_t fmt;
 496 #endif
 497 #else
 498 #if defined __ICC || defined __ECC
 499     ios::fmtflags fmt;
 500 #else
 501     Int_t fmt;
 502 #endif
 503 #endif
 504 */
 505     *os << "Word=" << hex << fUnion.fBuf[0] << hex << fUnion.fBuf[1]
 506                    << hex << fUnion.fBuf[2] << hex << fUnion.fBuf[3] << dec;
 507     switch (this->Mode()){
 508     case AliITSTestBeamData::kData :
 509         *os << " kData chip=" << setw(3) << fUnion.fDataD.fChip;
 510         *os << " Row="        << setw(3) << fUnion.fDataD.fRow;
 511         *os << " Column="     << setw(3) << fUnion.fDataD.fColm;
 512         break;
 513     case AliITSTestBeamData::kHead :
 514         *os << " kHead Event Sync =" << fUnion.fDataH.fEventSync;
 515         break;
 516     case AliITSTestBeamData::kTail  :
 517         *os << " kTail Transmitted word count =" << fUnion.fDataT.fTrans;
 518         break;
 519     case AliITSTestBeamData::kAbort :
 520         *os << " kAbort Transmitted word count =" << fUnion.fDataA.fTrans;
 521         break;
 522     default:
 523         *os << " Unknown Data Type";
 524         break;
 525     } // end switch
 526     *os << endl;
 527     return;
 528 }
 529 //----------------------------------------------------------------------
 530 ostream &operator<<(ostream &os,AliITSspdTestBeamData &p){
 531     // Standard output operator. See Print
 532     // Inputs:
 533     //    ostream                 &os  the output stream.
 534     //    AliITSspdTestBeamHeader &p   the data to be printed out.
 535     // Outputs:
 536     //    none.
 537     // Return:
 538     //    ostream &os pointing now to the end of the present stream.
 539
 540     p.Print(&os);
 541     return os;
 542 }