#include <TSystem.h>
#include "AliZDCRawStream.h"
#include "AliRawReader.h"
#include "AliRawDataHeader.h"
#include "AliRawEventHeaderBase.h"
#include "AliLog.h"
ClassImp(AliZDCRawStream)
AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
fRawReader(rawReader),
fBuffer(0),
fReadOutCard(-1),
fEvType(0),
fPosition(0),
fIsCalib(kFALSE),
fIsDARCHeader(kFALSE),
fIsHeaderMapping(kFALSE),
fIsChMapping(kFALSE),
fIsADCDataWord(kFALSE),
fIsADCHeader(kFALSE),
fIsADCEOB(kFALSE),
fSODReading(kFALSE),
fIsMapRead(kFALSE),
fReadCDH(kFALSE),
fDeadfaceOffset(-1),
fDeadbeefOffset(-1),
fDataOffset(0),
fModType(-1),
fADCModule(-1),
fADCNChannels(-1),
fADCChannel(-1),
fADCValue(-1),
fADCGain(-1),
fIsUnderflow(kFALSE),
fIsOverflow(kFALSE),
fScGeo(0),
fScNWords(0),
fScTriggerSource(0),
fScTriggerNumber(0),
fIsScEventGood(kTRUE),
fIsScHeaderRead(kFALSE),
fScStartCounter(0),
fScEvCounter(0),
fIsScalerWord(kFALSE),
fDetPattern(0),
fTrigCountNWords(0),
fIsTriggerScaler(kFALSE),
fTrigCountStart(0),
fMBTrigInput(0),
fCentralTrigInput(0),
fSCentralTrigInput(0),
fEMDTrigInput(0),
fL0Received(0),
fMBtrig2CTP(0),
fCentralTrig2CTP(0),
fSCentralTrig2CTP(0),
fEMDTrig2CTP(0),
fTrigHistNWords(0),
fIsTriggerHistory(kFALSE),
fTrigHistStart(0),
fPileUpBit1stWord(0),
fL0Bit1stWord(0),
fCentralTrigHist(0),
fMBTrigHist(0),
fPileUpBit2ndWord(0),
fL0Bit2ndWord(0),
fSCentralTrigHist(0),
fEMDTrigHist(0),
fNChannelsOn(0),
fCurrentCh(-1),
fCabledSignal(-1),
fCurrScCh(-1),
fCurrTDCCh(-1),
fIsADCEventGood(kTRUE),
fIsL0BitSet(kTRUE),
fIsPileUpEvent(kFALSE),
fIsADDChannel(kFALSE),
fADDADCdatum(0),
fIsTDCHeaderRead(kFALSE),
fTDCStartCounter(0),
fIsZDCTDCHeader(kFALSE),
fIsZDCTDCdatum(kFALSE),
fZDCTDCdatum(0),
fIsADDTDCHeader(kFALSE),
fIsADDTDCdatum(kFALSE),
fADDTDCdatum(0)
{
fRawReader->Reset();
fRawReader->Select("ZDC");
const int kNch = 48;
for(Int_t i=0; i<kNch; i++){
for(Int_t j=0; j<5; j++){
fMapADC[i][j]=-1;
if(i<32){
fScalerMap[i][j]=-1;
if(j<3) fTDCMap[i][j]=-1;
}
}
}
for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
}
AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
TObject(stream),
fRawReader(stream.fRawReader),
fBuffer(stream.GetRawBuffer()),
fReadOutCard(stream.GetReadOutCard()),
fEvType(stream.fEvType),
fPosition(stream.fPosition),
fIsCalib(stream.fIsCalib),
fIsDARCHeader(stream.fIsDARCHeader),
fIsHeaderMapping(stream.fIsHeaderMapping),
fIsChMapping(stream.fIsChMapping),
fIsADCDataWord(stream.fIsADCDataWord),
fIsADCHeader(stream.fIsADCHeader),
fIsADCEOB(stream.fIsADCEOB),
fSODReading(stream.fSODReading),
fIsMapRead(stream.fIsMapRead),
fReadCDH(stream.fReadCDH),
fDeadfaceOffset(stream.GetDeadfaceOffset()),
fDeadbeefOffset(stream.GetDeadbeefOffset()),
fDataOffset(stream.GetDataOffset()),
fModType(stream.GetModType()),
fADCModule(stream.GetADCModule()),
fADCNChannels(stream.GetADCNChannels()),
fADCChannel(stream.GetADCChannel()),
fADCValue(stream.GetADCValue()),
fADCGain(stream.GetADCGain()),
fIsUnderflow(stream.fIsUnderflow),
fIsOverflow(stream.fIsOverflow),
fScGeo(stream.GetScGeo()),
fScNWords(stream.GetScNWords()),
fScTriggerSource(stream.GetScTriggerSource()),
fScTriggerNumber(stream.fScTriggerNumber),
fIsScEventGood(stream.fIsScEventGood),
fIsScHeaderRead(stream.fIsScHeaderRead),
fScStartCounter(stream.fScStartCounter),
fScEvCounter(stream.fScEvCounter),
fIsScalerWord(stream.fIsScalerWord),
fDetPattern(stream.fDetPattern),
fTrigCountNWords(stream.fTrigCountNWords),
fIsTriggerScaler(stream.fIsTriggerScaler),
fTrigCountStart(stream.fTrigCountStart),
fMBTrigInput(stream.fMBTrigInput),
fCentralTrigInput(stream.fCentralTrigInput),
fSCentralTrigInput(stream.fSCentralTrigInput),
fEMDTrigInput(stream.fEMDTrigInput),
fL0Received(stream.fL0Received),
fMBtrig2CTP(stream.fMBtrig2CTP),
fCentralTrig2CTP(stream.fCentralTrig2CTP),
fSCentralTrig2CTP(stream.fSCentralTrig2CTP),
fEMDTrig2CTP(stream.fEMDTrig2CTP),
fTrigHistNWords(stream.fTrigHistNWords),
fIsTriggerHistory(stream.fIsTriggerHistory),
fTrigHistStart(stream.fTrigHistStart),
fPileUpBit1stWord(stream.fPileUpBit1stWord),
fL0Bit1stWord(stream.fL0Bit1stWord),
fCentralTrigHist(stream.fCentralTrigHist),
fMBTrigHist(stream.fMBTrigHist),
fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
fL0Bit2ndWord(stream.fL0Bit2ndWord),
fSCentralTrigHist(stream.fSCentralTrigHist),
fEMDTrigHist(stream.fEMDTrigHist),
fNChannelsOn(stream.fNChannelsOn),
fCurrentCh(stream.fCurrentCh),
fCabledSignal(stream.GetCabledSignal()),
fCurrScCh(stream.fCurrScCh),
fCurrTDCCh(stream.fCurrTDCCh),
fIsADCEventGood(stream.fIsADCEventGood),
fIsL0BitSet(stream.fIsL0BitSet),
fIsPileUpEvent(stream.fIsPileUpEvent),
fIsADDChannel(stream.fIsADDChannel),
fADDADCdatum(stream.fADDADCdatum),
fIsTDCHeaderRead(stream.fIsTDCHeaderRead),
fTDCStartCounter(stream.fTDCStartCounter),
fIsZDCTDCHeader(stream.fIsZDCTDCHeader),
fIsZDCTDCdatum(stream.fIsZDCTDCdatum),
fZDCTDCdatum(stream.fZDCTDCdatum),
fIsADDTDCHeader(stream.fIsADDTDCHeader),
fIsADDTDCdatum(stream.fIsADDTDCdatum),
fADDTDCdatum(stream.fADDTDCdatum)
{
const int kNch = 48;
for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
for(Int_t i=0; i<kNch; i++){
for(Int_t j=0; j<5; j++){
fMapADC[i][j] = stream.fMapADC[i][j];
if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
}
}
for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
}
AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
)
{
Fatal("operator =", "assignment operator not implemented");
return *this;
}
AliZDCRawStream::~AliZDCRawStream()
{
}
void AliZDCRawStream::ReadChMap()
{
const int kNch = 48;
AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
AliZDCChMap * chMap = GetChMap();
if(chMap){
for(Int_t i=0; i<kNch; i++){
fMapADC[i][0] = chMap->GetADCModule(i);
fMapADC[i][1] = chMap->GetADCChannel(i);
fMapADC[i][2] = chMap->GetADCSignalCode(i);
fMapADC[i][3] = chMap->GetDetector(i);
fMapADC[i][4] = chMap->GetSector(i);
}
fIsMapRead = kTRUE;
}
else printf(" AliZDCRawStream::ReadChMap -> No valid object fr mapping loaded!!!\n\n");
}
void AliZDCRawStream::ReadCDHHeader()
{
const AliRawDataHeader* header = fRawReader->GetDataHeader();
const AliRawDataHeaderV3* headerV3 = fRawReader->GetDataHeaderV3();
if(!header && !headerV3) {
AliError(" No CDH in raw data streaming");
fRawReader->AddMajorErrorLog(kCDHError);
return;
}
UChar_t message = header ? header->GetAttributes() : headerV3->GetAttributes();
if((message & 0xf0) == 0x0){
}
else if((message & 0xf0) == 0x10){
}
else if((message & 0xf0) == 0x20){
}
else if((message & 0xf0) == 0x30){
}
else if((message & 0xf0) == 0x40){
}
else if((message & 0xf0) == 0x50){
}
else if((message & 0xf0) == 0x60){
}
else if((message & 0xf0) == 0x70){
}
if((message & 0x08) == 0){
fReadOutCard = 0;
fIsDARCHeader = kTRUE;
}
else if((message & 0x08) == 0x08){
fReadOutCard = 1;
}
fIsCalib = (header ? header->GetL1TriggerMessage() : headerV3->GetL1TriggerMessage()) & 0x1;
}
Bool_t AliZDCRawStream::Next()
{
if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
const int kNch = 48;
fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE;
fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
fSector[0] = fSector[1] = -1;
for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
fEvType = fRawReader->GetType();
if(fPosition==0){
ReadCDHHeader();
if(!fReadCDH) fReadOutCard=1;
fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;fNChannelsOn=0;
}
if(fBuffer == 0xcafefade){
return kFALSE;
}
if(fReadOutCard==0 && fIsDARCHeader){
if(fIsCalib){
fDeadfaceOffset = 9;
fDeadbeefOffset = 25;
}
else{
fDeadfaceOffset = 1;
fDeadbeefOffset = 7;
}
fDataOffset = 1+fDeadbeefOffset;
fIsDARCHeader = kFALSE;
}
if(fEvType==10){
if(fSODReading){
if(fPosition>=fDataOffset){
if((fBuffer&0xff000001) == 0xff000001){
if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;
}
else{
printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
fSODReading = kFALSE;
return kFALSE;
}
}
else if((fBuffer&0xff000002) == 0xff000002){
fPosition++;
return kFALSE;
}
else if((fBuffer&0x80000000)>>31 == 1){
fIsHeaderMapping = kTRUE;
fADCModule = ((fBuffer & 0x7f000000)>>24);
fModType = ((fBuffer & 0x7ff00)>>8);
fADCNChannels = (fBuffer & 0xff);
printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
}
else if((fBuffer&0x80000000)>>31 == 0){
fADCChannel = ((fBuffer & 0x3fff0000)>>16);
fCabledSignal = (fBuffer&0xffff);
if(fModType == kV965){
if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){
fIsChMapping = kTRUE;
fMapADC[fCurrentCh][0] = fADCModule;
fMapADC[fCurrentCh][1] = fADCChannel;
fMapADC[fCurrentCh][2] = fCabledSignal;
fNChannelsOn++;
if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
|| fCabledSignal==24 || fCabledSignal==48){
fMapADC[fCurrentCh][3] = 4;
if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot) fMapADC[fCurrentCh][4]=1;
else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot) fMapADC[fCurrentCh][4]=2;
else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot) fMapADC[fCurrentCh][4]=3;
else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot) fMapADC[fCurrentCh][4]=4;
else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5;
}
else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
fMapADC[fCurrentCh][3] = 5;
if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot) fMapADC[fCurrentCh][4]=0;
else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1;
else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2;
else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3;
else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4;
}
else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
|| fCabledSignal==25 || fCabledSignal==49){
fMapADC[fCurrentCh][3] = 1;
if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot) fMapADC[fCurrentCh][4]=0;
else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1;
else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2;
else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3;
else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4;
else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5;
}
else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
fMapADC[fCurrentCh][3] = 2;
if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot) fMapADC[fCurrentCh][4]=0;
else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1;
else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2;
else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3;
else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4;
}
else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
fMapADC[fCurrentCh][3] = 3;
if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot) fMapADC[fCurrentCh][4]=1;
else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2;
}
fCurrentCh++;
}
}
else if(fModType == kV830){
fIsChMapping = kTRUE;
fScalerMap[fCurrScCh][0] = fADCModule;
fScalerMap[fCurrScCh][1] = fADCChannel;
fScalerMap[fCurrScCh][2] = fCabledSignal;
if((fCabledSignal>=2 && fCabledSignal<=6) ||
(fCabledSignal>=61 && fCabledSignal<=65)){
fScalerMap[fCurrScCh][3] = 4;
if(fCabledSignal==kZNAC || fCabledSignal==kZNACD) fScalerMap[fCurrScCh][4]=0;
else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1;
else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2;
else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3;
else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4;
}
else if((fCabledSignal>=7 && fCabledSignal<=11) ||
(fCabledSignal>=66 && fCabledSignal<=70)){
fScalerMap[fCurrScCh][3] = 5;
if(fCabledSignal==kZPAC || fCabledSignal==kZPACD) fScalerMap[fCurrScCh][4]=0;
else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1;
else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2;
else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3;
else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4;
}
else if((fCabledSignal>=12 && fCabledSignal<=16) ||
(fCabledSignal>=71 && fCabledSignal<=75)){
fScalerMap[fCurrScCh][3] = 1;
if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD) fScalerMap[fCurrScCh][4]=0;
else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1;
else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2;
else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3;
else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4;
}
else if((fCabledSignal>=17 && fCabledSignal<=21) ||
(fCabledSignal>=76 && fCabledSignal<=80)){
fScalerMap[fCurrScCh][3] = 2;
if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0;
else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D) fScalerMap[fCurrScCh][4]=1;
else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D) fScalerMap[fCurrScCh][4]=2;
else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D) fScalerMap[fCurrScCh][4]=3;
else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D) fScalerMap[fCurrScCh][4]=4;
}
else if(fCabledSignal==22 || fCabledSignal==23 ||
fCabledSignal==81 || fCabledSignal==82){
fScalerMap[fCurrScCh][3] = 3;
if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D) fScalerMap[fCurrScCh][4]=1;
else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2;
}
fCurrScCh++;
}
else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){
fIsChMapping = kTRUE;
fTDCMap[fCurrTDCCh][0] = fADCModule;
fTDCMap[fCurrTDCCh][1] = fADCChannel;
fTDCMap[fCurrTDCCh][2] = fCabledSignal;
fCurrTDCCh++;
}
}
}
}
fPosition++;
return kTRUE;
}
if(fPosition<fDeadfaceOffset && fReadOutCard==0){
fPosition++;
return kTRUE;
}
else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
if(fBuffer != 0xdeadface){
fRawReader->AddMajorErrorLog(kDARCError);
}
else{
fPosition++;
return kTRUE;
}
}
else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
fPosition++;
return kTRUE;
}
else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
if(fBuffer != 0xdeadbeef){
fRawReader->AddMajorErrorLog(kDARCError);
fPosition++;
return kFALSE;
}
else{
fPosition++;
return kTRUE;
}
}
else if(fPosition>=fDataOffset){
if(!fSODReading && !fIsMapRead) ReadChMap();
if(fReadOutCard==0){
if(fPosition==fDataOffset){
if((fBuffer & 0x07000000) != 0x06000000){
fRawReader->AddMajorErrorLog(kZDCDataError);
}
}
else if(fPosition==fDataOffset+1){
if((fBuffer & 0x07000000) != 0x02000000){
AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
fRawReader->AddMajorErrorLog(kZDCDataError);
fIsADCEventGood = kFALSE;
fPosition++;
return kFALSE;
}
}
}
if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo;
else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo;
else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo &&
!fIsTriggerHistory && !fIsScHeaderRead && !fIsTriggerScaler){
if((fBuffer & 0x07000000) == 0x02000000){
fIsADCHeader = kTRUE;
fADCNChannels = ((fBuffer & 0x00003f00)>>8);
}
else if((fBuffer & 0x07000000) == 0x00000000){
fIsADCDataWord = kTRUE;
fADCChannel = ((fBuffer & 0x1e0000) >> 17);
fADCGain = ((fBuffer & 0x10000) >> 16);
fADCValue = (fBuffer & 0xfff);
if(fMapADC[0][0]==-1){
printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
return kFALSE;
}
Int_t foundMapEntry = kFALSE;
for(Int_t k=0; k<kNch; k++){
if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
fSector[0] = fMapADC[k][3];
fSector[1] = fMapADC[k][4];
foundMapEntry = kTRUE;
break;
}
}
if(foundMapEntry==kFALSE && fEvType==7){
AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
fPosition,fADCModule,fADCChannel));
}
if(foundMapEntry==kTRUE && fEvType==7){
if(fSector[0]<1 || fSector[0]>5){
AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
fRawReader->AddMajorErrorLog(kInvalidSector);
}
if(fSector[1]<0 || fSector[1]>5){
AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
fRawReader->AddMajorErrorLog(kInvalidSector);
}
if(fADCModule<0 || fADCModule>3){
AliError(Form(" No valid ADC module: %d",fADCModule));
fRawReader->AddMajorErrorLog(kInvalidADCModule);
}
}
if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
}
else if((fBuffer & 0x07000000) == 0x04000000){
fIsADCEOB = kTRUE;
}
}
else if(fADCModule == kADDADCGeo){
if((fBuffer & 0x07000000) == 0x02000000){
fIsADCHeader = kTRUE;
fADCNChannels = ((fBuffer & 0x00003f00)>>8);
}
else if((fBuffer & 0x07000000) == 0x00000000){
fIsADDChannel = kTRUE;
fADCChannel = ((fBuffer & 0x1e0000) >> 17);
fADCGain = ((fBuffer & 0x10000) >> 16);
fADCValue = (fBuffer & 0xfff);
}
else if((fBuffer & 0x07000000) == 0x04000000){
fIsADCEOB = kTRUE;
}
}
else if(fADCModule==kTDCFakeGeo && fIsTDCHeaderRead==kFALSE){
fIsTDCHeaderRead = kTRUE;
fTDCStartCounter = fPosition;
fADCModule = (Int_t) (fBuffer & 0x1f);
if(fADCModule==kZDCTDCGeo){
fIsZDCTDCHeader = kTRUE;
}
else if(fADCModule==kADDTDCGeo){
fIsADDTDCHeader = kTRUE;
}
}
else if(fADCModule == kScalerGeo){
if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){
fScGeo = (fBuffer & 0xf8000000)>>27;
fScNWords = (fBuffer & 0x00fc0000)>>18;
fScTriggerSource = (fBuffer & 0x00030000)>>16;
fScTriggerNumber = (fBuffer & 0x0000ffff);
fIsScHeaderRead = kTRUE;
fScStartCounter = fPosition;
}
}
else if(fADCModule == kPUGeo){
fDetPattern = (fBuffer & 0x0000003f);
}
else if(fADCModule == kTrigScales){
if(fIsTriggerScaler == kFALSE){
fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
fTrigCountStart = fPosition;
fIsTriggerScaler = kTRUE;
}
}
else if(fADCModule == kTrigHistory){
if(fIsTriggerHistory == kFALSE){
fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
fTrigHistStart = fPosition;
fIsTriggerHistory = kTRUE;
}
}
if(fIsScHeaderRead && fPosition>=fScStartCounter+1){
fADCModule=kScalerGeo;
fIsADCDataWord=kFALSE;
fIsScalerWord=kTRUE;
fScEvCounter = fBuffer;
Int_t nWords = (Int_t) (fScNWords);
if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
}
if(fIsTDCHeaderRead && fIsZDCTDCHeader && fPosition>=fTDCStartCounter+1){
fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){
fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
fIsZDCTDCdatum = kTRUE;
fZDCTDCdatum = (Int_t) (fBuffer & 0x1fffff);
}
if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
fIsTDCHeaderRead = kFALSE;
}
}
if(fIsTDCHeaderRead && fIsADDTDCHeader && fPosition>=fTDCStartCounter+1){
fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){
fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
fIsADDTDCdatum = kTRUE;
fADDTDCdatum = (Int_t) (fBuffer & 0x1fffff);
}
if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
fIsTDCHeaderRead = kFALSE;
}
}
if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
else if(fPosition == fTrigCountStart+9){
fEMDTrig2CTP = fBuffer;
fIsTriggerScaler = kFALSE;
}
}
if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
if(fPosition == fTrigHistStart+1){
fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
fMBTrigHist = (fBuffer & 0x00007fff);
fCPTInput[0] = (fBuffer & 0x00000080) >> 6;
fCPTInput[1] = (fBuffer & 0x00400000) >> 21;
}
else if(fPosition == fTrigHistStart+fTrigHistNWords){
fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
fEMDTrigHist = (fBuffer & 0x00007fff);
fCPTInput[2] = (fBuffer & 0x00000080) >> 6;
fCPTInput[3] = (fBuffer & 0x00400000) >> 21;
fIsTriggerHistory = kFALSE;
if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
else{
fIsPileUpEvent = kTRUE;
printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
fPileUpBit1stWord, fPileUpBit2ndWord);
}
if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
else{
fIsL0BitSet = kFALSE;
printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
fL0Bit1stWord, fL0Bit2ndWord);
}
}
}
}
fPosition++;
return kTRUE;
}
AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
{
AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
return storage;
}
AliZDCChMap* AliZDCRawStream::GetChMap() const
{
AliZDCChMap *calibdata = 0x0;
AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
if(!entry) AliFatal("No calibration data loaded!");
else{
calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
}
return calibdata;
}