From: ivana Date: Tue, 9 May 2006 15:18:46 +0000 (+0000) Subject: Class for decoding rawdata for tracker, add padding word X-Git-Url: http://git.uio.no/git/?a=commitdiff_plain;h=c07511639b231711cf5a0fa363aa9b02d5f159f3;p=u%2Fmrichter%2FAliRoot.git Class for decoding rawdata for tracker, add padding word (Christian) --- diff --git a/MUON/AliMUONRawStreamTracker.cxx b/MUON/AliMUONRawStreamTracker.cxx new file mode 100644 index 00000000000..5fc444d1045 --- /dev/null +++ b/MUON/AliMUONRawStreamTracker.cxx @@ -0,0 +1,379 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////////// +/// +/// This class provides access to MUON digits in raw data. +/// +/// It loops over all MUON digits in the raw data given by the AliRawReader. +/// The Next method goes to the next digit. If there are no digits left +/// it returns kFALSE (under develpment) +/// It can loop also over DDL and store the decoded rawdata in TClonesArray. +/// +/// First version implement for Tracker +/// +/////////////////////////////////////////////////////////////////////////////// + +#include "AliMUONRawStreamTracker.h" + +#include "AliRawReader.h" +#include "AliRawDataHeader.h" +#include "AliLog.h" + +#include "AliMUONDspHeader.h" +#include "AliMUONBlockHeader.h" +#include "AliMUONBusStruct.h" +#include "AliMUONDDLTracker.h" + +ClassImp(AliMUONRawStreamTracker) + +AliMUONRawStreamTracker::AliMUONRawStreamTracker() + : TObject(), + fRawReader(0x0), + fDDL(0), + fBusPatchId(0), + fDspId(0), + fBlkId(0), + fNextDDL(kTRUE), + fMaxDDL(20), + fMaxBlock(2), + fMaxDsp(5), + fMaxBus(5) +{ + // + // create an object to read MUON raw digits + // Default ctor for monitoring purposes + // + fBusPatchManager = new AliMpBusPatch(); + fBusPatchManager->ReadBusPatchFile(); + + fDDLTracker = new AliMUONDDLTracker(); + fBusStruct = new AliMUONBusStruct(); + fBlockHeader = new AliMUONBlockHeader(); + fDspHeader = new AliMUONDspHeader(); +} + +//_________________________________________________________________ +AliMUONRawStreamTracker::AliMUONRawStreamTracker(AliRawReader* rawReader) + : TObject(), + fDDL(0), + fBusPatchId(0), + fDspId(0), + fBlkId(0), + fNextDDL(kTRUE), + fMaxDDL(20), + fMaxBlock(2), + fMaxDsp(5), + fMaxBus(5) +{ + // + // ctor with AliRawReader as argument + // for reconstruction purpose + // + + fRawReader = rawReader; + + fBusPatchManager = new AliMpBusPatch(); + fBusPatchManager->ReadBusPatchFile(); + + fDDLTracker = new AliMUONDDLTracker(); + fBusStruct = new AliMUONBusStruct(); + fBlockHeader = new AliMUONBlockHeader(); + fDspHeader = new AliMUONDspHeader(); +} + +//_________________________________________________________________ +AliMUONRawStreamTracker::AliMUONRawStreamTracker(const AliMUONRawStreamTracker& stream) : + TObject(stream) +{ + // + // copy ctor + // + AliFatal("copy constructor not implemented"); +} + +//______________________________________________________________________ +AliMUONRawStreamTracker& AliMUONRawStreamTracker::operator = (const AliMUONRawStreamTracker& + /* stream */) +{ + // + // assignment operator + // + AliFatal("assignment operator not implemented"); + return *this; +} + + +//___________________________________ +AliMUONRawStreamTracker::~AliMUONRawStreamTracker() +{ + // + // clean up + // + delete fBusPatchManager; + delete fDDLTracker; + delete fBusStruct; + delete fBlockHeader; + delete fDspHeader; +} + +//_____________________________________________________________ +Bool_t AliMUONRawStreamTracker::Next() +{ + // + // read the next raw digit (buspatch structure) + // returns kFALSE if there is no digit left + // (under development) + + AliMUONDDLTracker* ddlTracker = 0x0; + AliMUONBlockHeader* blkHeader = 0x0; + AliMUONDspHeader* dspHeader = 0x0; + Int_t nBusPatch; + Int_t nDsp; + Int_t nBlock; + + next: + if (fNextDDL){ + printf("iDDL %d\n", fDDL+1); + fBlkId = 0; + fDspId = 0; + fBusPatchId = 0; + if(!NextDDL()) + return kFALSE; + } + fNextDDL = kFALSE; + + ddlTracker = GetDDLTracker(); + + nBlock = ddlTracker->GetBlkHeaderEntries(); + if (fBlkId < nBlock) { + + blkHeader = ddlTracker->GetBlkHeaderEntry(fBlkId); + nDsp = blkHeader->GetDspHeaderEntries(); + + if( fDspId < nDsp) { + dspHeader = blkHeader->GetDspHeaderEntry(fDspId); + nBusPatch = dspHeader->GetBusPatchEntries(); + + if (fBusPatchId < nBusPatch) { + fBusStructPtr = dspHeader->GetBusPatchEntry(fBusPatchId++); + return kTRUE; + + } else {// iBusPatch + fDspId++; + fBusPatchId = 0; + goto next; + // Next(); + } + + } else {// iDsp + fBlkId++; + fDspId = 0; + fBusPatchId = 0; + goto next; + // Next(); + } + + } else {// iBlock + fBlkId = 0; + fDspId = 0; + fBusPatchId = 0; + fNextDDL = kTRUE; + //return kTRUE; + goto next; + } + + return kFALSE; +} + +//______________________________________________________ +Bool_t AliMUONRawStreamTracker::NextDDL() +{ + // reading tracker DDL + // store buspatch info into Array + // store only non-empty structures (buspatch info with datalength !=0) + + fDDLTracker->GetBlkHeaderArray()->Delete(); + // fDDLTracker->GetBlkHeaderArray()->Clear("C"); + + //Read Header Size of DDL,Block,DSP and BusPatch + + Int_t kDDLHeaderSize = sizeof(AliRawDataHeader)/4;; + Int_t kBlockHeaderSize = fBlockHeader->GetHeaderLength(); + Int_t kDspHeaderSize = fDspHeader->GetHeaderLength(); + Int_t kBusPatchHeaderSize = fBusStruct->GetHeaderLength(); + + Int_t totalDDLSize, totalBlockSize, totalDspSize , totalBusPatchSize, dataSize; + + + Int_t iBusPerDSP[5]; // number of bus patches per DSP + Int_t iDspMax; // number max of DSP per block + + // minimum data size (only header's) + Int_t blankDDLSize; + Int_t blankBlockSize; + Int_t blankDspSize; + + if (fDDL >= 20) { + fDDL = 0; + return kFALSE; + } + AliDebug(3, Form("DDL Number %d\n", fDDL )); + + // getting DSP info + fBusPatchManager->GetDspInfo(fDDL/2, iDspMax, iBusPerDSP); + + // Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most + // and each of DSP has at most 5 buspatches. + // This information is used to calculate the size of headers (DDL,Block and DSP) + // which has no interesting data. + blankDDLSize = kDDLHeaderSize + 2*kBlockHeaderSize + 2*iDspMax*kDspHeaderSize; + blankBlockSize = kBlockHeaderSize + iDspMax*kDspHeaderSize; + + for (Int_t i = 0; i < iDspMax; i++) { + blankDDLSize += 2*iBusPerDSP[i]*kBusPatchHeaderSize; + blankBlockSize += iBusPerDSP[i]*kBusPatchHeaderSize; + } + fRawReader->Reset(); + fRawReader->Select(0X9, fDDL, fDDL); //Select the DDL file to be read + + fRawReader->ReadHeader(); + + // 4 is multiplied to convert 2 bytes words + totalDDLSize = (fRawReader->GetDataSize() + sizeof(AliRawDataHeader))/4; + + // Compare the DDL header with an empty DDL header size to read the file + if(totalDDLSize > blankDDLSize) { + + Int_t totalDataWord = fRawReader->GetDataSize(); // in bytes + UInt_t *buffer = new UInt_t[totalDataWord/4]; + + fRawReader->ReadNext((UChar_t*)buffer, totalDataWord); + + // indexes + Int_t indexDsp; + Int_t indexBusPatch; + Int_t index = 0; + + for(Int_t iBlock = 0; iBlock < 2 ;iBlock++){ // loop over 2 blocks + + // copy within padding words + memcpy(fBlockHeader->GetHeader(),&buffer[index], (kBlockHeaderSize+1)*4); + + totalBlockSize = fBlockHeader->GetTotalLength(); + + fDDLTracker->AddBlkHeader(*fBlockHeader); + + if (fBlockHeader->GetPadding() == 0xDEAD) // skipping padding word + index++; + + if(totalBlockSize > blankBlockSize) { // compare block header + index += kBlockHeaderSize; + + for(Int_t iDsp = 0; iDsp < iDspMax ;iDsp++){ //DSP loop + + if (iDsp > fMaxDsp) break; + + memcpy(fDspHeader->GetHeader(),&buffer[index], kDspHeaderSize*4); + + totalDspSize = fDspHeader->GetTotalLength(); + indexDsp = index; + + blankDspSize = kDspHeaderSize + iBusPerDSP[iDsp]*kBusPatchHeaderSize; // no data just header + + fDDLTracker->AddDspHeader(*fDspHeader, iBlock); + + if(totalDspSize > blankDspSize) { // Compare DSP Header + index += kDspHeaderSize; + + for(Int_t iBusPatch = 0; iBusPatch < iBusPerDSP[iDsp]; iBusPatch++) { + + if (iBusPatch > fMaxBus) break; + + //copy buffer into header structure + memcpy(fBusStruct->GetBusPatchHeader(), &buffer[index], kBusPatchHeaderSize*4); + + totalBusPatchSize = fBusStruct->GetTotalLength(); + indexBusPatch = index; + + //Check Buspatch header, not empty events + if(totalBusPatchSize > kBusPatchHeaderSize) { + + index += kBusPatchHeaderSize; + dataSize = fBusStruct->GetLength(); + Int_t bufSize = fBusStruct->GetBufSize(); + + if(dataSize > 0) { // check data present + if (dataSize > bufSize) fBusStruct->SetAlloc(dataSize); + + //copy buffer into data structure + memcpy(fBusStruct->GetData(), &buffer[index], dataSize*4); + fBusStruct->SetBlockId(iBlock); // could be usefull in future applications ? + fBusStruct->SetDspId(iDsp); + fDDLTracker->AddBusPatch(*fBusStruct, iBlock, iDsp); + + } // dataSize test + + } // testing buspatch + + index = indexBusPatch + totalBusPatchSize; + + } //buspatch loop + + } // dsp test + + index = indexDsp + totalDspSize; + + } // dsp loop + + } //block test + + index = totalBlockSize; + + } //block loop + + delete[] buffer; + } //loop checking the header size of DDL + + + fDDL++; + + return kTRUE; +} +//______________________________________________________ +void AliMUONRawStreamTracker::ResetDDL() +{ + // reseting TClonesArray + // after each DDL + // + fDDLTracker->GetBlkHeaderArray()->Clear("C"); +} + +//______________________________________________________ +void AliMUONRawStreamTracker::SetMaxDDL(Int_t ddl) +{ + // set DDL number + if (ddl > 20) ddl = 20; + fMaxDDL = ddl; +} + +//______________________________________________________ +void AliMUONRawStreamTracker::SetMaxBlock(Int_t blk) +{ + // set regional card number + if (blk > 2) blk = 2; + fMaxBlock = blk; +} diff --git a/MUON/AliMUONRawStreamTracker.h b/MUON/AliMUONRawStreamTracker.h new file mode 100644 index 00000000000..23339706814 --- /dev/null +++ b/MUON/AliMUONRawStreamTracker.h @@ -0,0 +1,91 @@ +#ifndef ALIMUONRAWSTREAMTRACKER_H +#define ALIMUONRAWSTREAMTRACKER_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/*$Id$*/ + +/// \ingroup raw +/// \class AliMUONRawStreamTracker +/// \brief Class for reading MUON raw digits +/// +/// \author Christian Finck +/// +/////////////////////////////////////////////////////////////////////////////// +/// +/// This class provides access to MUON digits in raw data. +/// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include "AliMpBusPatch.h" + +class AliRawReader; +class AliMUONDDLTracker; +class AliMUONBusStruct; +class AliMUONDspHeader; +class AliMUONBlockHeader; + +class AliMUONRawStreamTracker: public TObject { + public : + AliMUONRawStreamTracker(); + AliMUONRawStreamTracker(AliRawReader* rawReader); + AliMUONRawStreamTracker(const AliMUONRawStreamTracker& stream); + AliMUONRawStreamTracker& operator = (const AliMUONRawStreamTracker& stream); + virtual ~AliMUONRawStreamTracker(); + + virtual Bool_t Next(); + virtual Bool_t NextDDL(); + virtual void ResetDDL(); + + Int_t GetMaxDDL() const {return fMaxDDL;} + Int_t GetMaxBlock() const {return fMaxBlock;} + Int_t GetMaxDsp() const {return fMaxDsp;} + Int_t GetMaxBus() const {return fMaxBus;} + + // check input before assigment + void SetMaxDDL(Int_t ddl); + void SetMaxBlock(Int_t blk); + + // does not check, done via BusPatchManager + void SetMaxDsp(Int_t dsp) {fMaxDsp = dsp;} + void SetMaxBus(Int_t bus) {fMaxBus = bus;} + + + void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;} + + AliMUONBusStruct* GetBusPatchInfo() const {return fBusStructPtr;} + AliMUONDDLTracker* GetDDLTracker() const {return fDDLTracker;} + Int_t GetDDL() const {return fDDL - 1;} + + protected : + + AliRawReader* fRawReader; // object for reading the raw data + + Int_t fDDL; // number of DDL + Int_t fBusPatchId; // entry of buspatch structure + Int_t fDspId; // entry of Dsp header + Int_t fBlkId; // entry of Block header + + Bool_t fNextDDL; // flag for next DDL to be read + + Int_t fMaxDDL; // maximum number of DDL in DATE file + Int_t fMaxBlock; // maximum number of block per DDL in DATE file + Int_t fMaxDsp; // maximum number of Dsp per block in DATE file + Int_t fMaxBus; // maximum number of Buspatch per Dsp in DATE file + + + AliMpBusPatch* fBusPatchManager; //! buspatch versus DE's & DDL + + AliMUONDDLTracker* fDDLTracker; //! pointer for buspatch structure + AliMUONBusStruct* fBusStruct; //! pointer for local structure + AliMUONBlockHeader* fBlockHeader; //! pointer for block structure + AliMUONDspHeader* fDspHeader; //! pointer for dsp structure + + AliMUONBusStruct* fBusStructPtr; //! pointer for local structure + + ClassDef(AliMUONRawStreamTracker, 1) // base class for reading MUON raw digits +}; + +#endif