Float_t
-AliHLTPHOSBaselineAnalyzer::CalculateChannelBaseline(AliHLTPHOSValidCellDataStruct *cellData, Int_t xOff, Int_t zOff)
+AliHLTPHOSBaselineAnalyzer::CalculateChannelBaseline(AliHLTPHOSValidCellDataStruct *cellData, Int_t* rawDataPtr, Int_t xOff, Int_t zOff)
{
//see headerfile for documentation
Int_t crazyness = 0;
Int_t total = 0;
- Int_t *data = cellData->fData;
+ Int_t *data = rawDataPtr;
for(Int_t i = fSampleStart; i < fNSamples; i++)
{
/*
* @param zOff is the offset in the z position given by the RCU number
* @return the baseline
*/
- Float_t CalculateChannelBaseline(AliHLTPHOSValidCellDataStruct *cellData, Int_t xOff, Int_t zOff);
+ Float_t CalculateChannelBaseline(AliHLTPHOSValidCellDataStruct *cellData, Int_t* rawDataPtr, Int_t xOff, Int_t zOff);
/**
* Calculate the accumulated baseline of a channel
{
fHighGainFactors[x][z] = 0.005;
fLowGainFactors[x][z] = 0.08;
+ fDigitThresholds[x][z][HIGH_GAIN] = 2;
+ fDigitThresholds[x][z][LOW_GAIN] = 2;
+ fBadChannelMask[x][z][HIGH_GAIN] = 1;
+ fBadChannelMask[x][z][LOW_GAIN] = 1;
}
}
+
+ for(int x = 0; x < N_XCOLUMNS_RCU; x++)
+ {
+ for(int z = 0; z < N_ZROWS_RCU; z++)
+ {
+ for(int gain = 0; gain < N_GAINS; gain++)
+ {
+ fEnergyArray[x][z][gain] = 0;
+ }
+ }
+ }
+
}
-
+
AliHLTPHOSDigitMaker::~AliHLTPHOSDigitMaker()
{
//See header file for documentation
Int_t j = 0;
Int_t xMod = -1;
Int_t zMod = -1;
- Float_t amplitude = 0;
-
+
+ AliHLTPHOSValidCellDataStruct* currentchannel = 0;
+
+ Reset();
+
+ fShmPtr->SetMemory(rcuData);
+ currentchannel = fShmPtr->NextChannel();
+
+ while(currentchannel != 0)
+ {
+ fEnergyArray[currentchannel->fX][currentchannel->fZ][currentchannel->fGain] = currentchannel->fEnergy;
+ currentchannel = fShmPtr->NextChannel();
+ }
+
for(int x = 0; x < N_XCOLUMNS_RCU; x++)
{
- for(int z = 0; z < N_ZROWS_RCU; z++)
+ for(int z = 0; z < N_ZROWS_RCU; z++)
{
- fCellDataPtr = &(rcuData->fValidData[x][z][HIGH_GAIN]);
xMod = x + rcuData->fRcuX * N_XCOLUMNS_RCU;
zMod = z + rcuData->fRcuZ * N_ZROWS_RCU;
- amplitude = fCellDataPtr->fEnergy;
- if(amplitude > fDigitThresholds[xMod][zMod][HIGH_GAIN] && amplitude < MAX_BIN_VALUE)
+
+ if(fEnergyArray[x][z][HIGH_GAIN] > fDigitThresholds[xMod][zMod][HIGH_GAIN] && fEnergyArray[x][z][HIGH_GAIN] < MAX_BIN_VALUE && fBadChannelMask[xMod][zMod][HIGH_GAIN])
{
fDigitStructPtr = &(fDigitContainerStructPtr->fDigitDataStruct[j+fDigitCount]);
fDigitStructPtr->fX = xMod;
fDigitStructPtr->fZ = zMod;
- fDigitStructPtr->fAmplitude = amplitude;
- fDigitStructPtr->fEnergy = amplitude * fHighGainFactors[xMod][zMod];
+ fDigitStructPtr->fAmplitude = fEnergyArray[x][z][HIGH_GAIN];
+ fDigitStructPtr->fEnergy = fEnergyArray[x][z][HIGH_GAIN] * fHighGainFactors[xMod][zMod];
//TODO: fix time
fDigitStructPtr->fTime = fCellDataPtr->fTime * 0.0000001;
fDigitStructPtr->fCrazyness = fCellDataPtr->fCrazyness;
fDigitStructPtr->fModule = rcuData->fModuleID;
j++;
}
- else if(amplitude >= MAX_BIN_VALUE)
+ else if(fEnergyArray[x][z][LOW_GAIN] >= MAX_BIN_VALUE && fBadChannelMask[xMod][zMod][LOW_GAIN])
{
- fCellDataPtr = & (rcuData->fValidData[x][z][LOW_GAIN]);
- amplitude = fCellDataPtr->fEnergy;
- if(amplitude > fDigitThresholds[xMod][zMod][LOW_GAIN])
+ if(fEnergyArray[x][z][LOW_GAIN] > fDigitThresholds[xMod][zMod][LOW_GAIN])
{
fDigitStructPtr = &(fDigitContainerStructPtr->fDigitDataStruct[j+fDigitCount]);
fDigitStructPtr->fX = xMod;
fDigitStructPtr->fZ = zMod;
- fDigitStructPtr->fAmplitude = amplitude;
- fDigitStructPtr->fEnergy = amplitude * fLowGainFactors[xMod][zMod];
+ fDigitStructPtr->fAmplitude = fEnergyArray[x][z][LOW_GAIN];
+ fDigitStructPtr->fEnergy = fEnergyArray[x][z][LOW_GAIN] * fLowGainFactors[xMod][zMod];
//TODO: fix time
fDigitStructPtr->fTime = fCellDataPtr->fTime * 0.0000001;;
fDigitStructPtr->fCrazyness = fCellDataPtr->fCrazyness;
AliHLTPHOSDigitMaker::Reset()
{
//See header file for documentation
+
+ for(int x = 0; x < N_XCOLUMNS_RCU; x++)
+ {
+ for(int z = 0; z < N_ZROWS_RCU; z++)
+ {
+ for(int gain = 0; gain < N_GAINS; gain++)
+ {
+ fEnergyArray[x][z][gain] = 0;
+ }
+ }
+ }
+
fDigitCount = 0;
}
}
}
}
+
+
+void
+AliHLTPHOSDigitMaker::SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut)
+{
+ for(int x = 0; x < N_XCOLUMNS_MOD; x++)
+ {
+ for(int z = 0; z < N_ZROWS_MOD; z++)
+ {
+ if(badChannelHGHist->GetBinContent(x, z) < qCut && badChannelHGHist->GetBinContent(x, z) > 0)
+ {
+ fBadChannelMask[x][z][HIGH_GAIN] = 1;
+ }
+ else
+ {
+ fBadChannelMask[x][z][HIGH_GAIN] = 0;
+ }
+ if(badChannelLGHist->GetBinContent(x, z) < qCut && badChannelLGHist->GetBinContent(x, z) > 0)
+ {
+ fBadChannelMask[x][z][LOW_GAIN] = 0;
+ }
+ else
+ {
+ fBadChannelMask[x][z][LOW_GAIN] = 0;
+ }
+ }
+ }
+}
class TClonesArray;
class TTree;
+class TH2F;
class AliHLTPHOSValidCellDataStruct;
class AliHLTPHOSRcuCellEnergyDataStruct;
class AliHLTPHOSDigitContainerDataStruct;
AliHLTPHOSDigitMaker(const AliHLTPHOSDigitMaker &) :
AliHLTPHOSBase(),
fCellDataPtr(0),
+ fShmPtr(0),
fDigitContainerStructPtr(0),
fDigitArrayPtr(0),
fDigitStructPtr(0),
*/
Int_t MakeDigits(AliHLTPHOSRcuCellEnergyDataStruct* rcuCellEnergies);
+ /**
+ * Set the mask for dead channels
+ * @param badChannelHGHist is a pointer to a high gain bad channel histogram
+ * @param badChannelLGHist is a pointer to a low gain bad channel histogram
+ * @param qCut is the cut
+ */
+ void SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut);
+
/** Reset the digit maker */
void Reset();
/** Pointer to valid cell list */
AliHLTPHOSValidCellDataStruct *fCellDataPtr; //! transient
+ /** Pointer to shared memory interface */
+ AliHLTPHOSSharedMemoryInterface* fShmPtr; //! transient
+
/** Pointer to the digit container */
AliHLTPHOSDigitContainerDataStruct *fDigitContainerStructPtr; //! transient
/** Digit count */
Int_t fDigitCount; //COMMENT
+ /** Array containing the energies of all RCU channels */
+ Float_t fEnergyArray[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; //COMMENT
+
/** High gain energy conversion factors */
Float_t fHighGainFactors[N_XCOLUMNS_MOD][N_ZROWS_MOD]; //COMMENT
/** Threshold for making digit ( zero suppression threshold) */
Float_t fDigitThresholds[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS]; //COMMENT
+ /** Bad channel mask */
+ Float_t fBadChannelMask[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS]; //COMMENT
+
ClassDef(AliHLTPHOSDigitMaker, 1);
};
// fCnt ++;
- cout << " AliHLTPHOSModuleCalibrationProcessorComponent::ProcessCalibratio processing event" << fCnt << endl;
-
fCnt ++;
//See header file for documentation
const AliHLTComponentEventData eDta = evtData;
AliHLTComponentTriggerData tDta = trigData;
+
+ AliHLTPHOSValidCellDataStruct *currentChannel =0;
+
UInt_t specification = 0;
const AliHLTComponentBlockData* iter = 0;
iter = GetFirstInputBlock( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC);
xOffset = cellDataPtr->fRcuX*N_XCOLUMNS_RCU;
zOffset = cellDataPtr->fRcuZ*N_ZROWS_RCU;
-
- for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+
+ fShmPtr->SetMemory(cellDataPtr);
+ currentChannel = fShmPtr->NextChannel();
+
+ while(currentChannel != 0)
{
- for(Int_t z = 0; z < N_ZROWS_RCU; z++)
- {
- for(Int_t gain = 0; gain < N_GAINS; gain++)
- {
- energyArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fEnergy;
- timeArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fTime;
- }
- }
+ Int_t tmpZ = currentChannel->fZ;
+ Int_t tmpX = currentChannel->fX;
+ Int_t tmpGain = currentChannel->fGain;
+
+ energyArray[tmpX+xOffset][tmpZ+zOffset][tmpGain] = currentChannel->fEnergy;
+ timeArray[tmpX+xOffset][tmpZ+zOffset][tmpGain] = currentChannel->fTime;
}
+// for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+// {
+// for(Int_t z = 0; z < N_ZROWS_RCU; z++)
+// {
+// for(Int_t gain = 0; gain < N_GAINS; gain++)
+// {
+// energyArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fEnergy;
+// timeArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fTime;
+// }
+// }
+// }
iter = GetNextInputBlock();
}
#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),
//fRawMemoryReader(0), fPHOSRawStream(0)
{
//comment
- // fMapperPtr = new AliHLTPHOSMapper();
+ fMapperPtr = new AliHLTPHOSMapper();
fAltroDataPtr = new AliAltroData();
fAltroBunchPtr = new AliAltroBunch();
fDecoderPtr = new AliAltroDecoder();
// 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();
}
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;
UInt_t nSelected = 0;
UInt_t specification = 0;
- cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent analyzing event " << fPhosEventCount << endl;
-
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 )
specification = specification|iter->fSpecification;
fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
- // fDecoderPtr->SetMemory(reinterpret_cast<char*>( 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);
-
+
while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
{
+
nSamples = fAltroDataPtr->GetDataSize() - 2;
if(fDoCheckDataSize)
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;
-
- validCellPtr->fEnergy = (float)fAnalyzerPtr->GetEnergy() - baseline;
- validCellPtr->fTime = (float)fAnalyzerPtr->GetTiming();
- validCellPtr->fCrazyness = (int)crazyness;
- validCellPtr->fNSamples = nSamples;
- validCellPtr->fID = tmpChannelCnt;
-
- // validCellPtr->fData = rawDataBufferPos;
- // validCellPtr->fDataOffset = rawDataBufferPos;
-
+ fOutPtr->fValidData[tmpChannelCnt].fEnergy = (float)fAnalyzerPtr->GetEnergy() - baseline;
+ fOutPtr->fValidData[tmpChannelCnt].fTime = (float)fAnalyzerPtr->GetTiming();
+ fOutPtr->fValidData[tmpChannelCnt].fCrazyness = (int)crazyness;
+
const UInt_t *tmpData = fAltroDataPtr->GetData();
- // const int *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;
- //(validCellPtr->fDataOffset)[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 ++;
}
-
- fOutPtr->fCnt = tmpChannelCnt;
- fOutPtr->fSize = mysize;
-
- if(fDoPushCellEnergies)
+
+ mysize += tmpSize*4;
+ // cout << "mysize: " << mysize << " - tmpSize: " <<
+
+ if(fDoPushRawData)
{
- // cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent, pushing cell energies" << endl;
- 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;
+ fOutPtr->fHasRawData = true;
}
else
{
- cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent, WARNING we are not pushing cell energies" << endl;
+ 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 );
- //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)
Logging(kHLTLogBenchmark, __FILE__ , IntToChar( __LINE__ ) , "Analyzing event %lu", fPhosEventCount);
}
-
}
return 0;
fPrintInfo = kFALSE;
int iResult=0;
TString argument="";
+ const int nSigmas = 3;
fMapperPtr = new AliHLTPHOSMapper();
if(fMapperPtr->GetIsInitializedMapping() == false)
return -4;
}
- const int nSigmas = 3;
-
- fDigitMakerPtr = new AliHLTPHOSDigitMaker();
-
- char tmprmsfile[256];
- if (fUtilitiesPtr->ScanSingleNameArgument(argc, argv, "-rmsfilepath", tmprmsfile) == true)
- {
- fDigitMakerPtr->SetDigitThresholds( tmprmsfile, nSigmas);
- SetSelectiveReadOutThresholds( tmprmsfile, nSigmas);
- }
-
char tmpbaselinfile[256];
if(fUtilitiesPtr->ScanSingleNameArgument(argc, argv, "-baselinefile", tmpbaselinfile) == true )
{
SetBaselines(tmpbaselinfile);
}
-
- float tmpLGFactor = 0;
- if(fUtilitiesPtr->ScanSingleFloatArgument(argc, argv, "-lowgainfactor", &tmpLGFactor) == true)
- {
- fDigitMakerPtr->SetGlobalLowGainFactor(tmpLGFactor);
- }
-
- float tmpHGFactor = 0;
- if(fUtilitiesPtr->ScanSingleFloatArgument(argc, argv, "-lowgainfactor", &tmpHGFactor) == true )
+ char tmpSelectiveThresholdfile[256];
+ if(fUtilitiesPtr->ScanSingleNameArgument(argc, argv, "-baselinefile", tmpSelectiveThresholdfile) == true )
{
- fDigitMakerPtr->SetGlobalHighGainFactor(tmpHGFactor);
- }
+ fDoSelectiveReadOut = true;
+ SetSelectiveReadOutThresholds(tmpSelectiveThresholdfile, nSigmas);
+ }
+
- fDoSelectiveReadOut = fUtilitiesPtr->ScanSingleArgument(argc, argv, "-selectivereadout");
- fDoMakeDigits = fUtilitiesPtr->ScanSingleArgument(argc, argv, "-makedigits");
+ //fDoSelectiveReadOut = fUtilitiesPtr->ScanSingleNameArgument(argc, argv, "-selectivereadout");
- // CRAP PTH
- // fDoPushCellEnergies = fUtilitiesPtr->ScanSingleArgument(argc, argv, "-pushcellenergies");
- fDoPushCellEnergies = true;
+ fDoPushRawData = fUtilitiesPtr->ScanSingleArgument(argc, argv, "-pushrawdata");
+
+ fDoPushRawData = true; //CRAP
fDoCheckDataSize = fUtilitiesPtr->ScanSingleArgument(argc, argv, "-checkdatasize");
//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
fShmPtr->SetMemory(cellDataPtr);
currentChannel = fShmPtr->NextChannel();
+ Int_t* tmpRawPtr = 0;
+
int tmp =0;
while(currentChannel != 0)
{
int tmpZ = currentChannel->fZ;
int tmpX = currentChannel->fX;
int tmpGain = currentChannel->fGain;
- int tmpSamples = currentChannel->fNSamples;
+ int tmpSamples = 0;
+ tmpRawPtr = fShmPtr->GetRawData(tmpSamples);
if( (tmpZ > N_ZROWS_RCU) || (tmpX > N_XCOLUMNS_RCU) || (tmpGain > N_GAINS))
// cout << " z = " << currentChannel->fZ << " x = " << currentChannel->fX << " gain = " << currentChannel->fGain << " samples =" << currentChannel->fNSamples <<endl;
tmp ++;
- fPatternTestPtr->AddPattern(currentChannel->fData, currentChannel->fZ, currentChannel->fX, currentChannel->fGain, currentChannel->fNSamples, fNPresamples);
- int ret = fPatternTestPtr->ValidateAltroPattern(currentChannel->fData, currentChannel->fNSamples);
+ fPatternTestPtr->AddPattern(tmpRawPtr, currentChannel->fZ, currentChannel->fX, currentChannel->fGain, tmpSamples, fNPresamples);
+ int ret = fPatternTestPtr->ValidateAltroPattern(tmpRawPtr, tmpSamples);
if(ret >= 0)
{
- fNTotalSamples += currentChannel->fNSamples;
+ fNTotalSamples += tmpSamples;
fNTotalPatterns ++;
if(ret > 0)
fShmPtr->SetMemory(cellDataPtr);
currentChannel = fShmPtr->NextChannel();
+ Int_t* tmpDataPtr = 0;
+ Int_t nSamples = 0;
+
while(currentChannel != 0)
{
+ tmpDataPtr = fShmPtr->GetRawData(nSamples);
fRcuCalibProcessorPtr->FillEnergy(currentChannel->fX, currentChannel->fZ, currentChannel->fGain, currentChannel->fEnergy);
- fRcuCalibProcessorPtr->FillLiveChannels(currentChannel->fData, totalSamples, currentChannel->fX, currentChannel->fZ,currentChannel->fGain);
+ fRcuCalibProcessorPtr->FillLiveChannels(tmpDataPtr, totalSamples, currentChannel->fX, currentChannel->fZ,currentChannel->fGain);
currentChannel = fShmPtr->NextChannel();
}
iter = GetFirstInputBlock( AliHLTPHOSDefinitions::fgkCellEnergyDataType | kAliHLTDataOriginPHOS);
AliHLTPHOSRcuCellEnergyDataStruct* cellDataPtr = 0;
+ AliHLTPHOSValidCellDataStruct *currentChannel =0;
Int_t xOffset = 0;
Int_t zOffset = 0;
Int_t module = -1;
xOffset = cellDataPtr->fRcuX*N_XCOLUMNS_RCU;
zOffset = cellDataPtr->fRcuZ*N_ZROWS_RCU;
- for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+ while(currentChannel != 0)
{
- for(Int_t z = 0; z < N_ZROWS_RCU; z++)
- {
- for(Int_t gain = 0; gain < N_GAINS; gain++)
- {
- energyArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fEnergy;
- timeArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fTime;
- }
- }
+ Int_t tmpZ = currentChannel->fZ;
+ Int_t tmpX = currentChannel->fX;
+ Int_t tmpGain = currentChannel->fGain;
+
+ energyArray[tmpX+xOffset][tmpZ+zOffset][tmpGain] = currentChannel->fEnergy;
+ timeArray[tmpX+xOffset][tmpZ+zOffset][tmpGain] = currentChannel->fTime;
}
+
+// for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+// {
+// for(Int_t z = 0; z < N_ZROWS_RCU; z++)
+// {
+// for(Int_t gain = 0; gain < N_GAINS; gain++)
+// {
+// energyArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fEnergy;
+// timeArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fTime;
+// }
+// }
+// }
iter = GetNextInputBlock();
}
cellDataPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)( iter->fPtr);
fShmPtr->SetMemory(cellDataPtr);
currentChannel = fShmPtr->NextChannel();
-
- while(currentChannel != 0)
+
+ Int_t* tmpDataPtr = 0;
+ Int_t nSamples = 0;
+ if(cellDataPtr->fHasRawData == true)
+ {
+ while(currentChannel != 0)
+ {
+ tmpDataPtr = fShmPtr->GetRawData(nSamples);
+ fRcuHistoProducerPtr->FillEnergy(currentChannel->fX, currentChannel->fZ, currentChannel->fGain, currentChannel->fEnergy);
+ fRcuHistoProducerPtr->FillLiveChannels(tmpDataPtr, nSamples, currentChannel->fX, currentChannel->fZ,currentChannel->fGain);
+ currentChannel = fShmPtr->NextChannel();
+ }
+ }
+ else
{
- fRcuHistoProducerPtr->FillEnergy(currentChannel->fX, currentChannel->fZ, currentChannel->fGain, currentChannel->fEnergy);
- fRcuHistoProducerPtr->FillLiveChannels(currentChannel->fData, fNTotalSamples, currentChannel->fX, currentChannel->fZ,currentChannel->fGain);
- currentChannel = fShmPtr->NextChannel();
+
+ Logging(kHLTLogFatal, __FILE__ , IntToChar( __LINE__ ) , "AliHLTPHOSRcuHistogramProducerComponent::We are not pushing raw data, aborting");
+ return -1;
}
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff