///////////////////////////////////////////////////////////////////////////////
#include <TObject.h>
-#include <TRandom.h>
#include "AliHMPIDParam.h"
#include <AliBitPacking.h>
#include <AliFstream.h>
virtual void Reset();
virtual Bool_t Next();
- void Init();
-
- Int_t Ch( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2C(fPad[ddl][row][dil][pad]); } //chamber number
-
- Int_t GetDDLNumber() const { return fDDLNumber; } // Provide current DDL number
- inline Int_t GetCharge(Int_t ddl,Int_t row, Int_t dilogic, Int_t pad); // Provide the charge observed in certain row,dilogic,pad channel
- inline Int_t GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad); //
-
- Int_t Pc ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2P(fPad[ddl][row][dil][pad]);} //PC position number
- Int_t PadPcX ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2X(fPad[ddl][row][dil][pad]);} //pad pc x # 0..79
- Int_t PadPcY ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2Y(fPad[ddl][row][dil][pad]);} //pad pc y # 0..47
-
- inline Bool_t SetZeroSup (Bool_t isSup);
- inline Bool_t GetZeroSup();
- inline Int_t GetErrors(Int_t eType); //Get errors and occurance
+ void InitVars(Int_t n);
+ void DelVars();
+ static inline Int_t GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad); //get absolute pad number
+ static Int_t GetNDDL() { return kNDDL;} //return the number of max # of DDLs
+ static Int_t GetNErrors() { return kSumErr;} //return the number of max # of Error Types
+
+ Int_t GetNPads() const { return fNPads;} //Get number of pads present in the stream
+ Int_t* GetPadArray() const { return fPad;} //Get pad array from stream decoded
+ Int_t* GetChargeArray() const { return fCharge;} //Get the charge of the pads from dedcoded stream
+ Int_t* GetnDDLInStream() const { return fnDDLInStream;} //Get the DDL input check array
+ Int_t* GetnDDLOutStream() const { return fnDDLOutStream;} //Get the DDL output check array
+ Int_t Pc ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2P(GetPad(ddl,row,dil,pad));} //PC position number
+ Int_t PadPcX ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2X(GetPad(ddl,row,dil,pad));} //pad pc x # 0..79
+ Int_t PadPcY ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2Y(GetPad(ddl,row,dil,pad));} //pad pc y # 0..47
+
+ static inline const Char_t* GetErrName(Int_t eType);
+ inline Bool_t SetZeroSup (Bool_t isSup);
+ inline Bool_t GetZeroSup()const;
+ inline Int_t GetErrors(Int_t ddl,Int_t eType)const; //Get errors and occurance
+ Int_t GetDDLNumber() const{ return fDDLNumber;} //return the number of DDL actually being decoded
+ UInt_t GetLDCNumber() const{ return fLDCNumber;} //return the number of LDC actually being decoded
+ UInt_t GetTimeStamp() const{ return fTimeStamp;} //return the time stamp of the event actually being decoded
+
+ void SetTurbo(Bool_t isTurbo){fTurbo=isTurbo;} // Enable/Disable Turbo
+ Bool_t GetTurbo(){ return fTurbo;} // Enable Turbo
+ Bool_t Turbo(); // Read HMPID Raw data without error checks
Bool_t ReadHMPIDRawData(); // Read HMPID Raw data
- Bool_t ReadSegment(UInt_t word32,Int_t &cntSegment); // Read Segment
- Bool_t ReadRow(UInt_t word32,Int_t &cntRow); // Read Row
- Bool_t ReadDilogic(UInt_t word32,Int_t &cntDilogic); // Read Dilogic
+ Bool_t ReadSegment(Int_t &cntSegment); // Read Segment
+ Bool_t ReadRow(Int_t &cntRow); // Read Row
+ Bool_t ReadDilogic(Int_t &cntDilogic); // Read Dilogic
- Bool_t CheckRow(UInt_t row); // Check Row
- Bool_t CheckDilogic(UInt_t dilogic); // Check Dilogic
- Bool_t CheckPad(UInt_t pad); // Check pad
- Bool_t CheckEoE(UInt_t word,Int_t &nDil); // Check EoE
- Bool_t CheckRowMarker(UInt_t word); // Check RowMarker
- Bool_t CheckSegment(UInt_t word); // Check Segment
- void DumpData(Int_t nw); // Dump Data
- void StorePosition(); //
+ Bool_t CheckRow(UInt_t row); // Check Row
+ Bool_t CheckDilogic(UInt_t dilogic); // Check Dilogic
+ Bool_t CheckPad(UInt_t pad); // Check pad
+ Bool_t CheckEoE(Int_t &nDil); // Check EoE
+ Bool_t CheckRowMarker(); // Check RowMarker
+ Bool_t CheckSegment(); // Check Segment
+ void DumpData(Int_t nw); // Dump Data
+ void StorePosition(); //Debug purpose
- inline void Raw (UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a); //digit->(w32,ddl,r,d,a)
- inline void Raw (Int_t ddl,Int_t r,Int_t d,Int_t a); //raw->abs pad number
- inline Bool_t Raw (UInt_t w32,Int_t ddl,AliRawReader *pRR); //(w32,ddl)->digit
- inline void SetCharge (Int_t ddl,Int_t row,Int_t dil,Int_t pad,Int_t q);
+// inline void Raw (UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a); //digit->(w32,ddl,r,d,a)
+// inline void Raw (Int_t ddl,Int_t r,Int_t d,Int_t a); //raw->abs pad number
+// inline Bool_t Raw (UInt_t w32,Int_t ddl,AliRawReader *pRR); //(w32,ddl)->digit
inline void WriteRaw (TObjArray *pDigLst ); //write as raw stream
inline void WriteRowMarker (AliFstream *ddl,UInt_t size);
inline void WriteEoE (AliFstream *ddl,UInt_t row,UInt_t dil,UInt_t wordCnt);
- inline void WriteSegMarker (AliFstream *ddl,UInt_t row);
+ inline void WriteSegMarker (AliFstream *ddl,UInt_t row, Int_t nwInSeg);
// inline TClonesArray ReMap(TClonesArray *pDigIn);
enum EDirection {kFwd,kBwd};
kbit17,kbit18,kbit19,kbit20,kbit21,kbit22,kbit23,kbit24,
kbit25,kbit26,kbit27,kbit28,kbit29,kbit30,kbit31,kbit32};
- enum EHMPIDRawStreamError {
- kRawDataSizeErr = 1,
- kRowMarkerErr = 2,
- kWrongRowErr = 3,
- kWrongDilogicErr = 4,
- kWrongPadErr = 5,
- kEoEFlagErr = 6,
- kEoESizeErr = 7,
- kEoEDILOGICErr = 8,
- kEoERowErr = 9,
- kBadSegWordErr = 10,
- kWrongSegErr = 11,
- kRowMarkerSizeErr = 12,
- kSumErr=13 //This is always the last one, to retreive the number of errors
- };
-
- enum {
+ enum EHMPIDRawStreamError { kRawDataSizeErr = 0, kRowMarkerErr = 1, kWrongRowErr = 2, kWrongDilogicErr = 3,
+ kWrongPadErr = 4, kEoEFlagErr = 5, kEoESizeErr = 6, kEoEDILOGICErr = 7,
+ kEoERowErr = 8, kBadSegWordErr = 9, kWrongSegErr = 10, kRowMarkerSizeErr = 11,
+ kPedQZero =12, kSumErr = 13 //This is always the last one, to retreive the number of errors
+ }; //Always check the updated list of names in the .cxx file for print-out!
+
+ enum {
kNRows = 24, // Number of rows (starting from 1 !)//was25
kNDILOGICAdd = 10, // Number of DILOGIC addresses in a row (starting from 1 !) //was11
kNPadAdd = 48, // Number of pad row
kNRowsPerSegment = 8, // Number of rows per segment
kNDDL = 14
};
- enum EHMPIDRawError {
+ enum EHMPIDRawError {
kInvalidRawDataWord = 1
};
AliHMPIDRawStream& operator = (const AliHMPIDRawStream& stream);
AliHMPIDRawStream(const AliHMPIDRawStream& stream);
- UInt_t GetWord(Int_t n=1,EDirection dir=kFwd); // Get n-th word
+ Bool_t GetWord(Int_t n=1,EDirection dir=kFwd); // Get n-th word
UInt_t GetNextWord(); // Get next word
- Int_t fCharge[kNDDL][kNRows+1][kNDILOGICAdd+1][kNPadAdd]; // Array for charge values for all channels in one DDL
- Int_t fPad[kNDDL][kNRows+1][kNDILOGICAdd+1][kNPadAdd]; // Array for abs pad values for all channels in one DDL
- UInt_t fRawWord[kNDDL][kNRows+1][kNDILOGICAdd+1][kNPadAdd];// Array of raw words
- Int_t fNumOfErr[kSumErr]; // Store the numner of errors for a given error type
+ Int_t fNPads; // counter of pads in one DDL
+ Int_t *fCharge; // Array for charge values for all channels in one DDL
+ Int_t *fPad; // Array for abs pad values for all channels in one DDL
Int_t fDDLNumber; // index of current DDL number
- AliRawReader* fRawReader; // object for reading the raw data
- UChar_t* fData; // raw data
- Int_t fPosition; // current position in fData
- Bool_t fZeroSup;
-
- ClassDef(AliHMPIDRawStream, 1) // base class for reading HMPID raw digits
+ Int_t *fnDDLInStream; // if the DDL is in the raw data
+ Int_t *fnDDLOutStream; // if the DDL is in the raw data
+ UInt_t fLDCNumber; // index of current LDC number
+ UInt_t fTimeStamp; // TimeStamp
+ AliRawReader *fRawReader; // object for reading the raw data
+ UChar_t *fData; // raw data
+ Int_t **fNumOfErr; // Store the numner of errors for a given error type and a given DDL
+ Int_t fPosition; // current word
+ UInt_t fWord; // current position in fData
+ Bool_t fZeroSup; // set if zero suppression is applied
+ Int_t *fPos; // for debug purposes
+ Int_t fiPos; // counter for debug
+ Bool_t fTurbo; // kTRUE = Turbo decoding is called. DEFAULT: kFALSE = normal decoding is called
+ ClassDef(AliHMPIDRawStream, 2) // base class for reading HMPID raw digits
};
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ /*
void AliHMPIDRawStream::Raw(UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a)
{
// Convert raw stream word to raw word format
a=y2a[PadPcY(ddl,r,d,a)%6]+6*(PadPcX(ddl,r,d,a)%8); //ADDRESS 0..47
w32=0;
- AliBitPacking::PackWord((fCharge[ddl][r][d][a]>4095)?4095:(UInt_t)fCharge[ddl][r][d][a],w32, 0,11); // 0000 0rrr rrdd ddaa aaaa qqqq qqqq qqqq Qdc bits (00..11) counts (0..4095)
+ AliBitPacking::PackWord((fCharge[fNPads]>4095)?4095:(UInt_t)fCharge[fNPads],w32, 0,11); // 0000 0rrr rrdd ddaa aaaa qqqq qqqq qqqq Qdc bits (00..11) counts (0..4095)
//molnarl: Since in simulation the the charge can be > than 4095 but not in real life we need to protect. If fQ>4095 after packing we will get 0 for the charge!
assert(0<=a&&a<=47);AliBitPacking::PackWord( a ,w32,12,17); // 3322 2222 2222 1111 1111 1000 0000 0000 DILOGIC address bits (12..17) counts (0..47)
assert(1<=d&&d<=10);AliBitPacking::PackWord( d ,w32,18,21); // 1098 7654 3210 9876 5432 1098 7654 3210 DILOGIC number bits (18..21) counts (1..10)
assert(1<=r&&r<=24);AliBitPacking::PackWord( r ,w32,22,26); // Row number bits (22..26) counts (1..24)
}
+*/
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDRawStream::Raw(Int_t ddl,Int_t r,Int_t d,Int_t a)
+ /*
+Int_t AliHMPIDRawStream::Raw(Int_t ddl,Int_t r,Int_t d,Int_t a)
{
//Assign absolute pad ID based on ddl,row,dil,pad
//Arguments: DDL, row number, dilogic number, dilogic address(pad)
Int_t tmp=(r-1)/8; Int_t pc=(ddl%2)? 5-2*tmp:2*tmp;
Int_t px=(d-1)*8+a/6;
tmp=(ddl%2)?(24-r):r-1; Int_t py=6*(tmp%8)+a2y[a%6];
- fPad[ddl][r][d][a]=AliHMPIDParam::Abs(ch,pc,px,py);
+ return AliHMPIDParam::Abs(ch,pc,px,py);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Bool_t AliHMPIDRawStream::Raw(UInt_t w32,Int_t ddl, AliRawReader *pRR)
fCharge[ddl][r][d][a]=q;
return kTRUE;
}
-//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDRawStream::SetCharge(Int_t ddl,Int_t row,Int_t dil,Int_t pad,Int_t q)
-{
- //Setter for the charger in the raw stream
- //Arguments: DDL, row number, dilogic number, dilogic address(pad), charge
- //Returns: Charge from the raw stream
- fCharge[ddl][row][dil][pad]=q;
- // return fCharge[ddl][row][dil][pad];
-
-}
+*/
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Int_t AliHMPIDRawStream::GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad)
{
// in case the charge from the channels
// has not been read or invalid arguments
- assert(0<=ddl&&ddl<=13);
- assert(1<=row&&row<=24);
- assert(1<=dil&&dil<=10);
- assert(0<=pad&&pad<=47);
-
+ //assert(0<=ddl&&ddl<=13); assert(1<=row&&row<=24); assert(1<=dil&&dil<=10); assert(0<=pad&&pad<=47);
+ /* clm */ //corrupted data from ddl aborts the pedestal run at the assert
+ if(ddl<0 || ddl >13 || row<1 || row >25 || dil<1 || dil >10 || pad<0 || pad >47 ) return -1;
+ /* clm */
Int_t a2y[6]={3,2,4,1,5,0}; //pady for a given padress (for single DILOGIC chip)
- Int_t ch=ddl/2;
- Int_t tmp=(row-1)/8; Int_t pc=(ddl%2)? 5-2*tmp:2*tmp;
- Int_t px=(dil-1)*8+pad/6;
- tmp=(ddl%2)?(24-row):row-1;
- Int_t py=6*(tmp%8)+a2y[pad%6];
-
- return fPad[ddl][row][dil][pad]=AliHMPIDParam::Abs(ch,pc,px,py);
-}//GetPad()
-//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDRawStream::GetCharge(Int_t ddl,Int_t row, Int_t dilogic, Int_t pad)
-{
- // The method returns the charge collected
- // in a particular channel
- // Return -1 in case the charge from the channels
- // has not been read or invalid arguments
- if (ddl < 0 || ddl > kNDDL) {
- AliError(Form("Wrong DDL index %d!",ddl));
- return 0;
- }
- if (row < 1 || row > kNRows) {
- AliError(Form("Wrong row index %d!",row));
- return 0;
- }
+ Int_t ch=ddl/2;
+ Int_t tmp=(24-row)/8;
+ Int_t pc=(ddl%2)?5-2*tmp:2*tmp;
+ Int_t px=(kNDILOGICAdd+1 - dil)*8-pad/6-1; //flip according to Paolo (2-9-2008)
- if (dilogic < 1 || dilogic > kNDILOGICAdd) {
- AliError(Form("Wrong DILOGIC address %d!",dilogic));
- return 0;
- }
-
- if (pad >= kNPadAdd) {
- AliError(Form("Wrong pad index %d!",pad));
- return 0;
- }
+ tmp=(ddl%2)?row-1:(24-row);
+ Int_t py=6*(tmp%8)+a2y[pad%6];
- return fCharge[ddl][row][dilogic][pad];
-
-}
+ return AliHMPIDParam::Abs(ch,pc,px,py);
+}//GetPad()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDRawStream::WriteRowMarker(AliFstream *ddl,UInt_t size)
{
//Arguments: ddl stream and the size of the block of the given row, the siye is at least the 10 EoE words!
//Returns: nothing
UInt_t w32=0;
- UInt_t marker=12968; //ror marker: 32a8 in hexa; 12968 in decimal
+ UInt_t marker=13992; //for pedestal=12968 == 32a8 for zero suppressed 36a8
AliBitPacking::PackWord(size, w32, 16,31); //number of roaw written after row marker (digits and EoE)
- AliBitPacking::PackWord(marker,w32,0,15); //32a8=12968
+ AliBitPacking::PackWord(marker,w32,0,15); //the marker word
ddl->WriteBuffer((char*)&w32,sizeof(w32));
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ddl->WriteBuffer((char*)&w32,sizeof(w32));
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDRawStream::WriteSegMarker(AliFstream *ddl,UInt_t row)
+void AliHMPIDRawStream::WriteSegMarker(AliFstream *ddl,UInt_t row, Int_t nwInSeg)
{
//Writes the segment marker (after 8 rows) into the ddl stream
- //Arguments: ddl stream and the segment: row 8 -> 0x5900, row 16 -> 5901, row 24 -> 5902
+ //Arguments: ddl stream and the segment: row 8 -> 0x5800, row 16 -> 5801, row 24 -> 5802 for pedestal
//Retruns: nothing
UInt_t w32=0;
- AliBitPacking::PackWord((UInt_t)43791, w32,16,31); //43791==AB0F
- AliBitPacking::PackWord((UInt_t)(22784+row/8),w32, 0,15); //22784==5900
- ddl->WriteBuffer((char*)&w32,sizeof(w32));
+
+ //Segment marker: 2736 == ab0
+ //AliBitPacking::PackWord((UInt_t)0 ,w32,27,31); //zero out the rest of the bits, since they are not needed
+ AliBitPacking::PackWord((UInt_t)2736 ,w32,20,31); //ab0 the segment marker word
+ AliBitPacking::PackWord((UInt_t)nwInSeg,w32, 8,19); //number of words in the segment
+ AliBitPacking::PackWord((UInt_t)(row/8),w32, 0, 7); //segment 0,1,2
+ ddl->WriteBuffer((char*)&w32,sizeof(w32));
+ //Printf("Segment word created is: %x",w32);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Bool_t AliHMPIDRawStream::SetZeroSup (Bool_t isSup)
return fZeroSup;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Bool_t AliHMPIDRawStream::GetZeroSup()
+Bool_t AliHMPIDRawStream::GetZeroSup()const
{
if(fZeroSup==kTRUE) return kTRUE;
else return kFALSE;
Int_t cntLeoe,cntReoe;
UInt_t posL,posR;
UInt_t cntLseg,cntRseg;
+ UInt_t cntwInLseg=0,cntwInRseg=0;
Int_t cntRdig=0,cntLdig=0;
UInt_t posLmarker,posRmarker;
digcnt=0;
TClonesArray *pDigCh=(TClonesArray *)pDigAll->At(iCh); //list of digits for current chamber
- //Printf("::::::::::::::::::; Number of Digits to write: %d == %d",pDigCh->GetEntriesFast(),pDigCh->GetEntries());
+
for(Int_t iDig=0;iDig<pDigCh->GetEntriesFast();iDig++){//digits loop
AliHMPIDDigit *pDig1=(AliHMPIDDigit*)pDigCh->At(iDig);
- pDig1->Raw(w32,ddl,r,d,a);
+ pDig1->Raw(w32,ddl,r,d,a); //??????????
isDigThere[ddl][r][d][a]=iDig;
}
for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){ //AliHMPIDRawStream::kNRows=25!
cntRrow=0;cntLrow=0;cntLseg=0;cntRseg=0;//
cntLeoe=0;cntReoe=0;
- posLmarker=ddlL->Tellp(); WriteRowMarker(ddlL,(UInt_t)1); cntL++; cntRrow++;
- posRmarker=ddlR->Tellp(); WriteRowMarker(ddlR,(UInt_t)1); cntR++; cntLrow++;
+ posLmarker=ddlL->Tellp(); WriteRowMarker(ddlL,(UInt_t)1); cntL++; cntRrow++; cntwInRseg++;
+ posRmarker=ddlR->Tellp(); WriteRowMarker(ddlR,(UInt_t)1); cntR++; cntLrow++; cntwInLseg++;
for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){ //AliHMPIDRawStream::kNDILOGICAdd = 11!
cntLpad=0;cntRpad=0;
for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){ //AliHMPIDRawStream::kNPadAdd = 48
AliHMPIDDigit *pDig=(AliHMPIDDigit*)pDigCh->At(isDigThere[iddl][row][dil][pad]);
pDig->Raw(w32,ddl,r,d,a);
if(pDig->Q() < 0 ) continue; //We can turn of the zero sup for pedestal simulation
- //Printf("::::::::::::::: ddl from Digit : %d",ddl);
- if(ddl%2){ //write raw digit selecting on DDL
- ddlL->WriteBuffer((char*)&w32,sizeof(w32)); cntL++; cntLpad++; cntLrow++; cntLdig++;//Printf(" WL: %x isDig: %d",w32,isDigThere[iddl][row][dil][pad]);
+ if(ddl%2){ //write raw digit selecting on DDL
+ ddlL->WriteBuffer((char*)&w32,sizeof(w32)); cntL++; cntLpad++; cntLrow++; cntLdig++; cntwInLseg++;//Printf(" WL: %x isDig: %d",w32,isDigThere[iddl][row][dil][pad]);
}else{
- ddlR->WriteBuffer((char*)&w32,sizeof(w32)); cntR++; cntRpad++; cntRrow++; cntRdig++;//Printf(" WR: %x isDig: %d",w32,isDigThere[iddl][row][dil][pad]);
+ ddlR->WriteBuffer((char*)&w32,sizeof(w32)); cntR++; cntRpad++; cntRrow++; cntRdig++;cntwInRseg++;//Printf(" WR: %x isDig: %d",w32,isDigThere[iddl][row][dil][pad]);
}
}//ddl
}//isDig
}//pad
- WriteEoE(ddlL,row,dil,cntLpad); cntL++; cntLrow++; cntLeoe++; //molnarl: write EoE markers
- WriteEoE(ddlR,row,dil,cntRpad); cntR++; cntRrow++; cntReoe++;
+ WriteEoE(ddlL,row,dil,cntLpad); cntL++; cntLrow++; cntLeoe++; cntwInLseg++; //molnarl: write EoE markers
+ WriteEoE(ddlR,row,dil,cntRpad); cntR++; cntRrow++; cntReoe++; cntwInRseg++;
}//dil
if(row%8==0){
- WriteSegMarker(ddlL,row); cntL++; cntLseg++;
- WriteSegMarker(ddlR,row); cntR++; cntRseg++;
+ WriteSegMarker(ddlL,row,cntwInLseg); cntL++; cntLseg++; cntwInLseg=0;
+ WriteSegMarker(ddlR,row,cntwInRseg); cntR++; cntRseg++; cntwInRseg=0;
}
posL=ddlL->Tellp(); ddlL->Seekp(posLmarker); WriteRowMarker(ddlL,(UInt_t)(cntLrow-1)); ddlL->Seekp(posL); //find the marker position write and go back to the actual position to continue writing
posR=ddlR->Tellp(); ddlR->Seekp(posRmarker); WriteRowMarker(ddlR,(UInt_t)(cntRrow-1)); ddlR->Seekp(posR);
}//chambers loop
}//WriteRaw()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDRawStream::GetErrors(Int_t eType)
+Int_t AliHMPIDRawStream::GetErrors(Int_t ddl,Int_t eType)const
{
// Return the number of errors for a given error tye during raw data reading
// Arguments: errorType
-// Returns: error or -999 if error Type does not exist
+// Returns: error or -999 if error Type does not exist
- if(eType < 1 || eType> kSumErr-1 ) return -999;
- else
- return fNumOfErr[eType];
-
-
+ if(eType < 0 || eType> kSumErr || ddl < 0 || ddl > kNDDL-1 ) return -999;
+ else return fNumOfErr[ddl][eType];
} //GetErrors()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+const Char_t* AliHMPIDRawStream::GetErrName(Int_t eType)
+{
+ // Return the name of the error for a given error tye during raw data reading
+ // Arguments: errorType
+ // Returns: error or -999 if error Type does not exist
+ const Char_t *eName[]={ "kRawDataSizeErr", "kRowMarkerErr" , "kWrongRowErr" , "kWrongDilogicErr",
+ "kWrongPadErr" , "kEoEFlagErr" , "kEoESizeErr" , "kEoEDILOGICErr",
+ "kEoERowErr" , "kBadSegWordErr", "kWrongSegErr" , "kRowMarkerSizeErr",
+ "kPedQZero" , "kSumErr" };
+ const Char_t *eNoErr="NotDefinedErrorType";
+ if(eType<0 || eType>kSumErr) return eNoErr;
+ else return eName[eType];
+}//GetErrName()
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+
#endif
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff