+// $Id$
/**************************************************************************
* This file is property of and copyright by the ALICE HLT Project *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-#include "AliHLTCaloRawAnalyzer.h"
+
+#include "AliCaloRawAnalyzer.h"
+#include "AliCaloBunchInfo.h"
+#include "AliCaloFitResults.h"
#include "AliHLTCaloRawAnalyzerComponentv3.h"
#include "AliHLTCaloChannelDataHeaderStruct.h"
#include "AliHLTCaloChannelDataStruct.h"
#include "AliHLTCaloMapper.h"
#include "AliHLTCaloSanityInspector.h"
-#include "AliAltroRawStreamV3.h"
#include "AliRawReaderMemory.h"
-#include "AliAltroRawStreamV3.h"
#include "AliCaloRawStreamV3.h"
+#include "AliHLTCaloConstantsHandler.h"
+#include "AliHLTCaloChannelRawDataStruct.h"
+#include "AliLog.h"
+#include "TStopwatch.h"
-AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3():
- AliHLTProcessor(),
- fAnalyzerPtr(0),
- fMapperPtr(0),
- fkDoPushRawData(true),
- fPhosEventCount(0),
- fSanityInspectorPtr(0),
- fRawReaderMemoryPtr(0),
- fAltroRawStreamPtr(0),
- fAlgorithm(0),
- fOffset(0),
- fBunchSizeCut(0),
- fMinPeakPosition(0),
- fMaxPeakPosition(100),
- fRawDataWriter(0)
-{
- //comment
+#include "AliCaloRawAnalyzerFactory.h"
- // fMapperPtr = new AliHLTCaloMapper();
+//#include "AliCaloConstants.h"
- fRawReaderMemoryPtr = new AliRawReaderMemory();
+//#include "AliCaloRawAnalyzer.h"
- fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawReaderMemoryPtr);
+//using namespace Algo;
- fSanityInspectorPtr = new AliHLTCaloSanityInspector();
-
- if( fkDoPushRawData == true )
- {
- fRawDataWriter = new RawDataWriter();
- }
+#include <vector>
+using namespace std;
+
+ClassImp(AliHLTCaloRawAnalyzerComponentv3);
+
+
+
+AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3(TString det, fitAlgorithm algo ):AliHLTCaloProcessor(),
+ AliHLTCaloConstantsHandler(det),
+ fAnalyzerPtr(0),
+ fMapperPtr(0),
+ fCurrentSpec(-1),
+ fDebug(false),
+ fSanityInspectorPtr(0),
+ fRawReaderMemoryPtr(0),
+ fAltroRawStreamPtr(0),
+ fDetector(det),
+ fAlgorithm(algo),
+ fOffset(0),
+ fBunchSizeCut(0),
+ fMinPeakPosition(0),
+ fMaxPeakPosition(100),
+ fDoPushBadRawData(false),
+ fDoPushRawData(false),
+ fRawDataWriter(0)
+
+{
+ //Constructor
+
}
AliHLTCaloRawAnalyzerComponentv3::~AliHLTCaloRawAnalyzerComponentv3()
{
- //comment
- Deinit();
+ //destructor
}
-
-int
-AliHLTCaloRawAnalyzerComponentv3::Deinit()
-{
- //comment
- if(fAnalyzerPtr)
- {
- delete fAnalyzerPtr;
- fAnalyzerPtr = 0;
- }
- if(fMapperPtr)
+int
+AliHLTCaloRawAnalyzerComponentv3::DoInit( int argc, const char** argv )
+{
+ //See base class for documentation
+ int iResult=0;
+
+ for(int i = 0; i < argc; i++)
{
- delete fMapperPtr;
- fMapperPtr = 0;
+ if(!strcmp("-offset", argv[i]))
+ {
+ fOffset = atoi(argv[i+1]);
+ }
+ if(!strcmp("-bunchsizecut", argv[i]))
+ {
+ fBunchSizeCut = atoi(argv[i+1]);
+ }
+ if(!strcmp("-minpeakposition", argv[i]))
+ {
+ fMinPeakPosition = atoi(argv[i+1]);
+ }
+ if(!strcmp("-maxpeakposition", argv[i]))
+ {
+ fMaxPeakPosition = atoi(argv[i+1]);
+ }
+ if(!strcmp("-pushrawdata", argv[i]))
+ {
+ fDoPushRawData = true;
+ }
+ if(!strcmp("-pushbaddata", argv[i]))
+ {
+ fDoPushBadRawData = true;
+ }
+ if(fDoPushBadRawData && fDoPushRawData)
+ {
+ HLTWarning("fDoPushBadRawData and fDoPushRawData in conflict, using fDoPushRawData");
+ fDoPushBadRawData = false;
+ }
+ if(!strcmp("-suppressalilogwarnings", argv[i]))
+ {
+ AliLog::SetGlobalLogLevel(AliLog::kError); //PHOS sometimes produces bad data -> Fill up the HLT logs...
+ }
}
- if(fRawReaderMemoryPtr)
+
+ fAnalyzerPtr = AliCaloRawAnalyzerFactory::CreateAnalyzer(fAlgorithm);
+ fAnalyzerPtr->SetIsZeroSuppressed(true);
+ fSanityInspectorPtr = new AliHLTCaloSanityInspector();
+
+ if( fDoPushRawData == true )
{
- delete fRawReaderMemoryPtr;
- fRawReaderMemoryPtr = 0;
+ fRawDataWriter = new RawDataWriter(fCaloConstants);
}
+ fRawReaderMemoryPtr = new AliRawReaderMemory();
+ fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, fDetector);
+
+ return iResult;
+}
+
+
+int
+AliHLTCaloRawAnalyzerComponentv3::DoDeinit()
+{
+ //comment
if(fAltroRawStreamPtr)
{
delete fAltroRawStreamPtr;
fAltroRawStreamPtr = 0;
}
+
+ if (fRawReaderMemoryPtr) delete fRawReaderMemoryPtr;
+ fRawReaderMemoryPtr=NULL;
+ if (fAltroRawStreamPtr) delete fAltroRawStreamPtr;
+ fAltroRawStreamPtr=NULL;
+ if (fRawDataWriter) delete fRawDataWriter;
+ fRawDataWriter=NULL;
+ if (fSanityInspectorPtr) delete fSanityInspectorPtr;
+ fSanityInspectorPtr=NULL;
+
return 0;
}
-/*
-const char*
-AliHLTCaloRawAnalyzerComponentv3::GetComponentID()
+
+
+void
+AliHLTCaloRawAnalyzerComponentv3::PrintDebugInfo()
{
//comment
- return "CaloRawAnalyzerv3";
+ static TStopwatch watch; //CRAP PTH
+ static double wlast = -1;
+ static double wcurrent = 0;
+
+ if( true == fDebug )
+ {
+ if( fCaloEventCount %1000 == 0 )
+ {
+ cout << __FILE__ << __LINE__ << " : Processing event " << fCaloEventCount << endl;
+ wlast = wcurrent;
+ wcurrent = watch.RealTime();
+ cout << __FILE__ << __LINE__ << "The event rate is " <<
+ 1000/( wcurrent - wlast ) << " Hz" << endl; watch.Start(kFALSE);
+ }
+ }
}
-*/
- /*
void
-AliHLTCaloRawAnalyzerComponentv3::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
+AliHLTCaloRawAnalyzerComponentv3::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
{
//comment
- list.clear();
- list.push_back( AliHLTCaloDefinitions::fgkDDLPackedRawDataType | kAliHLTDataOriginPHOS);
+ constBase = sizeof(AliHLTCaloChannelDataHeaderStruct);
+ inputMultiplier = 1.5;
}
- */
-AliHLTComponentDataType
-AliHLTCaloRawAnalyzerComponentv3::GetOutputDataType()
-{
- //comment
- return AliHLTCaloDefinitions::fgkChannelDataType;
-}
-void
-AliHLTCaloRawAnalyzerComponentv3::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
+bool
+AliHLTCaloRawAnalyzerComponentv3::CheckInputDataType(const AliHLTComponentDataType &datatype)
{
//comment
- constBase = sizeof(AliHLTCaloChannelDataHeaderStruct);
- inputMultiplier = 0.5;
+ vector <AliHLTComponentDataType> validTypes;
+ GetInputDataTypes(validTypes);
+
+ for(UInt_t i=0; i < validTypes.size(); i++ )
+ {
+ if ( datatype == validTypes.at(i) )
+ {
+ return true;
+ }
+ }
+
+ HLTDebug("Invalid Datatype");
+ return false;
}
+
int
-AliHLTCaloRawAnalyzerComponentv3::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& /*trigData*/,
- AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
+AliHLTCaloRawAnalyzerComponentv3::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
+ AliHLTComponentTriggerData& /*trigData*/,
+ AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
- Int_t blockSize = 0;
+ //comment
+ if(!IsDataEvent())
+ {
+ size = 0;
+ return 0;
+ }
+ if( true == fDebug )
+ { PrintDebugInfo();
+ };
+
+ Int_t blockSize = -1;
UInt_t totSize = 0;
const AliHLTComponentBlockData* iter = NULL;
unsigned long ndx;
- // cout << __FILE__ << ":" << __LINE__ << "TP0" << endl;
+
for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
{
- // cout << __FILE__ << ":" << __LINE__ << "TP1" << endl;
iter = blocks+ndx;
- if( CheckInputDataType( iter->fDataType ) == false )
+ if( ! CheckInputDataType(iter->fDataType) )
{
- // cout << __FILE__ << ":" << __LINE__ << ": wrong !! datatype" << endl;
- // cout << "The datatype recieved was" << endl;
- // cout << "the datatype is " << iter->fDataType.fID << ":" << iter->fDataType.fOrigin << endl;
continue;
}
- else
+
+ if(iter->fSpecification != fCurrentSpec)
{
- // cout << __FILE__ << ":" << __LINE__ << ":" << "data is of type fgkDDLPackedRawDataType, continue processing " << endl;
- // cout << "the datatype is " << iter->fDataType.fID << ":" << iter->fDataType.fOrigin << endl;
- // cout << __FILE__ << ":" << __LINE__ << "T10" << endl;
- InitMapping( iter->fSpecification);
- // cout << __FILE__ << ":" << __LINE__ << "TP2" << endl;
- blockSize = DoIt(iter, outputPtr, size, totSize); // Processing the block
- if(blockSize == -1) // If the processing returns -1 we are out of buffer and return an error msg.
- {
- return -ENOBUFS;
- }
-
- totSize += blockSize; //Keeping track of the used size
- // HLTDebug("Output data size: %d - Input data size: %d", totSize, iter->fSize);
- //Filling the block data
- AliHLTComponentBlockData bdChannelData;
- FillBlockData( bdChannelData );
- bdChannelData.fOffset = 0; //FIXME
- bdChannelData.fSize = blockSize;
-
- // bdChannelData.fDataType = AliHLTPHOSDefinitions::fgkChannelDataType;
- bdChannelData.fDataType = AliHLTCaloDefinitions::fgkChannelDataType;
-
- bdChannelData.fSpecification = iter->fSpecification;
- outputBlocks.push_back(bdChannelData);
- outputPtr += blockSize; //Updating position of the output buffer
+ fCurrentSpec = iter->fSpecification;
+ InitMapping(iter->fSpecification);
}
-
- fPhosEventCount++;
- size = totSize; //telling the framework how much buffer space we have used.
+
+ blockSize = DoIt(iter, outputPtr, size, totSize); // Processing the block
+ totSize += blockSize; //Keeping track of the used size
+ AliHLTComponentBlockData bdChannelData;
+ FillBlockData( bdChannelData );
+ bdChannelData.fOffset = 0; //FIXME
+ bdChannelData.fSize = blockSize;
+ bdChannelData.fDataType = GetOutputDataType();
+ bdChannelData.fSpecification = iter->fSpecification;
+ outputBlocks.push_back(bdChannelData);
+ outputPtr += blockSize; //Updating position of the output buffer
}
+
+ fCaloEventCount++;
+ size = totSize; //telling the framework how much buffer space we have used.
+
return 0;
-
+
}//end DoEvent
Int_t
AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, AliHLTUInt8_t* outputPtr, const AliHLTUInt32_t size, UInt_t& totSize)
{
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T0" << endl;
-
- //comment
+ //comment
int tmpsize= 0;
Int_t crazyness = 0;
Int_t nSamples = 0;
Short_t channelCount = 0;
- // Firs we want to write a header to the output
AliHLTCaloChannelDataHeaderStruct *channelDataHeaderPtr = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*>(outputPtr);
AliHLTCaloChannelDataStruct *channelDataPtr = reinterpret_cast<AliHLTCaloChannelDataStruct*>(outputPtr+sizeof(AliHLTCaloChannelDataHeaderStruct));
- //Adding to the total size of data written
totSize += sizeof( AliHLTCaloChannelDataHeaderStruct );
fRawReaderMemoryPtr->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), static_cast<ULong_t>( iter->fSize ) );
- fRawReaderMemoryPtr->SetEquipmentID( fMapperPtr->GetDDLFromSpec( iter->fSpecification) + 4608 );
+ fRawReaderMemoryPtr->SetEquipmentID( fMapperPtr->GetDDLFromSpec( iter->fSpecification) + fCaloConstants->GetDDLOFFSET() );
fRawReaderMemoryPtr->Reset();
fRawReaderMemoryPtr->NextEvent();
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T1" << endl;
- if( fkDoPushRawData == true)
+
+ if( fDoPushRawData == true)
{
- fRawDataWriter->NewEvent( );
+ fRawDataWriter->NewEvent( );
}
- if(fAltroRawStreamPtr != NULL)
+
+ if(fAltroRawStreamPtr->NextDDL())
{
- delete fAltroRawStreamPtr;
- fAltroRawStreamPtr=NULL;
- }
-
-
- // fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, TString("PHOS"));
-
- fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, TString("EMCAL"));
- // while( fAltroRawStreamPtr->NextDDL() )
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T2" << endl;
- fAltroRawStreamPtr->NextDDL();
- {
- int cnt = 0;
- while( fAltroRawStreamPtr->NextChannel() )
- {
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T3" << endl;
- if( fAltroRawStreamPtr->GetHWAddress() < 128 || ( fAltroRawStreamPtr->GetHWAddress() ^ 0x800) < 128 )
- {
- continue;
- }
- else
- {
- ++ cnt;
- UShort_t* firstBunchPtr = 0;
-
- // UShort_t chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress());
- UInt_t chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress());
-
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T4" << endl;
+ int cnt = 0;
+ fOffset = 0;
+ while( fAltroRawStreamPtr->NextChannel() )
+ {
+ if( fAltroRawStreamPtr->GetHWAddress() < 128 || ( fAltroRawStreamPtr->GetHWAddress() ^ 0x800) < 128 )
+ {
+ continue;
+ }
+ else
+ {
+ ++ cnt;
+ //UShort_t* firstBunchPtr = 0;
+ int chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress());
+ //patch to skip LG in EMC
+ if(fDetector.CompareTo("EMCAL") == 0 && (int)((chId >> 12)&0x1) == 0) continue;
+ if( fDoPushRawData == true)
+ {
+ fRawDataWriter->SetChannelId( chId );
+ }
- if( fkDoPushRawData == true)
- {
- fRawDataWriter->SetChannelId( chId );
- }
- while( fAltroRawStreamPtr->NextBunch() == true )
- {
- nSamples = fAltroRawStreamPtr->GetBunchLength();
-
- if( fkDoPushRawData == true)
- {
- // fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(), nSamples, fAltroRawStreamPtr->GetStartTimeBin() );
- fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(), nSamples, fAltroRawStreamPtr->GetEndTimeBin() );
- }
- firstBunchPtr = const_cast< UShort_t* >( fAltroRawStreamPtr->GetSignals() );
- }
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T5" << endl;
- totSize += sizeof( AliHLTCaloChannelDataStruct );
- if(totSize > size)
- {
- HLTError("Buffer overflow: Trying to write data of size: %d bytes. Output buffer available: %d bytes.", totSize, size);
-
- return -1;
- }
-
+ vector <AliCaloBunchInfo> bvctr;
+ while( fAltroRawStreamPtr->NextBunch() == true )
+ {
+ bvctr.push_back( AliCaloBunchInfo( fAltroRawStreamPtr->GetStartTimeBin(),
+ fAltroRawStreamPtr->GetBunchLength(),
+ fAltroRawStreamPtr->GetSignals() ) );
+
+ nSamples = fAltroRawStreamPtr->GetBunchLength();
+ if( fDoPushRawData == true)
+ {
+ fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(),
+ nSamples, fAltroRawStreamPtr->GetEndTimeBin() );
+ }
+ //firstBunchPtr = const_cast< UShort_t* >( fAltroRawStreamPtr->GetSignals() );
+ }
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T6" << endl;
- fAnalyzerPtr->SetData( firstBunchPtr, nSamples);
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T6.1" << endl;
- fAnalyzerPtr->Evaluate(0, nSamples);
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T6.2" << endl;
-
- // if(fAnalyzerPtr->GetTiming() > fMinPeakPosition && fAnalyzerPtr->GetTiming() < fMaxPeakPosition)
- {
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T7" << endl;
- channelDataPtr->fChannelID = chId;
- channelDataPtr->fEnergy = static_cast<Float_t>(fAnalyzerPtr->GetEnergy()) - fOffset;
- // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T8" << endl;
-
- if( channelDataPtr->fEnergy > 70 )
+ totSize += sizeof( AliHLTCaloChannelDataStruct );
+ if(totSize > size)
{
- // cout << __FILE__ << __LINE__ << "The energy is of channel "<< chId << " is " << channelDataPtr->fEnergy << endl;
+ HLTError("Buffer overflow: Trying to write data of size: %d bytes. Output buffer available: %d bytes.", totSize, size);
+ return -1;
}
-
- channelDataPtr->fTime = static_cast<Float_t>(fAnalyzerPtr->GetTiming());
- channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
- channelCount++;
- channelDataPtr++; // Updating position of the free output.
- }
- }
- fRawDataWriter->NewChannel();
- }
- }
-
- //Writing the header
+
+ AliCaloFitResults res = fAnalyzerPtr->Evaluate( bvctr, fAltroRawStreamPtr->GetAltroCFG1(),
+ fAltroRawStreamPtr->GetAltroCFG2() );
+
+ HLTDebug("Channel energy: %f, max sig: %d, gain = %d, x = %d, z = %d", res.GetAmp(), res.GetMaxSig(),
+ (chId >> 12)&0x1, chId&0x3f, (chId >> 6)&0x3f);
+ {
+ channelDataPtr->fChannelID = chId;
+ channelDataPtr->fEnergy = static_cast<Float_t>( res.GetAmp() ) - fOffset;
+ channelDataPtr->fTime = static_cast<Float_t>( res.GetTof() );
+ if(fDetector.CompareTo("EMCAL") == 0) channelDataPtr->fTime = static_cast<Float_t>( res.GetTof() )*100E-9 - fAltroRawStreamPtr->GetL1Phase();
+ channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
+ channelCount++;
+ channelDataPtr++; // Updating position of the free output.
+ }
+ }
+ }
+ if( fDoPushRawData == true)
+ {
+ fRawDataWriter->NewChannel();
+ }
+ }
+
+
channelDataHeaderPtr->fNChannels = channelCount;
channelDataHeaderPtr->fAlgorithm = fAlgorithm;
channelDataHeaderPtr->fInfo = 0;
-
- if( fkDoPushRawData == true)
+
+ if( fDoPushRawData == true)
{
tmpsize += fRawDataWriter->CopyBufferToSharedMemory( (UShort_t *)channelDataPtr, size, totSize);
}
- // channelDataHeaderPtr->fHasRawData = false;
- channelDataHeaderPtr->fHasRawData = fkDoPushRawData;
-
+ channelDataHeaderPtr->fHasRawData = fDoPushRawData;
HLTDebug("Number of channels: %d", channelCount);
- //returning the size used
- // delete fAltroRawStreamPtr;
tmpsize += sizeof(AliHLTCaloChannelDataStruct)*channelCount + sizeof(AliHLTCaloChannelDataHeaderStruct);
-
- // return sizeof(AliHLTPHOSChannelDataStruct)*channelCount + sizeof(AliHLTPHOSChannelDataHeaderStruct);
return tmpsize;
}
-int
-AliHLTCaloRawAnalyzerComponentv3::DoInit( int argc, const char** argv )
-{
-
- //See base class for documentation
- // fPrintInfo = kFALSE;
-
- int iResult=0;
-
- // fMapperPtr = new AliHLTCaloMapper();
-
- //InitMapping();
-
- for(int i = 0; i < argc; i++)
- {
- if(!strcmp("-offset", argv[i]))
- {
- fOffset = atoi(argv[i+1]);
- }
- if(!strcmp("-bunchsizecut", argv[i]))
- {
- fBunchSizeCut = atoi(argv[i+1]);
- }
- if(!strcmp("-minpeakposition", argv[i]))
- {
- fMinPeakPosition = atoi(argv[i+1]);
- }
- if(!strcmp("-maxpeakposition", argv[i]))
- {
- fMaxPeakPosition = atoi(argv[i+1]);
- }
- }
-
- /*
- if( fMapperPtr->GetIsInitializedMapping() == false)
- {
- Logging(kHLTLogFatal, __FILE__ , IntToChar( __LINE__ ) , "AliHLTCaloMapper::Could not initialise mapping from file %s, aborting", fMapperPtr->GetFilePath());
- return -4;
- }
- */
-
- return iResult;
-}
-
-
-AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter() : //fIsFirstChannel(true),
- fRawDataBuffer(0),
- fCurrentChannelSize(0),
- // fIsFirstChannel(true),
- fBufferIndex(0),
- // fBufferSize( NZROWSRCU*NXCOLUMNSRCU*ALTROMAXSAMPLES*NGAINS +1000 ),
- fBufferSize( 64*56*ALTROMAXSAMPLES*NGAINS +1000 ),
- fCurrentChannelIdPtr(0),
- fCurrentChannelSizePtr(0),
- fCurrentChannelDataPtr(0),
- fTotalSize(0)
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter(AliHLTCaloConstants* cConst) :
+ fRawDataBuffer(0),
+ fCurrentChannelSize(0),
+ fBufferIndex(0),
+ fBufferSize( 64*56*cConst->GetNGAINS()*cConst->GetALTROMAXSAMPLES() +1000 ),
+ fCurrentChannelIdPtr(0),
+ fCurrentChannelSizePtr(0),
+ fCurrentChannelDataPtr(0),
+ fTotalSize(0)
{
+ //comment
fRawDataBuffer = new UShort_t[fBufferSize];
Init();
}
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::~RawDataWriter()
+{
+ delete [] fRawDataBuffer;
+}
+
void
AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::Init()
{
+ //comment
fCurrentChannelIdPtr = fRawDataBuffer;
fCurrentChannelSizePtr = fRawDataBuffer +1;
fCurrentChannelDataPtr = fRawDataBuffer +2;
void
AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::NewEvent()
{
+ //comment
Init();
fTotalSize = 0;
}
void
AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::NewChannel( )
{
+ //comment
*fCurrentChannelSizePtr = fCurrentChannelSize;
fCurrentChannelIdPtr += fCurrentChannelSize;
fCurrentChannelSizePtr += fCurrentChannelSize;
if( sizerequested > sizetotal )
{
return 0;
- }
+ }
else
{
for(int i=0; i < fTotalSize; i++)
memPtr[i] = fRawDataBuffer[i];
}
return fTotalSize;
- }
+ }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff