From b921196a576e3be5c82f43132d838a6a0f976888 Mon Sep 17 00:00:00 2001 From: ivana Date: Thu, 22 Nov 2007 17:04:45 +0000 Subject: [PATCH] - Inherits from AliMUONRawStream - Add pre-compiler option for big endianess (under development) - Implemented next local response iterator - Flag to disable warnings outputs (Christian) --- MUON/AliMUONRawStreamTrigger.cxx | 326 ++++++++++++++++++++++++++----- MUON/AliMUONRawStreamTrigger.h | 66 +++++-- 2 files changed, 324 insertions(+), 68 deletions(-) diff --git a/MUON/AliMUONRawStreamTrigger.cxx b/MUON/AliMUONRawStreamTrigger.cxx index 6439f4f3b79..6d266ec2a25 100644 --- a/MUON/AliMUONRawStreamTrigger.cxx +++ b/MUON/AliMUONRawStreamTrigger.cxx @@ -20,22 +20,31 @@ /// 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). +/// The Next method goes to the next local response. If there are no local response left +/// it returns kFALSE. /// It can loop also over DDL and store the decoded rawdata in TClonesArrays /// in payload class. /// -/// First version implement for Trigger +/// Version implement for Trigger /// \author Christian Finck //----------------------------------------------------------------------------- +#include + #include "AliMUONRawStreamTrigger.h" +#include "AliMUONDarcHeader.h" +#include "AliMUONRegHeader.h" +#include "AliMUONLocalStruct.h" +#include "AliMUONDDLTrigger.h" +#include "AliMUONLogger.h" #include "AliRawReader.h" #include "AliRawDataHeader.h" #include "AliDAQ.h" #include "AliLog.h" +#include + /// \cond CLASSIMP ClassImp(AliMUONRawStreamTrigger) /// \endcond @@ -44,13 +53,17 @@ const Int_t AliMUONRawStreamTrigger::fgkMaxDDL = 2; //___________________________________________ AliMUONRawStreamTrigger::AliMUONRawStreamTrigger() - : TObject(), - fRawReader(0x0), +: AliMUONRawStream(), fPayload(new AliMUONPayloadTrigger()), - fDDL(0), - fSubEntries(0), - fNextDDL(kTRUE), - fEnableErrorLogger(kFALSE) + fCurrentDDL(0x0), + fCurrentDDLIndex(fgkMaxDDL), + fCurrentDarcHeader(0x0), + fCurrentRegHeader(0x0), + fCurrentRegHeaderIndex(0), + fCurrentLocalStruct(0x0), + fCurrentLocalStructIndex(0), + fLocalStructRead(kFALSE), + fDDL(0) { /// /// create an object to read MUON raw digits @@ -62,13 +75,17 @@ AliMUONRawStreamTrigger::AliMUONRawStreamTrigger() //_________________________________________________________________ AliMUONRawStreamTrigger::AliMUONRawStreamTrigger(AliRawReader* rawReader) - : TObject(), - fRawReader(rawReader), + : AliMUONRawStream(rawReader), fPayload(new AliMUONPayloadTrigger()), - fDDL(0), - fSubEntries(0), - fNextDDL(kTRUE), - fEnableErrorLogger(kFALSE) + fCurrentDDL(0x0), + fCurrentDDLIndex(fgkMaxDDL), + fCurrentDarcHeader(0x0), + fCurrentRegHeader(0x0), + fCurrentRegHeaderIndex(0), + fCurrentLocalStruct(0x0), + fCurrentLocalStructIndex(0), + fLocalStructRead(kFALSE), + fDDL(0) { /// /// ctor with AliRawReader as argument @@ -87,37 +104,227 @@ AliMUONRawStreamTrigger::~AliMUONRawStreamTrigger() } //_____________________________________________________________ -Bool_t AliMUONRawStreamTrigger::Next() +Bool_t AliMUONRawStreamTrigger::Next(UChar_t& id, UChar_t& dec, Bool_t& trigY, + UChar_t& yPos, UChar_t& sXDev, UChar_t& xDev, + UChar_t& xPos, Bool_t& triggerY, Bool_t& triggerX, + TArrayS& xPattern, TArrayS& yPattern) +{ + /// + /// read the next raw digit (local structure) + /// returns kFALSE if there is no digit left + /// Should call First() before this method to start the iteration. + /// + + if ( IsDone() ) return kFALSE; + + if ( fLocalStructRead ) { + + Bool_t ok = GetNextLocalStruct(); + if (!ok) + { + // this is the end + return kFALSE; + } + } + + fLocalStructRead = kTRUE; + + id = fCurrentLocalStruct->GetId(); + dec = fCurrentLocalStruct->GetDec(); + trigY = fCurrentLocalStruct->GetTrigY(); + yPos = fCurrentLocalStruct->GetYPos(); + sXDev = fCurrentLocalStruct->GetSXDev(); + xDev = fCurrentLocalStruct->GetXDev(); + xPos = fCurrentLocalStruct->GetXPos(); + + triggerX = fCurrentLocalStruct->GetTriggerX(); + triggerY = fCurrentLocalStruct->GetTriggerY(); + + fCurrentLocalStruct->GetXPattern(xPattern); + fCurrentLocalStruct->GetYPattern(yPattern); + + return kTRUE; +} + +//______________________________________________________ +Bool_t AliMUONRawStreamTrigger::IsDone() const { -/// read the next raw digit (buspatch structure) -/// returns kFALSE if there is no digit left - -// if (fNextDDL){ -// if(!NextDDL()) return kFALSE; -// } -// Int_t nEntries = fDDLTrigger->GetBusPatchEntries(); - -// if (fSubEntries < nEntries) { -// fLocalStruct = (AliMUONLocalStruct*)fDDLTrigger->GetBusPatchEntry(fSubEntries); -// fSubEntries++; -// fNextDDL = kFALSE; -// return kTRUE; -// } else { -// fDDLTrigger->GetBusPatchArray()->Delete(); -// fSubEntries = 0; -// fNextDDL = kTRUE; -// return Next(); -// } - - return kFALSE; + /// Whether the iteration is finished or not + return (fCurrentLocalStruct==0); +} + +//______________________________________________________ +void AliMUONRawStreamTrigger::First() +{ + /// Initialize the iteration process. + + fCurrentDDLIndex = -1; + // Must reset all the pointers because if we return before calling + // GetNextLocalStruct() the user might call CurrentDDL(), CurrentBlockHeader(), + // CurrentRegHeader() or CurrentLocalStruct() which should return reasonable + // results in that case. + fCurrentDDL = 0; + fCurrentDarcHeader = 0; + fCurrentRegHeader = 0; + fCurrentLocalStruct = 0; + + // Find the first non-empty structure + if (not GetNextDDL()) return; + if (not GetNextRegHeader()) return; + GetNextLocalStruct(); +} + +//______________________________________________________ +Bool_t AliMUONRawStreamTrigger::GetNextDDL() +{ + /// Returns the next DDL present + + assert( GetReader() != 0 ); + + Bool_t kFound(kFALSE); + + while ( fCurrentDDLIndex < fgkMaxDDL-1 && !kFound ) + { + ++fCurrentDDLIndex; + GetReader()->Reset(); + GetReader()->Select("MUONTRG",fCurrentDDLIndex,fCurrentDDLIndex); + if ( GetReader()->ReadHeader() ) + { + kFound = kTRUE; + } + } + + if ( !kFound ) + { + // fCurrentDDLIndex is set to fgkMaxDDL so that we exit the above loop immediately + // for a subsequent call to this method, unless NextEvent is called in between. + fCurrentDDLIndex = fgkMaxDDL; + // We have not actually been able to complete the loading of the new DDL so + // we are still on the old one. In this case we do not need to reset fCurrentDDL. + //fCurrentDDL = 0; + return kFALSE; + } + + Int_t totalDataWord = GetReader()->GetDataSize(); // in bytes + + AliDebug(3, Form("DDL Number %d totalDataWord %d\n", fCurrentDDLIndex, + totalDataWord)); + + UInt_t *buffer = new UInt_t[totalDataWord/4]; + + if ( !GetReader()->ReadNext((UChar_t*)buffer, totalDataWord) ) + { + // We have not actually been able to complete the loading of the new DDL so + // we are still on the old one. In this case we do not need to reset fCurrentDDL. + //fCurrentDDL = 0; + delete [] buffer; + return kFALSE; + } + +#ifndef R__BYTESWAP + swap(buffer, totalDataWord); // swap needed for mac power pc +#endif + + fPayload->ResetDDL(); + + Bool_t ok = fPayload->Decode(buffer); + + if (IsErrorLogger()) AddErrorMessage(); + + delete[] buffer; + + fCurrentDDL = fPayload->GetDDLTrigger(); + + fCurrentDarcHeader = fCurrentDDL->GetDarcHeader(); + + fCurrentRegHeaderIndex = -1; + + + return ok; +} + + +//______________________________________________________ +Bool_t AliMUONRawStreamTrigger::GetNextRegHeader() +{ + /// Returns the next Reg Header present + + assert( fCurrentDarcHeader != 0 ); + assert( fCurrentDDL != 0 ); + + fCurrentRegHeader = 0; + + Int_t i = fCurrentRegHeaderIndex; + + while ( fCurrentRegHeader == 0 && i < fCurrentDarcHeader->GetRegHeaderEntries()-1 ) + { + ++i; + fCurrentRegHeader = fCurrentDarcHeader->GetRegHeaderEntry(i); + } + + if ( !fCurrentRegHeader ) + { + Bool_t ok = GetNextDDL(); + if (!ok) + { + return kFALSE; + } + else + { + return GetNextRegHeader(); + } + } + + fCurrentRegHeaderIndex = i; + + fCurrentLocalStructIndex = -1; + + return kTRUE; +} + +//______________________________________________________ +Bool_t AliMUONRawStreamTrigger::GetNextLocalStruct() +{ + /// Find the next non-empty local structure + + assert( fCurrentRegHeader != 0 ); + + fCurrentLocalStruct = 0; + + Int_t i = fCurrentLocalStructIndex; + + while ( fCurrentLocalStruct == 0 && i < fCurrentRegHeader->GetLocalEntries()-1 ) + { + ++i; + fCurrentLocalStruct = fCurrentRegHeader->GetLocalEntry(i); + } + + if ( !fCurrentLocalStruct ) + { + Bool_t ok = GetNextRegHeader(); + if (!ok) + { + return kFALSE; + } + else + { + return GetNextLocalStruct(); + } + } + + fCurrentLocalStructIndex = i; + + fLocalStructRead = kFALSE; + + return kTRUE; } //______________________________________________________ Bool_t AliMUONRawStreamTrigger::NextDDL() { /// reading tracker DDL - /// store buspatch info into Array - /// store only non-empty structures (buspatch info with datalength !=0) + /// store local info into Array + /// store only non-empty structures // reset TClones fPayload->ResetDDL(); @@ -126,9 +333,9 @@ Bool_t AliMUONRawStreamTrigger::NextDDL() // loop over the two ddl's while ( fDDL < fgkMaxDDL ) { - fRawReader->Reset(); - fRawReader->Select("MUONTRG", fDDL, fDDL); //Select the DDL file to be read - if (fRawReader->ReadHeader()) break; + GetReader()->Reset(); + GetReader()->Select("MUONTRG", fDDL, fDDL); //Select the DDL file to be read + if (GetReader()->ReadHeader()) break; AliDebug(3,Form("Skipping DDL %d which does not seem to be there",fDDL)); ++fDDL; } @@ -140,15 +347,19 @@ Bool_t AliMUONRawStreamTrigger::NextDDL() AliDebug(3, Form("DDL Number %d\n", fDDL )); - Int_t totalDataWord = fRawReader->GetDataSize(); // in bytes + Int_t totalDataWord = GetReader()->GetDataSize(); // in bytes UInt_t *buffer = new UInt_t[totalDataWord/4]; // check not necessary yet, but for future developments - if (!fRawReader->ReadNext((UChar_t*)buffer, totalDataWord)) return kFALSE; + if (!GetReader()->ReadNext((UChar_t*)buffer, totalDataWord)) return kFALSE; +#ifndef R__BYTESWAP + swap(buffer, totalDataWord); // swap needed for mac power pc +#endif + fPayload->Decode(buffer); - if (fEnableErrorLogger) AddErrorMessage(); + if (IsErrorLogger()) AddErrorMessage(); fDDL++; @@ -177,16 +388,23 @@ void AliMUONRawStreamTrigger::AddErrorMessage() { /// add message into logger of AliRawReader per event - for (Int_t i = 0; i < fPayload->GetDarcEoWErrors(); ++i) - fRawReader->AddMajorErrorLog(kDarcEoWErr, "Wrong end of Darc word structure"); - - for (Int_t i = 0; i < fPayload->GetGlobalEoWErrors(); ++i) - fRawReader->AddMajorErrorLog(kGlobalEoWErr, "Wrong end of Global word structure"); + TString msg = 0; + Int_t occurance = 0; + AliMUONLogger* log = fPayload->GetErrorLogger(); + + log->ResetItr(); + while(log->Next(msg, occurance)) + { + if (msg.Contains("Darc")) + GetReader()->AddMajorErrorLog(kDarcEoWErr, msg.Data()); - for (Int_t i = 0; i < fPayload->GetRegEoWErrors(); ++i) - fRawReader->AddMajorErrorLog(kRegEoWErr, "Wrong end of Regional word structure"); + if (msg.Contains("Global")) + GetReader()->AddMajorErrorLog(kGlobalEoWErr, msg.Data()); - for (Int_t i = 0; i < fPayload->GetLocalEoWErrors(); ++i) - fRawReader->AddMajorErrorLog(kLocalEoWErr, "Wrong end of Local word structure"); + if (msg.Contains("Regional")) + GetReader()->AddMajorErrorLog(kRegEoWErr, msg.Data()); + if (msg.Contains("Local")) + GetReader()->AddMajorErrorLog(kLocalEoWErr, msg.Data()); + } } diff --git a/MUON/AliMUONRawStreamTrigger.h b/MUON/AliMUONRawStreamTrigger.h index 1b6eef6e7aa..50d7744cb5b 100644 --- a/MUON/AliMUONRawStreamTrigger.h +++ b/MUON/AliMUONRawStreamTrigger.h @@ -13,18 +13,43 @@ #include #include "AliMUONPayloadTrigger.h" +#include "AliMUONRawStream.h" +class TArrayS; class AliRawReader; class AliMUONDDLTrigger; +class AliMUONDarcHeader; +class AliMUONRegkHeader; +class AliMUONLocalStruct; - -class AliMUONRawStreamTrigger: public TObject { +class AliMUONRawStreamTrigger: public AliMUONRawStream { public : AliMUONRawStreamTrigger(); AliMUONRawStreamTrigger(AliRawReader* rawReader); virtual ~AliMUONRawStreamTrigger(); - virtual Bool_t Next(); + /// Initialize iterator + void First(); + + /// Returns current DDL object during iteration + AliMUONDDLTrigger* CurrentDDL() const { return fCurrentDDL; } + + /// Returns current DarcHeader object during iteration + AliMUONDarcHeader* CurrentDarcHeader() const { return fCurrentDarcHeader; } + + /// Returns current RegHeader object during iteration + AliMUONRegHeader* CurrentRegHeader() const { return fCurrentRegHeader; } + + /// Returns current LocalStruct object during iteration + AliMUONLocalStruct* CurrentLocalStruct() const { return fCurrentLocalStruct; } + + /// Advance one step in the iteration. Returns false if finished. + virtual Bool_t Next(UChar_t& id, UChar_t& dec, Bool_t& trigY, + UChar_t& yPos, UChar_t& sXDev, UChar_t& xDev, + UChar_t& xPos, Bool_t& triggerY, Bool_t& triggerX, + TArrayS& xPattern, TArrayS& yPattern); + + virtual Bool_t NextDDL(); /// Return maximum number of DDLs @@ -37,24 +62,24 @@ class AliMUONRawStreamTrigger: public TObject { void SetMaxReg(Int_t reg); void SetMaxLoc(Int_t loc); - /// Set object for reading the raw data - void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;} - /// Return pointer for DDL structure AliMUONDDLTrigger* GetDDLTrigger() const {return fPayload->GetDDLTrigger();} + /// Return number of DDL + Int_t GetDDL() const {return fDDL - 1;} + /// Return pointer for payload AliMUONPayloadTrigger* GetPayLoad() const {return fPayload;} - /// Return number of DDL - Int_t GetDDL() const {return fDDL - 1;} + /// Whether the iteration is finished or not + Bool_t IsDone() const; /// add error message into error logger void AddErrorMessage(); - /// Enable error info logger - void EnabbleErrorLogger() {fEnableErrorLogger = kTRUE;} - + /// Disable Warnings + void DisableWarnings() {fPayload->DisableWarnings();} + /// error numbers enum rawStreamTriggerError { kDarcEoWErr = 6, ///< end of Darc word error @@ -70,11 +95,24 @@ class AliMUONRawStreamTrigger: public TObject { /// Not implemented AliMUONRawStreamTrigger& operator = (const AliMUONRawStreamTrigger& stream); - AliRawReader* fRawReader; ///< object for reading the raw data + Bool_t GetNextDDL(); + Bool_t GetNextRegHeader(); + Bool_t GetNextLocalStruct(); + + private: + AliMUONPayloadTrigger* fPayload; ///< pointer to payload decoder + AliMUONDDLTrigger* fCurrentDDL; //!< for iterator: current ddl ptr + Int_t fCurrentDDLIndex; //!< for iterator: current ddl index + AliMUONDarcHeader* fCurrentDarcHeader; //!< for iterator: current darc ptr + AliMUONRegHeader* fCurrentRegHeader; //!< for iterator: current reg ptr + Int_t fCurrentRegHeaderIndex; //!< for iterator: current reg index + AliMUONLocalStruct* fCurrentLocalStruct; //!< for iterator: current local ptr + Int_t fCurrentLocalStructIndex; //!< for iterator: current local index + Bool_t fLocalStructRead; //!< flag for read out local structure + Int_t fDDL; //!< number of DDL + - Int_t fDDL; ///< number of DDL - Int_t fSubEntries; ///< entries of buspatch structure Bool_t fNextDDL; ///< flag for next DDL to be read Bool_t fEnableErrorLogger; //!< flag to enable the error info logger -- 2.43.0