using std::cout;
using std::endl;
-AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
+//AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
+AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
{
- fFloatDataPtr = new double[1008];
+ // fFloatDataPtr = new double[1008];
+ fIntDataPtr = new UInt_t[1008];
}
AliHLTPHOSRawAnalyzer::~AliHLTPHOSRawAnalyzer()
}
-AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(AliHLTPHOSRawAnalyzer const&):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+//AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(AliHLTPHOSRawAnalyzer const&):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(AliHLTPHOSRawAnalyzer const&):fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
{
}
* @param dtaPtr Data array for wich a subarray will be taken to perform the fit
* @param fs the sampling frequency in entities of MHz. Needed in order to calculate physical time
**/
-AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+//AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
{
- fFloatDataPtr = dtaPtr;
+ // fIntDataPtr = dtaPtr;
fSampleFrequency = fs;
} //end
void
AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, int N)
{
- fFloatDataPtr = dataPtr;
+ // fFloatDataPtr = dataPtr;
+
cout << "Baseline correction not yet implemeted" << endl;
} //end BaselineCorrection
void
AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, double baselineValue)
{
- fFloatDataPtr = dataPtr;
+ // fFloatDataPtr = dataPtr;
printf("\nbaselineValue = %f\n", baselineValue);
cout << "Baseline correction not yet implemeted" << endl;
} //end BaslineCorrection
} //end GetEnergy
+/**
+ * Set data array. Overrides data data array set in the constructor.
+ **/
+//void
+//AliHLTPHOSRawAnalyzer::SetData(double *data)
+//{
+// fFloatDataPtr = data;
+//}
+void
+AliHLTPHOSRawAnalyzer::SetData(UInt_t *data)
+{
+ // fFloatDataPtr = data;
+ fIntDataPtr = data;
+}
+
/**
* Set data array. Overrides data data array set in the constructor.
**/
fFloatDataPtr = data;
}
+
+
void
AliHLTPHOSRawAnalyzer::SetSampleFreq(double freq)
{
}
+UInt_t
+AliHLTPHOSRawAnalyzer::GetMaxValue(UInt_t *dta, Int_t size) const
+{
+
+ Double_t tmpMax = 0;
+
+ for(int i = 0; i < size; i++)
+ {
+ if(dta[i] > tmpMax)
+ {
+ tmpMax = dta[i];
+ }
+ }
+
+ return tmpMax;
+
+}
+
+
+/*
Double_t
AliHLTPHOSRawAnalyzer::GetMaxValue(Double_t *dta, Int_t size) const
{
return tmpMax;
}
+*/
/// - @ref GetComponentID
/// - @ref Spawn
-
-
#include "AliHLTPHOSRawAnalyzer.h"
#include "AliHLTPHOSRawAnalyzerComponent.h"
#include "AliRawReaderMemory.h"
#include "AliCaloRawStream.h"
#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
#include "AliHLTPHOSRcuChannelDataStruct.h"
+#include "AliHLTDDLDecoder.h"
+#include "AliHLTAltroData.h"
+#include "AliHLTPHOSMapper.h"
using namespace std;
AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTPHOSProcessor(), fAnalyzerPtr(0),
fSendChannelData(kFALSE),fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
{
-
+ fMapperPtr = new AliHLTPHOSMapper();
}
//_________________________________________________________________________________________________
int
AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
- AliHLTUInt8_t tmpMod = 0;
- AliHLTUInt8_t tmpZ = 0;
- AliHLTUInt8_t tmpX = 0;
- AliHLTUInt8_t tmpGain = 0;
+ // cout << "AliHLTPHOSRawAnalyzerComponent::DoEven" << endl;
+ // cout << "AliHLTPHOSRawAnalyzerComponent::DoEven" << endl;
+ // cout << "evtData.fStructSize" << evtData.fStructSize << endl;
+ // cout << "evtData.fEventID" << evtData.fEventID << endl ;
+ cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent: evtData.fBlockCnt = " << evtData.fBlockCnt << endl ;
+ // cout << "size =" << size << endl;
+ // cout << "blocks->fSize =" << blocks->fSize << endl;
+ // cout << "blocks->fOffset =" << blocks->fOffset << endl;
+
+ // AliHLTUInt8_t tmpMod = 0;
+ // AliHLTUInt8_t tmpZ = 0;
+ // AliHLTUInt8_t tmpX = 0;
+ // AliHLTUInt8_t tmpGain = 0;
Int_t sampleCnt = 0;
Int_t processedChannels = 0;
UInt_t offset = 0;
const AliHLTComponentBlockData* iter = NULL;
unsigned long ndx;
+
for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
{
+ printf("\nNEW DDL BLOCK\n");
+
iter = blocks+ndx;
mysize = 0;
offset = tSize;
if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType )
{
- continue;
+ cout <<"WARNING: notAliHLTPHOSDefinitions::fgkDDLPackedRawDataTyp " << endl;
+ // continue;
}
- fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
- fAnalyzerPtr->SetData(fTmpChannelData);
+
+ fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
+
+ fDecoderPtr->Decode();
+
+
+ fOutPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
+
+ int tmpCnt = 0;
+ printf("\n********** NEW EVENT ************\n");
+ printf("\n********************************");
+ printf("\n********************************");
+ printf("\n********************************\n");
+
+ while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
+ {
+
+ // fDecoderPtr->NextChannel(fAltroDataPtr);
+
+ fAnalyzerPtr->SetData(fAltroDataPtr->fData);
+ fAnalyzerPtr->Evaluate(0, fAltroDataPtr->fDataSize);
+ // fOutPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
+
+
+
+ fOutPtr->fValidData[tmpChannelCnt].fGain = fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].gain;
+ fOutPtr->fValidData[tmpChannelCnt].fZ = fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].row;
+ fOutPtr->fValidData[tmpChannelCnt].fX = fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].col;
+ fOutPtr->fValidData[tmpChannelCnt].fEnergy = (float)fAnalyzerPtr->GetEnergy();
+ fOutPtr->fValidData[tmpChannelCnt].fTime = (float)fAnalyzerPtr->GetTiming();
+ tmpChannelCnt ++;
+
+
+ if(tmpCnt < 1)
+ {
+
+ printf("\n******New ALTRO BLOCK**********\n");
+ printf("tmpCnt = %d \n", tmpCnt);
+ printf("size = %d\n", fAltroDataPtr->fDataSize);
+ printf("harware adress = %d\n", fAltroDataPtr->fHadd);
+ // DumpData(fAltroDataPtr->fData, fAltroDataPtr->fDataSize, 4);
+ DumpData(fAltroDataPtr->fData, 128, 4);
+ // cout << "gain =" <<fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].gain << endl;
+ // cout << "row =" <<fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].row << endl;
+ // cout << "col =" <<fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].col << endl;
+ // cout << "Channel = " << fAltroDataPtr->GetChannel()<< endl;
+ // cout << "Chip = " << fAltroDataPtr->GetChip()<< endl;
+ // cout << "Card = " << fAltroDataPtr->GetCard()<< endl;
+ // cout << "Branch = " << fAltroDataPtr->GetBranch()<< endl;
+ // DumpData(fAltroDataPtr->fData, fAltroDataPtr->fDataSize , 4);
+ printf("\n****** END altroblock **********\n");
+ }
+
+ tmpCnt ++;
+
+ // printf("harware adress = %d\n", fAltroDataPtr->fHadd);
+ // printf("size = %d\n", fAltroDataPtr->fDataSize);
+ }
+
+
+ mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
+ // cout <<"Pushing data block" << endl;
+
+ fOutPtr->fCnt = tmpChannelCnt;
+ AliHLTComponentBlockData bd;
+ FillBlockData( bd );
+ bd.fOffset = offset;
+ bd.fSize = mysize;
+
+ bd.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
+ bd.fSpecification = 0xFFFFFFFF;
+ outputBlocks.push_back( bd );
+
+ tSize += mysize;
+ outBPtr += mysize;
+
+ if( tSize > size )
+ {
+ cout <<"kHLTLogFatal, HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent Too much data Data written over allowed buffer. Amount written:"
+ << tSize << " allowed" << size << endl;
+ Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
+ "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
+ , tSize, size );
+ return EMSGSIZE;
+ }
+
+ printf("\nEND DDL BLOCK\n");
+
+
+ }
+
+ fPhosEventCount++;
+
+ if(fPrintInfo == kTRUE)
+ {
+ if(fPhosEventCount%fPrintInfoFrequncy == 0)
+ {
+ cout <<"Analyzing event " << fPhosEventCount << "for Equippment " << fkEquippmentID << endl;
+ }
+ }
+ size = tSize;
+
+ return 0;
+}//end DoEvent
+
+
+
+
+
+ // printf("\nRawAnalyzer: printing data\n");
+
+
+ /*
+ int cnt = 0;
+
+ for(int i=0; i< 100; i ++)
+ {
+ if(cnt%4 == 0) printf("\n");
+ printf(":%d\t",fAltroDataPtr->fData[i] );
+ cnt ++;
+ }
+ */
+ // }
+
+
+
+
+ // while( fDecoderPtr->NextChannel(fAltroDataPtr))
+ // {
+ // fAnalyzerPtr->SetData(fTmpChannelData);
+ // }
+
+ /*
+
fOutPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
fOutPtr->fRcuX = fRcuX;
fOutPtr->fRcuZ = fRcuZ;
fOutPtr->fModuleID = fModuleID;
tmpChannelCnt = 0;
-
- while(fPHOSRawStream->Next())
+
+
+ while(fPHOSRawStream->Next())
{
- // cout << "rawanalyze fPHOSRawStream->Next()" <<endl;
if (fPHOSRawStream->IsNewHWAddress())
{
if(processedChannels > 0)
{
tmpStartIndex = fPHOSRawStream->GetTime();
}
-
+
fTmpChannelData[fPHOSRawStream->GetTime()] = fPHOSRawStream->GetSignal();
sampleCnt ++;
+
}
tmpChannelCnt ++;
+
+ cout <<"tmpChannnelCnt =" << tmpChannelCnt << endl;
+ // DumpChannelData(fTmpChannelData);
fAnalyzerPtr->SetData(fTmpChannelData);
fAnalyzerPtr->Evaluate(0, sampleCnt);
fOutPtr->fValidData[tmpChannelCnt].fGain = tmpGain;
ResetDataPtr(tmpStartIndex, sampleCnt);
sampleCnt = 0;
-
fOutPtr->fCnt = tmpChannelCnt;
AliHLTComponentBlockData bd;
FillBlockData( bd );
bd.fOffset = offset;
+
bd.fSize = mysize;
bd.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
bd.fSpecification = 0xFFFFFFFF;
, tSize, size );
return EMSGSIZE;
}
+ */
- }
-
+
+
+/*
fPhosEventCount++;
if(fPrintInfo == kTRUE)
}
}
size = tSize;
+
return 0;
}//end DoEvent
+*/
+
//_________________________________________________________________________________________________
int
AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
{
+
+cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
+
+ fAltroDataPtr = new AliHLTAltroData();
+ fDecoderPtr = new AliHLTDDLDecoder();
fSendChannelData = kFALSE;
fPrintInfo = kFALSE;
Reset();
fRawMemoryReader = new AliRawReaderMemory();
fPHOSRawStream = new AliCaloRawStream(fRawMemoryReader,"PHOS");
- fPHOSRawStream->SetOldRCUFormat(kFALSE);
+
+ // fPHOSRawStream->SetOldRCUFormat(kFALSE);
+
+ fPHOSRawStream->SetOldRCUFormat(kTRUE);
+
int iResult=0;
TString argument="";
iResult = ScanArguments(argc, argv);
cout << "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID <number>" << endl;
Logging( kHLTLogFatal, "HLT::AliHLTPHOSRcuHistogramProducerComponent::DoInt( int argc, const char** argv )", "Missing argument",
"The argument equippmentID is not set: set it with a component argumet like this: -equippmentID <number>");
- iResult = -2;
+ iResult = -3;
}
else
{
}
return iResult;
+
+
+return 0;
+
}
+/*
//_________________________________________________________________________________________________
void
AliHLTPHOSRawAnalyzerComponent::DumpData(int gain) const
}
}
}
+*/
//_________________________________________________________________________________________________
} // end Reset
+
+
//_________________________________________________________________________________________________
void
AliHLTPHOSRawAnalyzerComponent::ResetDataPtr(int startindex, int sampleCnt)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff