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