T0/AliT0RawReader.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 /* $Id:  */
  17
  18 //____________________________________________________________________
  19 //
  20 // T0
  21 // Class for reading T0 RAW data in TOF data format
  22 //
  23 #include "AliT0RawReader.h"
  24 #include "AliT0Parameters.h"
  25 #include "AliBitPacking.h"
  26 #include "TBits.h"
  27
  28 #include <Riostream.h>
  29 #include "TMath.h"
  30 #include "TH1F.h"
  31 #include "TArrayI.h"
  32 #include "AliLog.h"
  33
  34 ClassImp(AliT0RawReader)
  35
  36   AliT0RawReader::AliT0RawReader (AliRawReader *rawReader, Bool_t isOnline)
  37     :  TTask("T0RawReader","read raw T0 data"),
  38        fRawReader(rawReader),
  39        fData(NULL),
  40        fPosition(0),
  41        fParam(NULL),
  42        fIsOnline(isOnline)
  43 {
  44   //
  45 // create an object to read T0raw digits
  46   AliDebug(1,"Start ");
  47
  48   fRawReader->Reset();
  49   fRawReader->Select("T0");
  50   fParam = AliT0Parameters::Instance();
  51   if (fIsOnline)
  52     fParam->InitIfOnline();
  53   else
  54     fParam->Init();
  55
  56 }
  57  AliT0RawReader::~AliT0RawReader ()
  58 {
  59   //
  60 }
  61 /*
  62 AliT0RawReader::AliT0RawReader(const AliT0RawReader& o): TTask(o),
  63      fRawReader(rawReader),
  64        fData(NULL),
  65        fPosition(0)
  66 {
  67   //
  68 }
  69 */
  70
  71
  72 Bool_t  AliT0RawReader::Next()
  73 {
  74 // read the next raw digit
  75 // returns kFALSE if there is no digit left
  76 //"LookUpTable":
  77 // Amplitude LED TRM=0; chain=0; TDC 0 -5        channel 0,2,4,6
  78 // Time CFD      TRM=0; chain=0; TDC 6 - 11      channel 0,2,4,6
  79 // mean time     TRM=0; chain=0; TDC 12          channel 0
  80 // T0A           TRM=0; chain=0; TDC 12          channel 2
  81 // T0C           TRM=0; chain=0; TDC 12          channel 4
  82 // vertex        TRM=0; chain=0; TDC 12          channel 6
  83 // mult QTC0        TRM=0; chain=0; TDC 13          channel 0
  84 // mult QTC1        TRM=0; chain=0; TDC 13          channel 2
  85
  86 // Charge QTC0   TRM=1; chain=0; TDC 0 -5        channel 0,2,4,6
  87 // Charge QTC1   TRM=1; chain=0; TDC 6 - 11      channel 0,2,4,6
  88 // T0A trigger          TRM=1; chain=0; TDC 12          channel 0
  89 // T0C trigger          TRM=1; chain=0; TDC 12          channel 2
  90 // vertex trigger       TRM=1; chain=0; TDC 12          channel 4
  91 // trigger central      TRM=1; chain=0; TDC 13          channel 0
  92 // tigger semicenral    TRM=1; chain=0; TDC 13          channel 2
  93 //
  94 // allData array collect data from all channels in one :
  95 // allData[0] - allData[23] 24 CFD channels
  96 // allData[24] -   allData[47] 24 LED channels
  97 //  allData[48]  mean (T0) signal
  98 // allData[49]   time difference (vertex)
  99
 100
 101   UInt_t word;
 102   Int_t time=0,  itdc=0, ichannel=0, uu;
 103   Int_t numberOfWordsInTRM=0, iTRM=0;
 104   Int_t tdcTime, koef,hit=0;
 105   Int_t koefhits[110];
 106   Int_t trm_chain_header =  0x00000000;
 107   Int_t  trm_chain_trailer =  0x10000000;
 108
 109   UInt_t  filler =  0x70000000;
 110   Bool_t correct=kTRUE;
 111   Int_t header;
 112
 113    Int_t fNTRM = fParam->GetNumberOfTRMs();
 114    for ( Int_t k=0; k<110; k++) {
 115     koefhits[k]=0;
 116     for ( Int_t jj=0; jj<5; jj++) {
 117       fAllData[k][jj]=0;
 118      }
 119    }
 120     do {
 121       if (!fRawReader->ReadNextData(fData)) return kFALSE;
 122     } while (fRawReader->GetDataSize() == 0);
 123
 124     fPosition = 0;
 125      cout.setf( ios_base::hex, ios_base::basefield );
 126
 127     //DRM header
 128     for (Int_t i=0; i<6; i++) {
 129       word = GetNextWord();
 130       //      cout<<" DRM header "<<word<<endl;
 131       header = AliBitPacking::UnpackWord(word,28,31);
 132       if( header !=4 )
 133         {
 134           AliWarning(Form(" !!!! wrong  DRM header  %x!!!!", word));
 135           fRawReader->AddFatalErrorLog(kWrongDRMHeader,Form("w=%x",word));
 136           break;
 137         }
 138     }
 139     //    cout<<"   fNTRM "<<fNTRM<<endl;
 140     for (Int_t ntrm=0; ntrm< fNTRM; ntrm++)
 141       {
 142         //TRMheader
 143         word = GetNextWord();
 144         header = AliBitPacking::UnpackWord(word,28,31);
 145         //      cout<<" TRM header "<<word<<endl;
 146         if ( header != 4 )
 147           {
 148             AliWarning(Form(" !!!! wrong TRM header  %x!!!!", word));
 149             fRawReader->AddMajorErrorLog(kWrongTRMHeader,Form("w=%x",word));
 150             break;
 151           }
 152         numberOfWordsInTRM=AliBitPacking::UnpackWord(word,4,16);
 153         //      cout<<" numberOfWordsInTRM "<<numberOfWordsInTRM<<endl;
 154         iTRM=AliBitPacking::UnpackWord(word,0,3);
 155         for( Int_t ichain=0; ichain<2; ichain++)
 156           {
 157             //chain header
 158             word = GetNextWord();
 159             //      cout<<" chain header "<<word<<endl;
 160             uu = word & trm_chain_header;
 161             if(uu != trm_chain_header)
 162               {
 163                 AliWarning(Form(" !!!! wrong CHAIN  0  header %x!!!!", word));
 164                 fRawReader->AddMajorErrorLog(kWrongChain0Header,Form("w=%x",word));
 165                 break;
 166               }
 167             word = GetNextWord();
 168 //          cout<<" next "<<word<<endl;
 169             tdcTime =  AliBitPacking::UnpackWord(word,31,31);
 170             //      for (; tdcTime==1; tdcTime)
 171             while(tdcTime==1)
 172               {
 173                 correct = kTRUE;
 174                 //                      cout<<" packed "<<word<<endl;
 175                 itdc=AliBitPacking::UnpackWord(word,24,27);
 176                 ichannel=AliBitPacking::UnpackWord(word,21,23);
 177                 time=AliBitPacking::UnpackWord(word,0,20);
 178
 179                 koef = fParam->GetChannel(iTRM,itdc,ichain,ichannel);
 180                 if (koef != 0 )
 181                   //              cout<<"RawReader>> "<<"koef "<<koef<<" trm "<<iTRM<<
 182                   //                " tdc "<<itdc<<" chain "<<ichain<<
 183                   //                " channel "<<ichannel<<" time "<<time<<endl;
 184                 if (koef ==-1 ){
 185                   AliWarning(Form("Incorrect lookup table ! "));
 186                   fRawReader->AddMajorErrorLog(kIncorrectLUT);
 187                   correct=kFALSE;
 188                 }
 189                 if(correct){
 190                   hit=koefhits[koef];
 191                   if(hit>5) {
 192                     AliWarning(Form("Too many hits for %i channel - %i ! ",koef,koefhits[koef] ));
 193                     hit=5;
 194                   }
 195                   fAllData[koef][hit]=time;
 196                   koefhits[koef]++;
 197                 }
 198                 word = GetNextWord();
 199                 //              cout<<" next word in cycle "<<word<<endl;
 200                 tdcTime =  AliBitPacking::UnpackWord(word,31,31);
 201
 202               }
 203
 204             //      cout<<" chain trailer "<<word<<endl;
 205             uu = word&trm_chain_trailer;
 206             if(uu != trm_chain_trailer )
 207               {
 208                 AliWarning(Form(" !!!! wrong CHAIN 0 trailer %x !!!!", word));
 209                 fRawReader->AddMajorErrorLog(kWrongChain0Trailer,Form("w=%x",word));
 210                 break;
 211               }
 212           }
 213
 214         word = GetNextWord(); //TRM trailer
 215         //      cout<<" TRM trailer "<<word<<endl;
 216         header = AliBitPacking::UnpackWord(word,28,31);
 217         if( header !=5 )
 218           {
 219             AliWarning(Form(" !!!! wrong TRM GLOBAL trailer  %x!!!!", word));
 220             fRawReader->AddMajorErrorLog(kWrongTRMTrailer,Form("w=%x",word));
 221             break;
 222           }
 223       } //TRM loop
 224     word = GetNextWord(); //
 225     //    cout<<" after TRM trailer "<<word<<endl;
 226     if (word == filler )  word = GetNextWord();
 227      header = AliBitPacking::UnpackWord(word,28,31);
 228      if( header !=5 )
 229        {
 230          AliWarning(Form(" !!!! wrong DRM GLOBAL trailer  %x!!!!", word));
 231          fRawReader->AddFatalErrorLog(kWrongDRMTrailer,Form("w=%x",word));
 232       }
 233      cout.setf( ios_base::dec, ios_base::basefield );
 234
 235      return kTRUE;
 236 }
 237 //_____________________________________________________________________________
 238 Int_t AliT0RawReader::GetPosition()
 239 {
 240   // Sets the position in the
 241   // input stream
 242   if (((fRawReader->GetDataSize() * 8) % 32) != 0)
 243     AliFatal(Form("Incorrect raw data size ! %d words are found !",fRawReader->GetDataSize()));
 244   return (fRawReader->GetDataSize() * 8) / 32;
 245 }
 246 //_____________________________________________________________________________
 247 UInt_t AliT0RawReader::GetNextWord()
 248 {
 249   // Read the next 32 bit word in backward direction
 250   // The input stream access is given by fData and fPosition
 251
 252
 253   //   fPosition--;
 254   Int_t iBit = fPosition * 32;
 255   Int_t iByte = iBit / 8;
 256
 257   UInt_t word = 0;
 258   word  = fData[iByte+3]<<24;
 259   word |= fData[iByte+2]<<16;
 260   word |= fData[iByte+1]<<8;
 261   word |= fData[iByte];
 262    fPosition++;
 263
 264   return word;
 265
 266 }
 267