/// 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.
+/// It can loop also over DDL and store the decoded rawdata in TClonesArray
+/// in Payload class.
///
/// First version implement for Tracker
///
#include "AliRawDataHeader.h"
#include "AliLog.h"
-#include "AliMUONDspHeader.h"
-#include "AliMUONBlockHeader.h"
-#include "AliMUONBusStruct.h"
-#include "AliMUONDDLTracker.h"
+#include "AliMpBusPatch.h"
ClassImp(AliMUONRawStreamTracker)
fDspId(0),
fBlkId(0),
fNextDDL(kTRUE),
- fMaxDDL(20),
- fMaxBlock(2),
- fMaxDsp(5),
- fMaxBus(5)
+ fMaxDDL(20)
{
//
// 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();
+ fPayload = new AliMUONPayloadTracker();
+
}
//_________________________________________________________________
fDspId(0),
fBlkId(0),
fNextDDL(kTRUE),
- fMaxDDL(20),
- fMaxBlock(2),
- fMaxDsp(5),
- fMaxBus(5)
+ fMaxDDL(20)
{
//
// ctor with AliRawReader as argument
// for reconstruction purpose
//
- fRawReader = rawReader;
-
- fBusPatchManager = new AliMpBusPatch();
- fBusPatchManager->ReadBusPatchFile();
+ fRawReader = rawReader;
+ fPayload = new AliMUONPayloadTracker();
- fDDLTracker = new AliMUONDDLTracker();
- fBusStruct = new AliMUONBusStruct();
- fBlockHeader = new AliMUONBlockHeader();
- fDspHeader = new AliMUONDspHeader();
}
//_________________________________________________________________
//
// clean up
//
- delete fBusPatchManager;
- delete fDDLTracker;
- delete fBusStruct;
- delete fBlockHeader;
- delete fDspHeader;
+ delete fPayload;
+
}
//_____________________________________________________________
// 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;
- }
+// 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;
+ fPayload->ResetDDL();
- 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);
+ Int_t totalDataWord = fRawReader->GetDataSize(); // in bytes
- totalDspSize = fDspHeader->GetTotalLength();
- indexDsp = index;
+ UInt_t *buffer = new UInt_t[totalDataWord/4];
- blankDspSize = kDspHeaderSize + iBusPerDSP[iDsp]*kBusPatchHeaderSize; // no data just header
+ fRawReader->ReadNext((UChar_t*)buffer, totalDataWord);
- 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
+ fPayload->Decode(buffer, fDDL);
+ delete[] buffer;
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;
+ fPayload->SetMaxBlock(blk);
}
#include <TObject.h>
#include <TClonesArray.h>
-#include "AliMpBusPatch.h"
+#include "AliMUONPayloadTracker.h"
class AliRawReader;
class AliMUONDDLTracker;
-class AliMUONBusStruct;
-class AliMUONDspHeader;
-class AliMUONBlockHeader;
+
class AliMUONRawStreamTracker: public TObject {
public :
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;}
+ Int_t GetMaxBlock() const {return fPayload->GetMaxBlock();}
+ Int_t GetMaxDsp() const {return fPayload->GetMaxDsp();}
+ Int_t GetMaxBus() const {return fPayload->GetMaxBus();}
// 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 SetMaxDsp(Int_t dsp) {fPayload->SetMaxDsp(dsp);}
+ void SetMaxBus(Int_t bus) {fPayload->SetMaxBus(bus);}
void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;}
- AliMUONBusStruct* GetBusPatchInfo() const {return fBusStructPtr;}
- AliMUONDDLTracker* GetDDLTracker() const {return fDDLTracker;}
+ AliMUONDDLTracker* GetDDLTracker() const {return fPayload->GetDDLTracker();}
Int_t GetDDL() const {return fDDL - 1;}
protected :
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
+ Int_t fMaxDDL; ///< maximum number of DDL in DATE file
- AliMUONBusStruct* fBusStructPtr; //!< pointer for local structure
+ AliMUONPayloadTracker* fPayload; ///< pointer to payload decoder
- ClassDef(AliMUONRawStreamTracker, 1) // base class for reading MUON raw digits
+ ClassDef(AliMUONRawStreamTracker, 2) // base class for reading MUON raw digits
};
#endif
/// 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 TClonesArrays
+/// in payload class.
///
/// First version implement for Trigger
///
#include "AliRawDataHeader.h"
#include "AliLog.h"
-#include "AliMUONDarcHeader.h"
-#include "AliMUONRegHeader.h"
-#include "AliMUONLocalStruct.h"
-#include "AliMUONDDLTrigger.h"
ClassImp(AliMUONRawStreamTrigger)
fDDL(0),
fSubEntries(0),
fNextDDL(kTRUE),
- fMaxDDL(2),
- fMaxReg(8),
- fMaxLoc(16)
+ fMaxDDL(2)
{
//
// create an object to read MUON raw digits
// Default ctor for monitoring purposes
//
- fDDLTrigger = new AliMUONDDLTrigger();
- fRegHeader = new AliMUONRegHeader();
- fLocalStruct = new AliMUONLocalStruct();
+ fPayload = new AliMUONPayloadTrigger();
}
fDDL(0),
fSubEntries(0),
fNextDDL(kTRUE),
- fMaxDDL(2),
- fMaxReg(8),
- fMaxLoc(16)
+ fMaxDDL(2)
+
{
//
// ctor with AliRawReader as argument
// for reconstruction purpose
//
- fRawReader = rawReader;
+ fRawReader = rawReader;
+ fPayload = new AliMUONPayloadTrigger();
- fDDLTrigger = new AliMUONDDLTrigger();
- fRegHeader = new AliMUONRegHeader();
- fLocalStruct = new AliMUONLocalStruct();
-
}
//_________________________________________________________________
//
// clean up
//
- delete fDDLTrigger;
- delete fLocalStruct;
- delete fRegHeader;
+ delete fPayload;
}
//_____________________________________________________________
// store buspatch info into Array
// store only non-empty structures (buspatch info with datalength !=0)
- // reading DDL for trigger
-
- AliMUONDarcHeader* darcHeader = fDDLTrigger->GetDarcHeader();
-
- Int_t kDarcHeaderSize = darcHeader->GetHeaderLength();
- Int_t kRegHeaderSize = fRegHeader->GetHeaderLength() ;
- Bool_t scalerEvent = kFALSE;
-
// reset TClones
- darcHeader->GetRegHeaderArray()->Delete();
- //darcHeader->GetRegHeaderArray()->Clear("C");
+ fPayload->ResetDDL();
+
// loop over the two ddl's
if (fDDL >= fMaxDDL) {
fDDL = 0;
return kFALSE;
}
-
fRawReader->Reset();
fRawReader->Select(0XA,fDDL,fDDL); //Select the DDL file to be read
fRawReader->ReadNext((UChar_t*)buffer, totalDataWord);
- Int_t index = 0;
- darcHeader->SetWord(buffer[index++]);
-
- if(darcHeader->GetEventType() == 2) {
- scalerEvent = kTRUE;
- } else
- scalerEvent = kFALSE;
-
- if(scalerEvent) {
- // 6 DARC scaler words
- memcpy(darcHeader->GetDarcScalers(), &buffer[index], darcHeader->GetDarcScalerLength()*4);
- index += darcHeader->GetDarcScalerLength();
- }
-
- if (buffer[index++] != darcHeader->GetEndOfDarc())
- AliWarning(Form("Wrong end of Darc word %x instead of %x\n",buffer[index-1], darcHeader->GetEndOfDarc()));
-
- // 4 words of global board input + Global board output
- memcpy(darcHeader->GetGlobalInput(), &buffer[index], (kDarcHeaderSize-1)*4);
- index += kDarcHeaderSize- 1; // kind tricky cos scaler info in-between Darc header
+ fPayload->Decode(buffer);
- if(scalerEvent) {
- // 10 Global scaler words
- memcpy(darcHeader->GetGlobalScalers(), &buffer[index], darcHeader->GetGlobalScalerLength()*4);
- index += darcHeader->GetGlobalScalerLength();
- }
+ fDDL++;
- if (buffer[index++] != darcHeader->GetEndOfGlobal())
- AliWarning(Form("Wrong end of Global word %d instead of %d\n",buffer[index-1], darcHeader->GetEndOfGlobal()));
-
- // 8 regional boards
- for (Int_t iReg = 0; iReg < fMaxReg; iReg++) { //loop over regeonal card
-
- memcpy(fRegHeader->GetHeader(), &buffer[index], kRegHeaderSize*4);
- index += kRegHeaderSize;
-
- fDDLTrigger->AddRegHeader(*fRegHeader);
- // 11 regional scaler word
- if(scalerEvent) {
- memcpy(fRegHeader->GetScalers(), &buffer[index], fRegHeader->GetScalerLength()*4);
- index += fRegHeader->GetScalerLength();
- }
-
- if (buffer[index++] != fRegHeader->GetEndOfReg())
- AliWarning(Form("Wrong end of Reg word %x instead of %x\n",buffer[index-1], fRegHeader->GetEndOfReg()));
-
- // 16 local cards per regional board
- for (Int_t iLoc = 0; iLoc < fMaxLoc; iLoc++) { //loop over local card
-
- Int_t dataSize = fLocalStruct->GetLength();;
-
- // 5 word trigger information
- memcpy(fLocalStruct->GetData(), &buffer[index], dataSize*4);
- index += dataSize;
-
- // 45 regional scaler word
- if(scalerEvent) {
- memcpy(fLocalStruct->GetScalers(), &buffer[index], fLocalStruct->GetScalerLength()*4);
- index += fLocalStruct->GetScalerLength();
- }
-
- if (buffer[index++] != fLocalStruct->GetEndOfLocal())
- AliWarning(Form("Wrong end of local word %x instead of %x\n",buffer[index-1], fLocalStruct->GetEndOfLocal()));
-
- fDDLTrigger->AddLocStruct(*fLocalStruct, iReg);
-
- } // local card loop
-
- } // regional card loop
-
delete [] buffer;
-
- fDDL++;
-
return kTRUE;
}
-//______________________________________________________
-void AliMUONRawStreamTrigger::ResetDDL()
-{
- // reseting TClonesArray
- // after each DDL
- //
- AliMUONDarcHeader* darcHeader = fDDLTrigger->GetDarcHeader();
- darcHeader->GetRegHeaderArray()->Clear("C");
-}
//______________________________________________________
void AliMUONRawStreamTrigger::SetMaxDDL(Int_t ddl)
void AliMUONRawStreamTrigger::SetMaxReg(Int_t reg)
{
// set regional card number
- if (reg > 8) reg = 8;
- fMaxReg = reg;
+ fPayload->SetMaxReg(reg);
}
//______________________________________________________
void AliMUONRawStreamTrigger::SetMaxLoc(Int_t loc)
{
// set local card number
- if (loc > 16) loc = 16;
- fMaxLoc = loc;
+ fPayload->SetMaxLoc(loc);
}
#include <TObject.h>
#include <TClonesArray.h>
+#include "AliMUONPayloadTrigger.h"
class AliRawReader;
class AliMUONDDLTrigger;
-class AliMUONLocalStruct;
-class AliMUONRegHeader;
+
class AliMUONRawStreamTrigger: public TObject {
public :
virtual Bool_t Next();
virtual Bool_t NextDDL();
- virtual void ResetDDL();
Int_t GetMaxDDL() const {return fMaxDDL;}
- Int_t GetMaxReg() const {return fMaxReg;}
- Int_t GetMaxLoc() const {return fMaxLoc;}
+ Int_t GetMaxReg() const {return fPayload->GetMaxReg();}
+ Int_t GetMaxLoc() const {return fPayload->GetMaxLoc();}
void SetMaxDDL(Int_t ddl);
void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;}
- AliMUONLocalStruct* GetLocalInfo() const {return fLocalStruct;}
- AliMUONDDLTrigger* GetDDLTrigger() const {return fDDLTrigger;}
- Int_t GetDDL() const {return fDDL - 1;}
+ AliMUONDDLTrigger* GetDDLTrigger() const {return fPayload->GetDDLTrigger();}
+ Int_t GetDDL() const {return fDDL - 1;}
protected :
- AliRawReader* fRawReader; ///< object for reading the raw data
-
+ AliRawReader* fRawReader; ///< object for reading the raw data
+ AliMUONPayloadTrigger* fPayload; ///< pointer to payload decoder
+
Int_t fDDL; ///< number of DDL
Int_t fSubEntries; ///< entries of buspatch structure
Bool_t fNextDDL; ///< flag for next DDL to be read
+ Int_t fMaxDDL; ///< maximum number of DDL in DATE file
- Int_t fMaxDDL; ///< maximum number of DDL in DATE file
- Int_t fMaxReg; ///< maximum number of regional cards in DATE file
- Int_t fMaxLoc; ///< maximum number of local cards in DATE file
-
- AliMUONDDLTrigger* fDDLTrigger; //!< pointer for DDL structure
- AliMUONRegHeader* fRegHeader; //!< pointer for regional structure
- AliMUONLocalStruct* fLocalStruct; //!< pointer to local structure
-
- ClassDef(AliMUONRawStreamTrigger, 2) // base class for reading MUON trigger rawdata
+ ClassDef(AliMUONRawStreamTrigger, 3) // base class for reading MUON trigger rawdata
};
#endif
#pragma link C++ class AliMUONDarcHeader+;
#pragma link C++ class AliMUONRegHeader+;
#pragma link C++ class AliMUONLocalStruct+;
+#pragma link C++ class AliMUONPayloadTrigger+;
#pragma link C++ class AliMUONRawStreamTrigger+;
#pragma link C++ class AliMUONDDLTracker+;
#pragma link C++ class AliMUONDspHeader+;
#pragma link C++ class AliMUONBlockHeader+;
#pragma link C++ class AliMUONBusStruct+;
+#pragma link C++ class AliMUONPayloadTracker+;
#pragma link C++ class AliMUONRawStreamTracker+;
#endif
AliMUONDarcHeader.cxx \
AliMUONRegHeader.cxx \
AliMUONLocalStruct.cxx \
+ AliMUONPayloadTrigger.cxx \
AliMUONRawStreamTrigger.cxx \
AliMUONDDLTracker.cxx \
AliMUONBlockHeader.cxx \
AliMUONDspHeader.cxx \
AliMUONBusStruct.cxx \
+ AliMUONPayloadTracker.cxx \
AliMUONRawStreamTracker.cxx
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff