X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=TRD%2FAliTRDrawData.cxx;h=478ece5ceed0517c08c7e4b819832d628e5dcf7f;hb=2caed5640033fb1732ee0834bd227d86ddd0acc5;hp=b510e973f550a39a195f7a381b34d63db70c9675;hpb=362c9d61708912a81d77cb017e1d05fd1f9486a6;p=u%2Fmrichter%2FAliRoot.git diff --git a/TRD/AliTRDrawData.cxx b/TRD/AliTRDrawData.cxx index b510e973f55..478ece5ceed 100644 --- a/TRD/AliTRDrawData.cxx +++ b/TRD/AliTRDrawData.cxx @@ -22,40 +22,51 @@ /////////////////////////////////////////////////////////////////////////////// #include +#include + +#include "AliDAQ.h" +#include "AliRawDataHeader.h" +#include "AliRawReader.h" +#include "AliLog.h" #include "AliTRDrawData.h" #include "AliTRDdigitsManager.h" #include "AliTRDgeometry.h" #include "AliTRDdataArrayI.h" #include "AliTRDRawStream.h" -#include "AliRawDataHeader.h" -#include "AliRawReader.h" #include "AliTRDCommonParam.h" #include "AliTRDcalibDB.h" -#include "AliDAQ.h" ClassImp(AliTRDrawData) //_____________________________________________________________________________ -AliTRDrawData::AliTRDrawData():TObject() +AliTRDrawData::AliTRDrawData() + :TObject() + ,fRawVersion(1) // Default Raw Data version set here + ,fCommonParam(0) + ,fCalibration(0) + ,fGeo(0) + ,fNumberOfDDLs(0) { // // Default constructor // - fDebug = 0; - } //_____________________________________________________________________________ -AliTRDrawData::AliTRDrawData(const AliTRDrawData &r):TObject() +AliTRDrawData::AliTRDrawData(const AliTRDrawData &r) + :TObject(r) + ,fRawVersion(1) // Default Raw Data version set here + ,fCommonParam(0) + ,fCalibration(0) + ,fGeo(0) + ,fNumberOfDDLs(0) { // - // AliTRDrawData copy constructor + // Copy constructor // - ((AliTRDrawData &) r).Copy(*this); - } //_____________________________________________________________________________ @@ -68,31 +79,88 @@ AliTRDrawData::~AliTRDrawData() } //_____________________________________________________________________________ -AliTRDrawData &AliTRDrawData::operator=(const AliTRDrawData &r) +Bool_t AliTRDrawData::SetRawVersion(Int_t v) { // - // Assignment operator + // Set the raw data version (Currently only version 0, 1 and 2 are available) // - if (this != &r) ((AliTRDrawData &) r).Copy(*this); - return *this; + if ( (v >= 0) && (v <= 2) ) { + fRawVersion = v; + return kTRUE; + } + + return kFALSE; } //_____________________________________________________________________________ -void AliTRDrawData::Copy(TObject &r) const +Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree, TTree *tracks ) { // - // Copy function + // Initialize necessary parameters and call one + // of the raw data simulator selected by SetRawVersion. + // + // Currently tracklet output is not spported yet and it + // will be supported in higher version simulator. // - ((AliTRDrawData &) r).fDebug = fDebug; + fNumberOfDDLs = AliDAQ::NumberOfDdls("TRD"); + + AliTRDdigitsManager* digitsManager = new AliTRDdigitsManager(); + + if (!digitsManager->ReadDigits(digitsTree)) { + delete digitsManager; + return kFALSE; + } + + if (tracks != NULL) { + delete digitsManager; + AliError("Tracklet input is not supported yet."); + return kFALSE; + } + + fGeo = new AliTRDgeometry(); + + fCommonParam = AliTRDCommonParam::Instance(); + if (!fCommonParam) { + AliError("Could not get common params"); + delete fGeo; + delete digitsManager; + return kFALSE; + } + + fCalibration = AliTRDcalibDB::Instance(); + if (!fCalibration) { + AliError("Could not get calibration object"); + delete fGeo; + delete digitsManager; + return kFALSE; + } + + Int_t retval = kTRUE; + + // Call appropriate Raw Simulator + if ( fRawVersion == 0 ) retval = Digits2RawV0(digitsManager); + else if ( fRawVersion > 0 && fRawVersion <= 2 ) retval = Digits2RawVx(digitsManager); + else { + retval = kFALSE; + AliWarning(Form("Unsupported raw version (fRawVersion=%d).",fRawVersion)); + } + + // Cleanup + delete fGeo; + delete digitsManager; + + return retval; } //_____________________________________________________________________________ -Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree) +Bool_t AliTRDrawData::Digits2RawV0(AliTRDdigitsManager* digitsManager) { + // + // Bogdan's raw simulator (offline use only) // // Convert the digits to raw data byte stream. The output is written // into the the binary files TRD_.ddl. @@ -111,54 +179,26 @@ Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree) // Data bank // - const Int_t kNumberOfDDLs = AliDAQ::NumberOfDdls("TRD"); const Int_t kSubeventHeaderLength = 8; const Int_t kSubeventDummyFlag = 0xBB; Int_t headerSubevent[3]; - ofstream *outputFile[kNumberOfDDLs]; - UInt_t bHPosition[kNumberOfDDLs]; - Int_t ntotalbyte[kNumberOfDDLs]; + ofstream **outputFile = new ofstream* [fNumberOfDDLs]; + UInt_t *bHPosition = new UInt_t [fNumberOfDDLs]; + Int_t *ntotalbyte = new Int_t [fNumberOfDDLs]; Int_t nbyte = 0; Int_t npads = 0; unsigned char *bytePtr; unsigned char *headerPtr; - AliTRDdigitsManager* digitsManager = new AliTRDdigitsManager(); - digitsManager->SetDebug(fDebug); - - // Read in the digit arrays - if (!digitsManager->ReadDigits(digitsTree)) { - delete digitsManager; - return kFALSE; - } - - AliTRDgeometry *geo = new AliTRDgeometry(); AliTRDdataArrayI *digits; - - AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance(); - if (!commonParam) - { - printf(" "); - printf("Could not get common params\n"); - return 0; - } - - AliTRDcalibDB* calibration = AliTRDcalibDB::Instance(); - if (!calibration) - { - printf(" "); - printf("Could not get calibration object\n"); - return kFALSE; - } - - // the event header - AliRawDataHeader header; + AliRawDataHeader header; // The event header // Open the output files - for (Int_t iDDL = 0; iDDL < kNumberOfDDLs; iDDL++) { + for (Int_t iDDL = 0; iDDL < fNumberOfDDLs; iDDL++) { + char name[20]; - strcpy(name,AliDAQ::DdlFileName("TRD",iDDL)); + sprintf(name, "TRD_%d.ddl", iDDL + AliTRDRawStream::kDDLOffset); #ifndef __DECCXX outputFile[iDDL] = new ofstream(name, ios::binary); #else @@ -167,20 +207,21 @@ Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree) // Write a dummy data header bHPosition[iDDL] = outputFile[iDDL]->tellp(); - outputFile[iDDL]->write((char*)(&header),sizeof(header)); + outputFile[iDDL]->write((char *) (& header),sizeof(header)); ntotalbyte[iDDL] = 0; + } // Loop through all detectors for (Int_t det = 0; det < AliTRDgeometry::Ndet(); det++) { - Int_t cham = geo->GetChamber(det); - Int_t plan = geo->GetPlane(det); - Int_t sect = geo->GetSector(det); - Int_t rowMax = commonParam->GetRowMax(plan,cham,sect); - Int_t colMax = commonParam->GetColMax(plan); - Int_t timeTotal = calibration->GetNumberOfTimeBins(); - Int_t bufferMax = rowMax*colMax*timeTotal; + Int_t cham = fGeo->GetChamber(det); + Int_t plan = fGeo->GetPlane(det); + Int_t sect = fGeo->GetSector(det); + Int_t rowMax = fCommonParam->GetRowMax(plan,cham,sect); + Int_t colMax = fCommonParam->GetColMax(plan); + Int_t timeTotal = fCalibration->GetNumberOfTimeBins(); + Int_t bufferMax = rowMax * colMax * timeTotal; Int_t *buffer = new Int_t[bufferMax]; npads = 0; @@ -192,6 +233,10 @@ Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree) // Get the digits array digits = digitsManager->GetDigits(det); digits->Expand(); + // This is to take care of switched off super modules + if (digits->GetNtime() == 0) { + continue; + } // Loop through the detector pixel for (Int_t col = 0; col < colMax; col++) { @@ -260,9 +305,7 @@ Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree) nbyte++; } - if (fDebug > 1) { - Info("Digits2Raw","det = %d, nbyte = %d (%d)",det,nbyte,bufferMax); - } + AliDebug(1,Form("det = %d, nbyte = %d (%d)",det,nbyte,bufferMax)); // Write the subevent header bytePtr = (unsigned char *) headerSubevent; @@ -275,11 +318,11 @@ Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree) *bytePtr++ = (nbyte >> 16); *bytePtr++ = (npads & 0xff); *bytePtr++ = (npads >> 8); - outputFile[iDDL]->write((char*)headerPtr,kSubeventHeaderLength); + outputFile[iDDL]->write((char *) headerPtr,kSubeventHeaderLength); // Write the buffer to the file bytePtr = (unsigned char *) buffer; - outputFile[iDDL]->write((char*)bytePtr,nbyte); + outputFile[iDDL]->write((char *) bytePtr,nbyte); ntotalbyte[iDDL] += nbyte + kSubeventHeaderLength; @@ -287,63 +330,325 @@ Bool_t AliTRDrawData::Digits2Raw(TTree *digitsTree) } - if (fDebug) { - for (Int_t iDDL = 0; iDDL < kNumberOfDDLs; iDDL++) { - Info("Digits2Raw","Total size: DDL %d = %d",iDDL,ntotalbyte[iDDL]); - } - } - // Update the data headers and close the output files - for (Int_t iDDL = 0; iDDL < kNumberOfDDLs; iDDL++) { + for (Int_t iDDL = 0; iDDL < fNumberOfDDLs; iDDL++) { + header.fSize = UInt_t(outputFile[iDDL]->tellp()) - bHPosition[iDDL]; header.SetAttribute(0); // valid data outputFile[iDDL]->seekp(bHPosition[iDDL]); - outputFile[iDDL]->write((char*)(&header),sizeof(header)); + outputFile[iDDL]->write((char *) (&header),sizeof(header)); outputFile[iDDL]->close(); delete outputFile[iDDL]; + } - delete geo; - delete digitsManager; + delete [] outputFile; + delete [] bHPosition; + delete [] ntotalbyte; return kTRUE; +} + +//_____________________________________________________________________________ +Bool_t AliTRDrawData::Digits2RawVx(AliTRDdigitsManager *digitsManager) +{ + // + // Raw data simulator for all versions > 0. This is prepared for real data. + // This version simulate only raw data with ADC data and not with tracklet. + // + + const Int_t kMaxHcWords = (fGeo->TBmax()/3)*fGeo->ADCmax()*fGeo->MCMmax()*fGeo->ROBmaxC1()/2 + 100 + 20; + + // Buffer to temporary store half chamber data + UInt_t *hc_buffer = new UInt_t[kMaxHcWords]; + + // sect is same as iDDL, so I use only sect here. + for (Int_t sect = 0; sect < fGeo->Nsect(); sect++) { + + char name[1024]; + sprintf(name,"TRD_%d.ddl",sect + AliTRDRawStream::kDDLOffset); + +#ifndef __DECCXX + ofstream *of = new ofstream(name, ios::binary); +#else + ofstream *of = new ofstream(name); +#endif + + // Write a dummy data header + AliRawDataHeader header; // the event header + UInt_t hpos = of->tellp(); + of->write((char *) (& header), sizeof(header)); + + // Reset payload byte size (payload does not include header). + Int_t npayloadbyte = 0; + + // GTU common data header (5x4 bytes per super module, shows link mask) + for( Int_t cham = 0; cham < fGeo->Ncham(); cham++ ) { + UInt_t GtuCdh = (UInt_t)(0xe << 28); + for( Int_t plan = 0; plan < fGeo->Nplan(); plan++) { + Int_t iDet = fGeo->GetDetector(plan, cham, sect); + // If chamber status is ok, we assume that the optical link is also OK. + // This is shown in the GTU link mask. + if ( fCalibration->GetChamberStatus(iDet) ) + GtuCdh = GtuCdh | (3 << (2*plan)); + } + of->write((char *) (& GtuCdh), sizeof(GtuCdh)); + npayloadbyte += 4; + } + + // Prepare chamber data + for( Int_t cham = 0; cham < fGeo->Ncham(); cham++) { + for( Int_t plan = 0; plan < fGeo->Nplan(); plan++) { + + Int_t iDet = fGeo->GetDetector(plan,cham,sect); + + // Get the digits array + AliTRDdataArrayI *digits = digitsManager->GetDigits(iDet); + digits->Expand(); + + Int_t hcwords = 0; + + // Process A side of the chamber + if ( fRawVersion >= 1 && fRawVersion <= 2 ) hcwords = ProduceHcDataV1andV2(digits,0,iDet,hc_buffer,kMaxHcWords); + of->write((char *) hc_buffer, hcwords*4); + npayloadbyte += hcwords*4; + + // Process B side of the chamber + if ( fRawVersion >= 1 && fRawVersion <= 2 ) hcwords = ProduceHcDataV1andV2(digits,1,iDet,hc_buffer,kMaxHcWords); + of->write((char *) hc_buffer, hcwords*4); + npayloadbyte += hcwords*4; + + } + } + + // Complete header + header.fSize = UInt_t(of->tellp()) - hpos; + header.SetAttribute(0); // Valid data + of->seekp(hpos); // Rewind to header position + of->write((char *) (& header), sizeof(header)); + of->close(); + delete of; + + } + + delete hc_buffer; + return kTRUE; + +} + +//_____________________________________________________________________________ +Int_t AliTRDrawData::ProduceHcDataV1andV2(AliTRDdataArrayI *digits, Int_t side + , Int_t det, UInt_t *buf, Int_t maxSize) +{ + // + // This function simulates: 1) SM-I commissiong data Oct. 06 (fRawVersion == 1). + // 2) Full Raw Production Version (fRawVersion == 2) + // + // Produce half chamber data (= an ORI data) for the given chamber (det) and side (side) + // where + // + // side=0 means A side with ROB positions 0, 2, 4, 6. + // side=1 means B side with ROB positions 1, 3, 5, 7. + // + // Chamber type (C0 orC1) is determined by "det" automatically. + // Appropriate size of buffer (*buf) must be prepared prior to calling this function. + // Pointer to the buffer and its size must be given to "buf" and "maxSize". + // Return value is the number of valid data filled in the buffer in unit of 32 bits + // UInt_t words. + // If buffer size if too small, the data is truncated with the buffer size however + // the function will finish without crash (this behaviour is similar to the MCM). + // + + Int_t nw = 0; // Number of written words + Int_t of = 0; // Number of overflowed words + Int_t plan = fGeo->GetPlane( det ); // Plane + Int_t cham = fGeo->GetChamber( det ); // Chamber + Int_t sect = fGeo->GetSector( det ); // Sector (=iDDL) + Int_t nRow = fCommonParam->GetRowMax( plan, cham, sect ); + Int_t nCol = fCommonParam->GetColMax( plan ); + const Int_t nTBin = fCalibration->GetNumberOfTimeBins(); + Int_t kCtype = 0; // Chamber type (0:C0, 1:C1) + Int_t iEv = 0xA; // Event ID. Now fixed to 10, how do I get event id? + UInt_t x = 0; // General used number + + // Check the nCol and nRow. + if ((nCol == 144) && + (nRow == 16 || nRow == 12)) { + kCtype = (nRow-12) / 4; + } + else { + AliError(Form("This type of chamber is not supported (nRow=%d, nCol=%d)." + ,nRow,nCol)); + return 0; + } + + AliDebug(1,Form("Producing raw data for sect=%d plan=%d cham=%d side=%d" + ,sect,plan,cham,side)); + + // Tracklet should be processed here but not implemented yet + + // Write end of tracklet marker + if (nw < maxSize) { + buf[nw++] = endoftrackletmarker; + } + else { + of++; + } + + // Half Chamber header + if ( fRawVersion == 1 ) { + // Now it is the same version as used in SM-I commissioning. + Int_t dcs = det+100; // DCS Serial (in simulation, it is meaningless + x = (dcs<<20) | (sect<<15) | (plan<<12) | (cham<<9) | (side<<8) | 1; + if (nw < maxSize) { + buf[nw++] = x; + } + else { + of++; + } + } + else if ( fRawVersion == 2 ) { + // h[0] (there are 2 HC header) + Int_t minorv = 0; // The minor version number + Int_t add = 1; // The number of additional header words to follow + x = (1<<31) | (fRawVersion<<24) | (minorv<<17) | (add<<14) | (sect<<9) | (plan<<6) | (cham<<3) | (side<<2) | 1; + if (nw < maxSize) { + buf[nw++] = x; + } + else { + of++; + } + // h[1] + Int_t bc_ctr = 99; // bunch crossing counter. Here it is set to 99 always for no reason + Int_t pt_ctr = 15; // pretrigger counter. Here it is set to 15 always for no reason + Int_t pt_phase = 11; // pretrigger phase. Here it is set to 11 always for no reason + x = (bc_ctr<<16) | (pt_ctr<<12) | (pt_phase<<8) | ((nTBin-1)<<2) | 1; + if (nw < maxSize) { + buf[nw++] = x; + } + else { + of++; + } + } + + // Scan for ROB and MCM + for (Int_t iRobRow = 0; iRobRow < (kCtype + 3); iRobRow++ ) { + Int_t iRob = iRobRow * 2 + side; + for (Int_t iMcm = 0; iMcm < fGeo->MCMmax(); iMcm++ ) { + Int_t padrow = iRobRow * 4 + iMcm / 4; + + // MCM header + x = ((iRob * fGeo->MCMmax() + iMcm) << 24) | ((iEv % 0x100000) << 4) | 0xC; + if (nw < maxSize) { + buf[nw++] = x; + } + else { + of++; + } + + // ADC data + for (Int_t iAdc = 0; iAdc < 21; iAdc++ ) { + Int_t padcol = fGeo->GetPadCol(iRob, iMcm, iAdc); + UInt_t aa = !(iAdc & 1) + 2; + UInt_t *a = new UInt_t[nTBin+2]; + // 3 timebins are packed into one 32 bits word + for (Int_t iT = 0; iT < nTBin; iT+=3) { + if ((padcol >= 0) && (padcol < nCol)) { + a[iT ] = ((iT ) < nTBin ) ? digits->GetDataUnchecked(padrow,padcol,iT ) : 0; + a[iT+1] = ((iT + 1) < nTBin ) ? digits->GetDataUnchecked(padrow,padcol,iT + 1) : 0; + a[iT+2] = ((iT + 2) < nTBin ) ? digits->GetDataUnchecked(padrow,padcol,iT + 2) : 0; + } + else { + a[iT] = a[iT+1] = a[iT+2] = 0; // This happenes at the edge of chamber (should be pedestal! How?) + } + x = (a[iT+2] << 22) | (a[iT+1] << 12) | (a[iT] << 2) | aa; + if (nw < maxSize) { + buf[nw++] = x; + } + else { + of++; + } + } + // Diagnostics + Float_t avg = 0; + Float_t rms = 0; + for (Int_t iT = 0; iT < nTBin; iT++) { + avg += (Float_t) (a[iT]); + } + avg /= (Float_t) nTBin; + for (Int_t iT = 0; iT < nTBin; iT++) { + rms += ((Float_t) (a[iT]) - avg) * ((Float_t) (a[iT]) - avg); + } + rms = TMath::Sqrt(rms / (Float_t) nTBin); + if (rms > 1.7) { + AliDebug(2,Form("Large RMS (>1.7) (ROB,MCM,ADC)=(%02d,%02d,%02d), avg=%03.1f, rms=%03.1f" + ,iRob,iMcm,iAdc,avg,rms)); + } + delete a; + } + } + } + + // Write end of raw data marker + if (nw < maxSize) { + buf[nw++] = endofeventmarker; + } + else { + of++; + } + if (of != 0) { + AliWarning("Buffer overflow. Data is truncated. Please increase buffer size and recompile."); + } + + return nw; + +} + +//_____________________________________________________________________________ +AliTRDdigitsManager *AliTRDrawData::Raw2Digits(AliRawReader *rawReader) +{ + // + // Read raw data and convert to digits + // + + if ( fRawVersion == 0 ) { + return Raw2DigitsV0(rawReader); // fRawVersion == 0 + } + else { + return Raw2DigitsVx(rawReader); // fRawVersion > 0 + } } //_____________________________________________________________________________ -AliTRDdigitsManager* AliTRDrawData::Raw2Digits(AliRawReader* rawReader) +AliTRDdigitsManager *AliTRDrawData::Raw2DigitsV0(AliRawReader *rawReader) { // - // Read the raw data digits and put them into the returned digits manager + // Bogdan's raw data reader (for offline only). // - AliTRDdataArrayI *digits = 0; - AliTRDdataArrayI *track0 = 0; - AliTRDdataArrayI *track1 = 0; - AliTRDdataArrayI *track2 = 0; + AliTRDdataArrayI *digits = 0; + AliTRDdataArrayI *track0 = 0; + AliTRDdataArrayI *track1 = 0; + AliTRDdataArrayI *track2 = 0; AliTRDgeometry *geo = new AliTRDgeometry(); AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance(); - if (!commonParam) - { - printf(" "); - printf("Could not get common params\n"); + if (!commonParam) { + AliError("Could not get common parameters"); return 0; } - + AliTRDcalibDB* calibration = AliTRDcalibDB::Instance(); - if (!calibration) - { - printf(" "); - printf("Could not get calibration object\n"); + if (!calibration) { + AliError("Could not get calibration object"); return 0; } // Create the digits manager AliTRDdigitsManager* digitsManager = new AliTRDdigitsManager(); - digitsManager->SetDebug(fDebug); digitsManager->CreateArrays(); AliTRDRawStream input(rawReader); @@ -361,11 +666,9 @@ AliTRDdigitsManager* AliTRDrawData::Raw2Digits(AliRawReader* rawReader) if (track1) track1->Compress(1,0); if (track2) track2->Compress(1,0); - if (fDebug > 2) { - Info("Raw2Digits","Subevent header:"); - Info("Raw2Digits","\tdet = %d",det); - Info("Raw2Digits","\tnpads = %d",npads); - } + AliDebug(2,"Subevent header:"); + AliDebug(2,Form("\tdet = %d",det)); + AliDebug(2,Form("\tnpads = %d",npads)); // Create the data buffer Int_t cham = geo->GetChamber(det); @@ -388,16 +691,17 @@ AliTRDdigitsManager* AliTRDrawData::Raw2Digits(AliRawReader* rawReader) track2->Allocate(rowMax,colMax,timeTotal); } - } + } digits->SetDataUnchecked(input.GetRow(),input.GetColumn(), input.GetTime(),input.GetSignal()); track0->SetDataUnchecked(input.GetRow(),input.GetColumn(), - input.GetTime(), -1); + input.GetTime(), 0); track1->SetDataUnchecked(input.GetRow(),input.GetColumn(), - input.GetTime(), -1); + input.GetTime(), 0); track2->SetDataUnchecked(input.GetRow(),input.GetColumn(), - input.GetTime(), -1); + input.GetTime(), 0); + } if (digits) digits->Compress(1,0); @@ -410,3 +714,40 @@ AliTRDdigitsManager* AliTRDrawData::Raw2Digits(AliRawReader* rawReader) return digitsManager; } + +//_____________________________________________________________________________ +AliTRDdigitsManager *AliTRDrawData::Raw2DigitsVx(AliRawReader *rawReader) +{ + + // + // This is executed for all Raw Data Versions > 0. Raw data is read and filled + // into digits array. Next function is not used. + // + + AliTRDdataArrayI *digits = 0; + + AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance(); + if (!commonParam) { + AliError("Could not get common params"); + return 0; + } + + AliTRDcalibDB *calibration = AliTRDcalibDB::Instance(); + if (!calibration) { + AliError("Could not get calibration object"); + return 0; + } + + // Create the digits manager + AliTRDdigitsManager* digitsManager = new AliTRDdigitsManager(); + digitsManager->CreateArrays(); + + AliTRDRawStream input(rawReader, digitsManager, digits); + input.SetRawVersion( fRawVersion ); + input.ReadAll(); // Loop through the digits + + delete digits; + + return digitsManager; + +}