TOF/AliTOFD.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 $Log$
  18 Revision 1.3  2000/10/02 21:28:17  fca
  19 Removal of useless dependecies via forward declarations
  20
  21 Revision 1.2  2000/05/18 14:33:01  vicinanz
  22 Modified to be full HP compliant
  23
  24 Revision 1.1  2000/05/10 16:52:18  vicinanz
  25 New TOF version with holes for PHOS/RICH
  26
  27 */
  28
  29 #include "AliTOF.h"
  30 #include "AliTOFD.h"
  31 #include "TObject.h"
  32
  33 //******************************************************************************
  34
  35 ClassImp(AliTOFRawDigit)
  36
  37 //______________________________________________________________________________
  38 AliTOFRawDigit::AliTOFRawDigit()
  39 //
  40 // Constructor of AliTOFRawDigit class
  41 //
  42 {
  43   fTreeD     = 0;
  44   fRawDigits = 0;
  45 }
  46
  47 //******************************************************************************
  48
  49 ClassImp(AliTOFRoc)
  50
  51 //______________________________________________________________________________
  52 AliTOFRoc::AliTOFRoc()
  53 //
  54 // Constructor of AliTOFRoc class
  55 // The class represents a ROC in the TARODA system
  56 //
  57 {
  58   fItems = 0;
  59   fSize  = 0;
  60 }
  61
  62 //______________________________________________________________________________
  63 AliTOFRoc::~AliTOFRoc(){}
  64
  65 //______________________________________________________________________________
  66 Int_t AliTOFRoc::AddItem(Int_t Fec, Int_t Tdc, Int_t Error,
  67                          Float_t Charge, Float_t Time)
  68 {
  69 //
  70 // Adds an item (i.e. the charge, the TOF and the
  71 // cohordinates of a hit pad) to the ROC class.
  72 //
  73
  74    fItems++;
  75    SetCharge(fItems,Fec,Tdc,Charge);
  76    SetTime  (fItems,Error,Time);
  77    return fItems;
  78 }
  79
  80 //______________________________________________________________________________
  81 void AliTOFRoc::SetHeader()
  82 //
  83 // Calculate the header line of the ROC in the raw data file
  84 //
  85 {
  86    fHeader  = fNRoc<<28;
  87    fHeader += fSize;
  88 }
  89
  90
  91 //______________________________________________________________________________
  92 void AliTOFRoc::SetTime(UInt_t Item, UInt_t Error, Float_t RealTime)
  93 {
  94 //
  95 // Calculate the raw data line relative to the TDC
  96 // output of a pad in the current ROC.
  97 //
  98
  99    UInt_t itime;
 100    itime = (UInt_t)(RealTime/50.);
 101    if (itime >= TMath::Power(2,24)) itime = 2^24-1;
 102    Error <<= 24;
 103    fTimeRow[Item]= Error+itime;
 104 }
 105
 106 //______________________________________________________________________________
 107 void AliTOFRoc::SetCharge(UInt_t Item, UInt_t Fec, UInt_t Tdc, Float_t RealCharge)
 108 {
 109 //
 110 // Calculate the raw data line relative to the ADC
 111 // output of a pad in the current ROC.
 112 //
 113
 114    UInt_t iCharge;
 115    if (fNRoc>=TMath::Power(2,4)) fNRoc = 0;
 116    fNRoc <<= 28;
 117    if (Fec >=TMath::Power(2,6))  Fec = 0;
 118    Fec  <<= 22;
 119    if (Tdc >=TMath::Power(2,6))  Tdc = 0;
 120    Tdc  <<= 16;
 121    iCharge = (UInt_t)(RealCharge/50.);
 122    if(iCharge>=TMath::Power(2,16)) iCharge = (UInt_t)TMath::Power(2,16)-1;
 123    fChrgRow[Item] = iCharge+fNRoc+Fec+Tdc;
 124 }
 125
 126 //______________________________________________________________________________
 127 void AliTOFRoc::SetTime(UInt_t Item, UInt_t tir)
 128 //
 129 // Writes the raw data line relative to the TDC
 130 //
 131 {
 132    fChrgRow[Item]=tir;
 133 }
 134
 135 //______________________________________________________________________________
 136 void AliTOFRoc::SetCharge(UInt_t Item, UInt_t chr)
 137 //
 138 // Writes the raw data line relative to the ADC
 139 //
 140 {
 141    fChrgRow[Item]=chr;
 142 }
 143
 144 //______________________________________________________________________________
 145 Float_t AliTOFRoc::GetCharge(Int_t Item)
 146 {
 147 //
 148 // Reads the effective value of the charge starting
 149 // from the line of the raw data
 150 //
 151
 152    UInt_t  icharge  = fChrgRow[Item]&0x0000ffff;
 153    Float_t charge = (Float_t)icharge*50.;
 154    return charge;
 155 }
 156
 157 //______________________________________________________________________________
 158 Float_t AliTOFRoc::GetTime(Int_t Item, UInt_t& Error)
 159 {
 160 //
 161 // Reads the effective value of the time of flight starting
 162 // from the line of the raw data
 163 //
 164
 165    UInt_t  itime  = fTimeRow[Item]&0x00ffffff;
 166    Float_t time = (Float_t)itime*50.;
 167    Error = fTimeRow[Item]>>24;
 168    return time;
 169 }
 170
 171 //______________________________________________________________________________
 172 Int_t AliTOFRoc::GetTotPad(Int_t Item)
 173 {
 174 //
 175 // Reads the cohordinates of the pad starting
 176 // from the line of the raw data
 177 //
 178
 179    UInt_t nRoc = (fChrgRow[Item]&0xf0000000)>>28;
 180    UInt_t nFec = (fChrgRow[Item]&0x0fc00000)>>22;
 181    UInt_t nTdc = (fChrgRow[Item]&0x003f0000)>>16;
 182    UInt_t pad = nRoc*32*32+nFec*32+nTdc;
 183    return pad;
 184 }
 185
 186 //______________________________________________________________________________
 187 UInt_t AliTOFRoc::GetCheckSum()
 188 {
 189 //
 190 // Calculate the checksum word of the current ROC
 191 //
 192
 193    UInt_t checkSum=0;
 194    for(Int_t i=0; i<fItems; i++){
 195       checkSum += BitCount(GetChrgRow(i));
 196       checkSum += BitCount(GetTimeRow(i));
 197    }
 198    return checkSum;
 199 }
 200
 201 //______________________________________________________________________________
 202 UInt_t AliTOFRoc::BitCount(UInt_t x)
 203 {
 204 //
 205 // Count the "1" bit in the current word
 206 //
 207
 208    UInt_t count=0;
 209    for (count=0; x!=0; x>>=1){
 210       if(x&0x00000001) count++;
 211    }
 212    return count;
 213 }
 214
 215 //______________________________________________________________________________
 216 UInt_t AliTOFRoc::SetSize()
 217 {
 218 //
 219 // Reads the size of data from current ROC starting
 220 // from the header line of the raw data
 221 //
 222
 223    fSize = fHeader&0x0000ffff;
 224    fItems = (fSize-4)/4;
 225    return fSize;
 226 }
 227
 228
 229 //******************************************************************************
 230
 231 ClassImp(AliTOFRawSector)
 232
 233 //______________________________________________________________________________
 234 AliTOFRawSector::AliTOFRawSector()
 235 {
 236 //
 237 // Constructor of AliTOFRawSector class
 238 // Each sector is in effect a
 239 // TClonesArray of 14 AliTOFRoc Objects
 240 //
 241    fRocData = new TClonesArray("AliTOFRoc",14);
 242 }
 243
 244 //______________________________________________________________________________
 245 AliTOFRawSector::~AliTOFRawSector()
 246 {
 247 // destructor of the AliTOFRawSector object
 248 // Here we delete the 14 AliTOFRoc istances
 249 //
 250    if (fRocData) {
 251        fRocData->Delete() ;
 252        delete fRocData;
 253        fRocData = 0;
 254    }
 255 }
 256
 257 //______________________________________________________________________________
 258 void AliTOFRawSector::WriteSector()
 259 {
 260 //
 261 // Starting from the raw data objects writes a binary file
 262 // similar to real raw data.
 263 //
 264
 265     FILE *rawfile;
 266     rawfile = fopen("rawdata.dat","w");
 267
 268 //    fprintf(rawfile,Header);
 269
 270     Int_t nRoc;
 271
 272 // loop on all AliTOFRoc Headers to set them
 273     for(nRoc=1; nRoc<=14; nRoc++){
 274        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
 275        currentRoc->SetHeader();
 276        //       UInt_t RocHeader = currentRoc->fHeader;
 277 //      fprintf(rawfile,RocHeader);
 278     }
 279
 280     for(nRoc=1; nRoc<=14; nRoc++){
 281        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
 282        Int_t rocItems = currentRoc->GetItems();
 283
 284        for(Int_t nItem=1; nItem<=rocItems;nItem++){
 285          //          UInt_t TimeRow = currentRoc->GetTimeRow(nItem);
 286 //          fprintf(rawfile,TimeRow);
 287           //          UInt_t ChrgRow = currentRoc->GetTimeRow(nItem);
 288 //          fprintf(rawfile,ChrgRow);
 289        }
 290     }
 291
 292     //    UInt_t EndOfSector = GlobalCheckSum;
 293 //    fprintf(rawfile,EndOfSector);
 294 }
 295
 296 //______________________________________________________________________________
 297 void AliTOFRawSector::ReadSector()
 298 {
 299 //
 300 // Starting from raw data initialize and write the
 301 // Raw Data objects
 302 //(i.e. a TClonesArray of 18 AliTOFRawSector)
 303 //
 304
 305     FILE *rawfile;
 306     rawfile = fopen("rawdata.dat","r");
 307
 308 //    fscanf(rawfile,Header);
 309 //    fscanf(rawfile,Header);
 310     Int_t nRoc;
 311
 312     for(nRoc=1; nRoc<=14; nRoc++){
 313        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
 314        UInt_t rocHeader;
 315        fscanf(rawfile,"%u",&rocHeader);
 316        currentRoc->SetHeader(rocHeader);
 317     }
 318
 319 //      UInt_t SCMWord;
 320 //      fscanf(rawfile,"%u",SCMWord);
 321
 322     for(nRoc=1; nRoc<=14; nRoc++){
 323        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
 324        //       Int_t Size = currentRoc->SetSize();
 325        Int_t nItems = currentRoc->GetItems();
 326        for(Int_t nrow=0; nrow<=nItems; nrow++){
 327           UInt_t charRow,timeRow;
 328           fscanf(rawfile,"%u",&charRow);
 329           currentRoc->SetTime(nrow, charRow);
 330           fscanf(rawfile,"%u",&timeRow);
 331           currentRoc->SetTime(nrow, timeRow);
 332        }
 333          Int_t FinalWord;
 334          fscanf(rawfile,"%d",&FinalWord);
 335     }
 336 //    fscanf(rawfile,GlobalCheckSum);
 337 }
 338