* provided "as is" without express or implied warranty. *
**************************************************************************/
-
-
#include "AliHLTPHOSRawAnalyzer.h"
#include "AliHLTPHOSRawAnalyzerComponent.h"
#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
#include "AliHLTPHOSMapper.h"
#include "AliHLTPHOSSanityInspector.h"
#include "AliHLTPHOSBaseline.h"
-#include "AliHLTPHOSDigitContainerDataStruct.h"
-#include "AliHLTPHOSDigitMaker.h"
#include "TFile.h"
#include "TTree.h"
#include "TClonesArray.h"
fDecoderPtr(0),
fAltroDataPtr(0),
fAltroBunchPtr(0),
- fDoPushCellEnergies(true),
- fDoMakeDigits(false),
- fDigitMakerPtr(0),
+ fDoPushRawData(false),
fDigitContainerPtr(0),
fDoSelectiveReadOut(false),
fSelectedChannelsList(0),
- fDoCheckDataSize(false)
+ fDoCheckDataSize(false),
+ fNCorruptedBlocks(0),
+ fNOKBlocks(0)
//fRawMemoryReader(0), fPHOSRawStream(0)
{
//comment
- // fMapperPtr = new AliHLTPHOSMapper();
+ fMapperPtr = new AliHLTPHOSMapper();
fAltroDataPtr = new AliAltroData();
fAltroBunchPtr = new AliAltroBunch();
fDecoderPtr = new AliAltroDecoder();
fSanityInspectorPtr = new AliHLTPHOSSanityInspector();
fSelectedChannelsList = new AliHLTUInt16_t[N_XCOLUMNS_RCU*N_ZROWS_RCU*N_GAINS];
}
+
+
AliHLTPHOSRawAnalyzerComponent::~AliHLTPHOSRawAnalyzerComponent()
{
- //comment
- if(fMapperPtr)
- {
- delete fMapperPtr;
- fMapperPtr = 0;
- }
- if(fAltroDataPtr)
- {
- delete fAltroDataPtr;
- fAltroDataPtr = 0;
- }
- if(fAltroBunchPtr)
- {
- delete fAltroBunchPtr;
- fAltroBunchPtr = 0;
- }
- if(fDecoderPtr)
- {
- delete fDecoderPtr;
- fDecoderPtr = 0;
- }
+ Deinit();
}
}
-
const char*
AliHLTPHOSRawAnalyzerComponent::GetComponentID()
{
return "AliPhosTestRaw";
}
+
void
AliHLTPHOSRawAnalyzerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
// see header file for class documentation
tgtList.clear();
tgtList.push_back(AliHLTPHOSDefinitions::fgkCellEnergyDataType);
- tgtList.push_back(AliHLTPHOSDefinitions::fgkDigitDataType);
- tgtList.push_back(kAliHLTDataTypeHwAddr16);
+ tgtList.push_back(kAliHLTDataTypeHwAddr16);
return tgtList.size();
}
AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
//comment
+
UInt_t offset = 0;
UInt_t mysize = 0;
UInt_t tSize = 0;
Float_t baseline = 0;
- UInt_t digitCount = 0;
AliHLTUInt8_t* outBPtr;
outBPtr = outputPtr;
const AliHLTComponentBlockData* iter = NULL;
Int_t nSamples = 0;
UInt_t nSelected = 0;
UInt_t specification = 0;
-
+
for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
{
+
Int_t tmpChannelCnt = 0;
iter = blocks+ndx;
mysize = 0;
offset = tSize;
Int_t crazyness = 0;
+ UInt_t tmpSize = 0;
mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType )
{
continue;
}
-
specification = specification|iter->fSpecification;
+
fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
fDecoderPtr->Decode();
fOutPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
+
fOutPtr->fRcuX = fRcuX;
fOutPtr->fRcuZ = fRcuZ;
fOutPtr->fModuleID =fModuleID;
- Reset(fOutPtr);
- rawDataBufferPos += (mysize)/sizeof(Int_t);
+ rawDataBufferPos += (mysize)/sizeof(Int_t);
+
while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
{
+
nSamples = fAltroDataPtr->GetDataSize() - 2;
+
if(fDoCheckDataSize)
{
if(nSamples != fNTotalSamples)
{
+ cout <<"processing event " << fPhosEventCount << endl;;
+ cout << "Wrong number of samples Expected "<< fNTotalSamples << " samples (assuming non zero supressed data) but recieved " << nSamples << endl;
Logging( kHLTLogError, __FILE__ , "Wrong number of samples", "Expected %lu samples (assuming non zero supressed data) but recieved %lu", fNTotalSamples, nSamples);
+ fNCorruptedBlocks ++;
+ continue;
}
}
-
- crazyness = fSanityInspectorPtr->CheckInsanity(fAltroDataPtr->GetData(), fAltroDataPtr->GetDataSize() - 2);
- fAnalyzerPtr->SetData(fAltroDataPtr->GetData());
+
+ fNOKBlocks ++;
+
+ if((fPhosEventCount%10 ==0) && fPhosEventCount !=0)
+ {
+ // float percent = ((float)(100*fNCorruptedBlocks))/((float)(fNOKBlocks + fNCorruptedBlocks) );
+ }
+
+ crazyness = fSanityInspectorPtr->CheckInsanity((const UInt_t*)fAltroDataPtr->GetData(), (const Int_t)(fAltroDataPtr->GetDataSize() - 2));
+
+ fAnalyzerPtr->SetData(fAltroDataPtr->GetData(), fAltroDataPtr->GetDataSize() -2);
fAnalyzerPtr->Evaluate(0, fAltroDataPtr->GetDataSize() -2);
- Int_t x = fMapperPtr->fHw2geomapPtr[fAltroDataPtr->GetHadd()].fXCol;
- Int_t z = fMapperPtr->fHw2geomapPtr[fAltroDataPtr->GetHadd()].fZRow;
- Int_t gain = fMapperPtr->fHw2geomapPtr[fAltroDataPtr->GetHadd()].fGain;
- validCellPtr = &(fOutPtr->fValidData[x][z][gain]);
- validCellPtr->fX = x;
- validCellPtr->fZ = z;
- validCellPtr->fGain = gain;
+ fOutPtr->fValidData[tmpChannelCnt].fZ = fMapperPtr->fHw2geomapPtr[fAltroDataPtr->GetHadd()].fZRow;
+ fOutPtr->fValidData[tmpChannelCnt].fX = fMapperPtr->fHw2geomapPtr[fAltroDataPtr->GetHadd()].fXCol;
+ fOutPtr->fValidData[tmpChannelCnt].fGain = fMapperPtr->fHw2geomapPtr[fAltroDataPtr->GetHadd()].fGain;
if(fUseBaselineSubtraction)
{
- baseline = fBaselines[validCellPtr->fX][validCellPtr->fZ][ validCellPtr->fGain];
+ baseline = fBaselines[fOutPtr->fValidData[tmpChannelCnt].fX][fOutPtr->fValidData[tmpChannelCnt].fZ][ fOutPtr->fValidData[tmpChannelCnt].fGain];
}
- baseline = 0;
+
+ fOutPtr->fValidData[tmpChannelCnt].fEnergy = (float)fAnalyzerPtr->GetEnergy() - baseline;
+ fOutPtr->fValidData[tmpChannelCnt].fTime = (float)fAnalyzerPtr->GetTiming();
+ fOutPtr->fValidData[tmpChannelCnt].fCrazyness = (int)crazyness;
- validCellPtr->fEnergy = (float)fAnalyzerPtr->GetEnergy() - baseline;
- validCellPtr->fTime = (float)fAnalyzerPtr->GetTiming();
- validCellPtr->fCrazyness = (int)crazyness;
- validCellPtr->fNSamples = nSamples;
- validCellPtr->fID = tmpChannelCnt;
- validCellPtr->fData = rawDataBufferPos;
const UInt_t *tmpData = fAltroDataPtr->GetData();
- if(fDoPushCellEnergies)
+ if(fDoPushRawData)
{
+ tmpSize += nSamples + 1;
+ *rawDataBufferPos = nSamples;
+ cout << "# samples: " << *rawDataBufferPos << endl;
for(int sample = 0; sample < nSamples; sample++)
{
- (validCellPtr->fData)[sample] = tmpData[sample] - (int)baseline;
+ rawDataBufferPos++;
+ *(rawDataBufferPos) = tmpData[sample] - (Int_t)baseline;
}
+ rawDataBufferPos++;
}
if(fDoSelectiveReadOut)
{
- if(validCellPtr->fEnergy > fSelectiveReadOutThresholds[x][z][gain])
+ if(validCellPtr->fEnergy > fSelectiveReadOutThresholds[fOutPtr->fValidData[tmpChannelCnt].fX][fOutPtr->fValidData[tmpChannelCnt].fZ][fOutPtr->fValidData[tmpChannelCnt].fGain])
{
fSelectedChannelsList[nSelected] = (AliHLTUInt16_t)(fAltroDataPtr->GetHadd());
nSelected++;
}
}
- UInt_t tmpSize = sizeof(Int_t)*(validCellPtr->fNSamples);
- mysize += tmpSize;
- rawDataBufferPos += tmpSize/sizeof(Int_t);
+ // UInt_t tmpSize = sizeof(Int_t)*(fOutPtr->fValidData[tmpChannelCnt].fNSamples);
+ // mysize += sizeof(Int_t)*(fOutPtr->fValidData[tmpChannelCnt].fNSamples);
+ //mysize += tmpSize;
+ //rawDataBufferPos += tmpSize/sizeof(Int_t);
+
+
tmpChannelCnt ++;
}
+
+ mysize += tmpSize*4;
+ // cout << "mysize: " << mysize << " - tmpSize: " <<
+
+ if(fDoPushRawData)
+ {
+ fOutPtr->fHasRawData = true;
+ }
+ else
+ {
+ fOutPtr->fHasRawData = false;
+ }
fOutPtr->fCnt = tmpChannelCnt;
fOutPtr->fSize = mysize;
+
+ AliHLTComponentBlockData bdCellEnergy;
+ FillBlockData( bdCellEnergy );
+ bdCellEnergy.fOffset = offset;
+ bdCellEnergy.fSize = mysize;
+ bdCellEnergy.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
+ bdCellEnergy.fSpecification = specification;
+ outputBlocks.push_back( bdCellEnergy );
- if(fDoPushCellEnergies)
- {
- AliHLTComponentBlockData bdCellEnergy;
- FillBlockData( bdCellEnergy );
- bdCellEnergy.fOffset = offset;
- bdCellEnergy.fSize = mysize;
- bdCellEnergy.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
- bdCellEnergy.fSpecification = specification;
- outputBlocks.push_back( bdCellEnergy );
-
- tSize += mysize;
- outBPtr += mysize;
- }
-
- //Making Digits
- if(fDoMakeDigits)
- {
- Int_t digitSize = 0;
- fDigitMakerPtr->SetDigitContainerStruct((AliHLTPHOSDigitContainerDataStruct*)outBPtr);
- digitCount = fDigitMakerPtr->MakeDigits(fOutPtr);
- offset = tSize;
- digitSize += sizeof(AliHLTPHOSDigitContainerDataStruct);
-
- AliHLTComponentBlockData bdDigits;
- FillBlockData(bdDigits);
- bdDigits.fOffset = offset;
- bdDigits.fSize = mysize;
- bdDigits.fDataType = AliHLTPHOSDefinitions::fgkDigitDataType;
- bdDigits.fSpecification = specification;
- outputBlocks.push_back( bdDigits );
-
- tSize += digitSize;
- outBPtr += digitSize;
- fDigitMakerPtr->Reset();
- }
+ tSize += mysize;
+ outBPtr += mysize;
//Pushing selected channel addresses
if(fDoSelectiveReadOut)
tSize += mysize;
outBPtr += mysize;
}
-
+
+
if( tSize > size )
{
Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
, tSize, size );
return EMSGSIZE;
}
-
+
}
fPhosEventCount++;
+
+
if(fPrintInfo == kTRUE)
{
+
if(fPhosEventCount%fPrintInfoFrequncy == 0)
{
Logging(kHLTLogBenchmark, __FILE__ , IntToChar( __LINE__ ) , "Analyzing event %lu", fPhosEventCount);
}
- }
+
+ }
return 0;
}//end DoEvent
int
AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
{
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ // fAnalyzerPtr->SetCorrectBaselineUsingFirstFiveSamples();
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
//See base class for documentation
fSendChannelData = kFALSE;
fPrintInfo = kFALSE;
int iResult=0;
TString argument="";
+ const int nSigmas = 3;
fMapperPtr = new AliHLTPHOSMapper();
if(fMapperPtr->GetIsInitializedMapping() == false)
return -4;
}
- iResult = ScanArguments(argc, argv);
-
- int nSigmas = 3;
-
- fDigitMakerPtr = new AliHLTPHOSDigitMaker();
-
- for(int i = 0; i < argc; i++)
+ char tmpbaselinfile[256];
+ if(fUtilitiesPtr->ScanSingleNameArgument(argc, argv, "-baselinefile", tmpbaselinfile) == true )
{
- if(!strcmp("-rmsfilepath", argv[i]))
- {
- fDigitMakerPtr->SetDigitThresholds(argv[i+1], nSigmas);
- SetSelectiveReadOutThresholds(argv[i+1], nSigmas);
- }
- if(!strcmp("-baselinefile", argv[i]))
- {
- SetBaselines(argv[i+1]);
- }
- if(!strcmp("-lowgainfactor", argv[i]))
- {
- fDigitMakerPtr->SetGlobalLowGainFactor(atof(argv[i+1]));
- }
- if(!strcmp("-highgainfactor", argv[i]))
- {
- fDigitMakerPtr->SetGlobalHighGainFactor(atof(argv[i+1]));
- }
- if(!strcmp("-selectivereadout", argv[i]))
- {
- fDoSelectiveReadOut = true;
- }
- if(!strcmp("-makedigits", argv[i]))
- {
- fDoMakeDigits = true;
- }
- if(!strcmp("-pushcellenergies", argv[i]))
- {
- fDoPushCellEnergies = true;
- }
- if(!strcmp("-checkdatasize", argv[i]))
- {
- fDoCheckDataSize = true;
- }
- }
-
- if(fIsSetEquippmentID == kFALSE)
- {
- Logging( kHLTLogFatal, __FILE__, "Missing argument",
- "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID <number>");
- iResult = -3;
+ SetBaselines(tmpbaselinfile);
}
- else
+
+ char tmpSelectiveThresholdfile[256];
+ if(fUtilitiesPtr->ScanSingleNameArgument(argc, argv, "-baselinefile", tmpSelectiveThresholdfile) == true )
{
- iResult = 0;
+ fDoSelectiveReadOut = true;
+ SetSelectiveReadOutThresholds(tmpSelectiveThresholdfile, nSigmas);
}
+
+ //fDoSelectiveReadOut = fUtilitiesPtr->ScanSingleNameArgument(argc, argv, "-selectivereadout");
+
+ fDoPushRawData = fUtilitiesPtr->ScanSingleArgument(argc, argv, "-pushrawdata");
+
+ fDoPushRawData = true; //CRAP
+
+ fDoCheckDataSize = fUtilitiesPtr->ScanSingleArgument(argc, argv, "-checkdatasize");
+
+ iResult = ScanArguments(argc, argv);
return iResult;
}
//comment
// for(unsigned int mod = 0; mod < N_MODULES; mod ++)
//{
+ /*
for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
{
}
}
}
-
+ */
ResetDataPtr(0, ALTRO_MAX_SAMPLES);
} // end Reset
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff