+// $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 "AliHLTCaloConstants.h"
-#include "AliHLTCaloRcuProcessor.h"
-#include "AliHLTCaloCrazynessDefinitions.h"
#include "AliHLTCaloChannelRawDataStruct.h"
-#include "AliHLTCaloCoordinate.h"
+#include "AliLog.h"
+#include "TStopwatch.h"
+
+#include "AliCaloRawAnalyzerFactory.h"
+
+//#include "AliCaloConstants.h"
-//#include "AliCALOBunchInfo.h"
-//AliCALORawAnalyzer
+//#include "AliCaloRawAnalyzer.h"
+
+//using namespace Algo;
#include <vector>
using namespace std;
ClassImp(AliHLTCaloRawAnalyzerComponentv3);
-AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3(TString det):
- AliHLTCaloConstantsHandler(det),
- AliHLTCaloRcuProcessor(),
- // fCaloEventCount(0),
- fAnalyzerPtr(0),
- fMapperPtr(0),
- fSanityInspectorPtr(0),
- fRawReaderMemoryPtr(0),
- fAltroRawStreamPtr(0),
- fAlgorithm(0),
- fOffset(0),
- fBunchSizeCut(0),
- fMinPeakPosition(0),
- fMaxPeakPosition(100),
- fDoPushBadRawData(false),
- fDoPushRawData(false),
- fRawDataWriter(0)
-{
- //comment
-
- // fMapperPtr = new AliHLTCaloMapper();
- fRawReaderMemoryPtr = new AliRawReaderMemory();
-
- fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawReaderMemoryPtr);
- fSanityInspectorPtr = new AliHLTCaloSanityInspector();
-
- if( fDoPushRawData == true )
- {
- fRawDataWriter = new RawDataWriter(fCaloConstants);
- }
+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
- fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, det);
-
}
AliHLTCaloRawAnalyzerComponentv3::~AliHLTCaloRawAnalyzerComponentv3()
{
- //comment
- DoDeinit();
+ //destructor
}
-
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]))
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( fMapperPtr->GetIsInitializedMapping() == false)
+
+ fAnalyzerPtr = AliCaloRawAnalyzerFactory::CreateAnalyzer(fAlgorithm);
+ fAnalyzerPtr->SetIsZeroSuppressed(true);
+ fSanityInspectorPtr = new AliHLTCaloSanityInspector();
+
+ if( fDoPushRawData == true )
{
- Logging(kHLTLogFatal, __FILE__ , IntToChar( __LINE__ ) , "AliHLTCaloMapper::Could not initialise mapping from file %s, aborting", fMapperPtr->GetFilePath());
- return -4;
+ fRawDataWriter = new RawDataWriter(fCaloConstants);
}
- */
+ fRawReaderMemoryPtr = new AliRawReaderMemory();
+ fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, fDetector);
+
return iResult;
}
+
int
AliHLTCaloRawAnalyzerComponentv3::DoDeinit()
{
//comment
-
- if(fAnalyzerPtr)
- {
- delete fAnalyzerPtr;
- fAnalyzerPtr = 0;
- }
-
- if(fMapperPtr)
- {
- delete fMapperPtr;
- fMapperPtr = 0;
- }
-
- if(fRawReaderMemoryPtr)
- {
- delete fRawReaderMemoryPtr;
- fRawReaderMemoryPtr = 0;
- }
-
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()
+bool
+AliHLTCaloRawAnalyzerComponentv3::CheckInputDataType(const AliHLTComponentDataType &datatype)
{
//comment
- return AliHLTCaloDefinitions::fgkChannelDataType;
+ 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;
}
- */
- /*
-void
-AliHLTCaloRawAnalyzerComponentv3::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
+int
+AliHLTCaloRawAnalyzerComponentv3::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
+ AliHLTComponentTriggerData& /*trigData*/,
+ AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
//comment
- constBase = sizeof(AliHLTCaloChannelDataHeaderStruct);
- inputMultiplier = 0.5;
-}
- */
+ 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;
+
+ for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+ {
+ iter = blocks+ndx;
+ if( ! CheckInputDataType(iter->fDataType) )
+ {
+ continue;
+ }
+
+ if(iter->fSpecification != fCurrentSpec)
+ {
+ fCurrentSpec = iter->fSpecification;
+ InitMapping(iter->fSpecification);
+ }
+
+ 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)
{
-
+ //comment
int tmpsize= 0;
Int_t crazyness = 0;
Int_t nSamples = 0;
AliHLTCaloChannelDataHeaderStruct *channelDataHeaderPtr = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*>(outputPtr);
AliHLTCaloChannelDataStruct *channelDataPtr = reinterpret_cast<AliHLTCaloChannelDataStruct*>(outputPtr+sizeof(AliHLTCaloChannelDataHeaderStruct));
-
totSize += sizeof( AliHLTCaloChannelDataHeaderStruct );
fRawReaderMemoryPtr->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), static_cast<ULong_t>( iter->fSize ) );
fRawReaderMemoryPtr->SetEquipmentID( fMapperPtr->GetDDLFromSpec( iter->fSpecification) + fCaloConstants->GetDDLOFFSET() );
fRawReaderMemoryPtr->Reset();
fRawReaderMemoryPtr->NextEvent();
-
+
if( fDoPushRawData == true)
{
- fRawDataWriter->NewEvent( );
+ fRawDataWriter->NewEvent( );
}
-
+
if(fAltroRawStreamPtr->NextDDL())
- {
- int cnt = 0;
- // fOffset = ( fAltroRawStreamPtr->GetAltroCFG1() >> 10 ) & 0xf;
- fOffset = 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;
- int chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress());
- // HLTError("Channel HW address: %d", fAltroRawStreamPtr->GetHWAddress());
- if( fDoPushRawData == true)
- {
- fRawDataWriter->SetChannelId( chId );
- }
-
- // 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() );
- }
-
- //return 1;
-
- 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;
- }
-
- // fAnalyzerPtr->SetData( firstBunchPtr, nSamples);
- 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);
-
- // if(fAnalyzerPtr->GetTiming() > fMinPeakPosition && fAnalyzerPtr->GetTiming() < fMaxPeakPosition)
+ {
+ int cnt = 0;
+ fOffset = 0;
+ while( fAltroRawStreamPtr->NextChannel() )
+ {
+ if( fAltroRawStreamPtr->GetHWAddress() < 128 || ( fAltroRawStreamPtr->GetHWAddress() ^ 0x800) < 128 )
{
- channelDataPtr->fChannelID = chId;
- channelDataPtr->fEnergy = static_cast<Float_t>( res.GetAmp() ) - fOffset;
-
- channelDataPtr->fTime = static_cast<Float_t>( res.GetTof() );
- channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
- channelCount++;
- channelDataPtr++; // Updating position of the free output.
- }
- }
-
- // This should be the functionality for pushing the raw data for the bad channels
-
- /*
- if ( bad )
- {
- crazyness |= AliHLTCaloCrazynessDefinitions::fgkBadEstBit;
- }
-
- channelDataPtr->fChannelID = chId;
- channelDataPtr->fEnergy = static_cast<Float_t>(fAnalyzerPtr->GetEnergy()) - fOffset;
- AliHLTCaloCoordinate c;
- fMapperPtr->ChannelId2Coordinate(chId, c);
- HLTDebug("Got channel, x: %d, z: %d, gain: %d, energy: %f", c.fX, c.fZ, c.fGain, channelDataPtr->fEnergy);
- channelDataPtr->fTime = static_cast<Float_t>(fAnalyzerPtr->GetTiming());
- channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
- channelCount++;
- channelDataPtr++; // Updating position of the free output.
+ 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 );
+ }
- // Push the raw data if we have crazyness and feature to push raw data for bad channels
- if (crazyness && fDoPushBadRawData)
-
- {
- channelDataPtr->fCrazyness = crazyness | AliHLTCaloCrazynessDefinitions::fgkRawDataBit;
- UShort_t extraSize = sizeof ( AliHLTCaloChannelRawDataStruct ) + ( nSamples-1 ) *sizeof ( UShort_t );
- totSize += extraSize;
-
- if ( totSize > size )
- {
- HLTError ( "Buffer overflow: Trying to write data of size: %d bytes. Output buffer available: %d bytes.", totSize, size );
- return -1;
- }
-
- AliHLTCaloChannelRawDataStruct *tmpChannel = reinterpret_cast<AliHLTCaloChannelRawDataStruct*> ( channelDataPtr );
- memcpy ( & ( tmpChannel->fData ), firstBunchPtr, nSamples*sizeof ( UShort_t ) );
- channelDataPtr = reinterpret_cast<AliHLTCaloChannelDataStruct*> ( reinterpret_cast<UChar_t*> ( channelDataPtr ) + extraSize );
- }
-
- */
- }
-
- if( fDoPushRawData == true)
- {
- fRawDataWriter->NewChannel();
- }
-
- }
-
-
-// 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() );
+ }
+
+ 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;
+ }
+
+ 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();
+ }
+ }
-//Writing the header
+
channelDataHeaderPtr->fNChannels = channelCount;
channelDataHeaderPtr->fAlgorithm = fAlgorithm;
channelDataHeaderPtr->fInfo = 0;
-
- // return 1;
-
-
+
if( fDoPushRawData == true)
{
tmpsize += fRawDataWriter->CopyBufferToSharedMemory( (UShort_t *)channelDataPtr, size, totSize);
}
- // channelDataHeaderPtr->fHasRawData = false;
channelDataHeaderPtr->fHasRawData = fDoPushRawData;
HLTDebug("Number of channels: %d", channelCount);
tmpsize += sizeof(AliHLTCaloChannelDataStruct)*channelCount + sizeof(AliHLTCaloChannelDataHeaderStruct);
-
-
-AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter(AliHLTCaloConstants* cConst) : //fIsFirstChannel(true),
- fRawDataBuffer(0),
- fCurrentChannelSize(0),
- // fIsFirstChannel(true),
- fBufferIndex(0),
- // fBufferSize( NZROWSRCU*NXCOLUMNSRCU*ALTROMAXSAMPLES*NGAINS +1000 ),
- fBufferSize( 64*56*cConst->GetNGAINS()*cConst->GetALTROMAXSAMPLES() +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