2 /**************************************************************************
3 * This file is property of and copyright by the ALICE HLT Project *
4 * All rights reserved. *
6 * Primary Authors: Per Thomas Hille, Oystein Djuvsland *
8 * Permission to use, copy, modify and distribute this software and its *
9 * documentation strictly for non-commercial purposes is hereby granted *
10 * without fee, provided that the above copyright notice appears in all *
11 * copies and that both the copyright notice and this permission notice *
12 * appear in the supporting documentation. The authors make no claims *
13 * about the suitability of this software for any purpose. It is *
14 * provided "as is" without express or implied warranty. *
15 **************************************************************************/
17 //#include "AliHLTCaloRawAnalyzer.h"
18 #include "AliCaloRawAnalyzer.h"
19 #include "AliCaloBunchInfo.h"
20 #include "AliCaloFitResults.h"
22 #include "AliHLTCaloRawAnalyzerComponentv3.h"
23 #include "AliHLTCaloChannelDataHeaderStruct.h"
24 #include "AliHLTCaloChannelDataStruct.h"
25 #include "AliHLTCaloMapper.h"
26 #include "AliHLTCaloSanityInspector.h"
27 #include "AliAltroRawStreamV3.h"
28 #include "AliRawReaderMemory.h"
29 #include "AliAltroRawStreamV3.h"
30 #include "AliCaloRawStreamV3.h"
31 #include "AliHLTCaloConstantsHandler.h"
32 #include "AliHLTCaloConstants.h"
33 #include "AliHLTCaloRcuProcessor.h"
34 #include "AliHLTCaloCrazynessDefinitions.h"
35 #include "AliHLTCaloChannelRawDataStruct.h"
36 #include "AliHLTCaloCoordinate.h"
39 //#include "AliCALOBunchInfo.h"
45 ClassImp(AliHLTCaloRawAnalyzerComponentv3);
47 AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3(TString det):
48 AliHLTCaloConstantsHandler(det),
49 AliHLTCaloRcuProcessor(),
50 // fCaloEventCount(0),
53 fSanityInspectorPtr(0),
54 fRawReaderMemoryPtr(0),
55 fAltroRawStreamPtr(0),
60 fMaxPeakPosition(100),
62 fDoPushBadRawData(false),
67 // fMapperPtr = new AliHLTCaloMapper();
69 fRawReaderMemoryPtr = new AliRawReaderMemory();
71 fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawReaderMemoryPtr);
73 fSanityInspectorPtr = new AliHLTCaloSanityInspector();
75 if( fDoPushRawData == true )
77 fRawDataWriter = new RawDataWriter(fCaloConstants);
80 fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, det);
85 AliHLTCaloRawAnalyzerComponentv3::~AliHLTCaloRawAnalyzerComponentv3()
94 AliHLTCaloRawAnalyzerComponentv3::DoInit( int argc, const char** argv )
97 //See base class for documentation
98 // fPrintInfo = kFALSE;
102 // fMapperPtr = new AliHLTCaloMapper();
106 for(int i = 0; i < argc; i++)
108 if(!strcmp("-offset", argv[i]))
110 fOffset = atoi(argv[i+1]);
112 if(!strcmp("-bunchsizecut", argv[i]))
114 fBunchSizeCut = atoi(argv[i+1]);
116 if(!strcmp("-minpeakposition", argv[i]))
118 fMinPeakPosition = atoi(argv[i+1]);
120 if(!strcmp("-maxpeakposition", argv[i]))
122 fMaxPeakPosition = atoi(argv[i+1]);
124 if(!strcmp("-pushrawdata", argv[i]))
126 fDoPushRawData = true;
128 if(!strcmp("-pushbaddata", argv[i]))
130 fDoPushBadRawData = true;
132 if(fDoPushBadRawData && fDoPushRawData)
134 HLTWarning("fDoPushBadRawData and fDoPushRawData in conflict, using fDoPushRawData");
135 fDoPushBadRawData = false;
140 if( fMapperPtr->GetIsInitializedMapping() == false)
142 Logging(kHLTLogFatal, __FILE__ , IntToChar( __LINE__ ) , "AliHLTCaloMapper::Could not initialise mapping from file %s, aborting", fMapperPtr->GetFilePath());
150 AliHLTCaloRawAnalyzerComponentv3::DoDeinit()
166 if(fRawReaderMemoryPtr)
168 delete fRawReaderMemoryPtr;
169 fRawReaderMemoryPtr = 0;
172 if(fAltroRawStreamPtr)
174 delete fAltroRawStreamPtr;
175 fAltroRawStreamPtr = 0;
184 AliHLTCaloRawAnalyzerComponentv3::GetComponentID()
187 return "CaloRawAnalyzerv3";
194 AliHLTCaloRawAnalyzerComponentv3::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
198 list.push_back( AliHLTCaloDefinitions::fgkDDLPackedRawDataType | kAliHLTDataOriginPHOS);
204 AliHLTComponentDataType
205 AliHLTCaloRawAnalyzerComponentv3::GetOutputDataType()
208 return AliHLTCaloDefinitions::fgkChannelDataType;
215 AliHLTCaloRawAnalyzerComponentv3::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
218 constBase = sizeof(AliHLTCaloChannelDataHeaderStruct);
219 inputMultiplier = 0.5;
226 AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, AliHLTUInt8_t* outputPtr, const AliHLTUInt32_t size, UInt_t& totSize)
232 Short_t channelCount = 0;
234 AliHLTCaloChannelDataHeaderStruct *channelDataHeaderPtr = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*>(outputPtr);
235 AliHLTCaloChannelDataStruct *channelDataPtr = reinterpret_cast<AliHLTCaloChannelDataStruct*>(outputPtr+sizeof(AliHLTCaloChannelDataHeaderStruct));
237 totSize += sizeof( AliHLTCaloChannelDataHeaderStruct );
238 fRawReaderMemoryPtr->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), static_cast<ULong_t>( iter->fSize ) );
239 fRawReaderMemoryPtr->SetEquipmentID( fMapperPtr->GetDDLFromSpec( iter->fSpecification) + 1792 );
240 fRawReaderMemoryPtr->Reset();
241 fRawReaderMemoryPtr->NextEvent();
243 if( fDoPushRawData == true)
245 fRawDataWriter->NewEvent( );
248 if(fAltroRawStreamPtr->NextDDL())
251 // fOffset = ( fAltroRawStreamPtr->GetAltroCFG1() >> 10 ) & 0xf;
253 while( fAltroRawStreamPtr->NextChannel() )
255 // cout << __FILE__ << ":" << __LINE__ << ":" <<__FUNCTION__ << "T3" << endl;
256 if( fAltroRawStreamPtr->GetHWAddress() < 128 || ( fAltroRawStreamPtr->GetHWAddress() ^ 0x800) < 128 )
263 UShort_t* firstBunchPtr = 0;
264 int chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress());
265 // HLTError("Channel HW address: %d", fAltroRawStreamPtr->GetHWAddress());
266 if( fDoPushRawData == true)
268 fRawDataWriter->SetChannelId( chId );
272 vector <AliCaloBunchInfo> bvctr;
273 while( fAltroRawStreamPtr->NextBunch() == true )
275 bvctr.push_back( AliCaloBunchInfo( fAltroRawStreamPtr->GetStartTimeBin(), fAltroRawStreamPtr->GetBunchLength(), fAltroRawStreamPtr->GetSignals() ) );
277 nSamples = fAltroRawStreamPtr->GetBunchLength();
278 if( fDoPushRawData == true)
280 fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(), nSamples, fAltroRawStreamPtr->GetEndTimeBin() );
282 firstBunchPtr = const_cast< UShort_t* >( fAltroRawStreamPtr->GetSignals() );
287 totSize += sizeof( AliHLTCaloChannelDataStruct );
290 //HLTError("Buffer overflow: Trying to write data of size: %d bytes. Output buffer available: %d bytes.", totSize, size);
294 // fAnalyzerPtr->SetData( firstBunchPtr, nSamples);
295 AliCaloFitResults res = fAnalyzerPtr->Evaluate( bvctr, fAltroRawStreamPtr->GetAltroCFG1(), fAltroRawStreamPtr->GetAltroCFG2() );
298 // if(fAnalyzerPtr->GetTiming() > fMinPeakPosition && fAnalyzerPtr->GetTiming() < fMaxPeakPosition)
300 channelDataPtr->fChannelID = chId;
301 channelDataPtr->fEnergy = static_cast<Float_t>( res.GetAmp() ) - fOffset;
303 channelDataPtr->fTime = static_cast<Float_t>( res.GetTof() );
304 channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
306 channelDataPtr++; // Updating position of the free output.
310 // This should be the functionality for pushing the raw data for the bad channels
315 crazyness |= AliHLTCaloCrazynessDefinitions::fgkBadEstBit;
318 channelDataPtr->fChannelID = chId;
319 channelDataPtr->fEnergy = static_cast<Float_t>(fAnalyzerPtr->GetEnergy()) - fOffset;
320 AliHLTCaloCoordinate c;
321 fMapperPtr->ChannelId2Coordinate(chId, c);
322 // HLTError("Got channel, x: %d, z: %d, gain: %d, energy: %f", c.fX, c.fZ, c.fGain, channelDataPtr->fEnergy);
323 channelDataPtr->fTime = static_cast<Float_t>(fAnalyzerPtr->GetTiming());
324 channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
326 channelDataPtr++; // Updating position of the free output.
328 // Push the raw data if we have crazyness and feature to push raw data for bad channels
329 if (crazyness && fDoPushBadRawData)
332 channelDataPtr->fCrazyness = crazyness | AliHLTCaloCrazynessDefinitions::fgkRawDataBit;
333 UShort_t extraSize = sizeof ( AliHLTCaloChannelRawDataStruct ) + ( nSamples-1 ) *sizeof ( UShort_t );
334 totSize += extraSize;
336 if ( totSize > size )
338 HLTError ( "Buffer overflow: Trying to write data of size: %d bytes. Output buffer available: %d bytes.", totSize, size );
342 AliHLTCaloChannelRawDataStruct *tmpChannel = reinterpret_cast<AliHLTCaloChannelRawDataStruct*> ( channelDataPtr );
343 memcpy ( & ( tmpChannel->fData ), firstBunchPtr, nSamples*sizeof ( UShort_t ) );
344 channelDataPtr = reinterpret_cast<AliHLTCaloChannelDataStruct*> ( reinterpret_cast<UChar_t*> ( channelDataPtr ) + extraSize );
350 if( fDoPushRawData == true)
352 fRawDataWriter->NewChannel();
361 channelDataHeaderPtr->fNChannels = channelCount;
362 channelDataHeaderPtr->fAlgorithm = fAlgorithm;
363 channelDataHeaderPtr->fInfo = 0;
368 if( fDoPushRawData == true)
370 tmpsize += fRawDataWriter->CopyBufferToSharedMemory( (UShort_t *)channelDataPtr, size, totSize);
373 // channelDataHeaderPtr->fHasRawData = false;
374 channelDataHeaderPtr->fHasRawData = fDoPushRawData;
375 HLTError("Number of channels: %d", channelCount);
376 tmpsize += sizeof(AliHLTCaloChannelDataStruct)*channelCount + sizeof(AliHLTCaloChannelDataHeaderStruct);
385 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter(AliHLTCaloConstants* cConst) : //fIsFirstChannel(true),
387 fCurrentChannelSize(0),
388 // fIsFirstChannel(true),
390 // fBufferSize( NZROWSRCU*NXCOLUMNSRCU*ALTROMAXSAMPLES*NGAINS +1000 ),
391 fBufferSize( 64*56*cConst->GetNGAINS()*cConst->GetALTROMAXSAMPLES() +1000 ),
392 fCurrentChannelIdPtr(0),
393 fCurrentChannelSizePtr(0),
394 fCurrentChannelDataPtr(0),
397 fRawDataBuffer = new UShort_t[fBufferSize];
404 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::Init()
406 fCurrentChannelIdPtr = fRawDataBuffer;
407 fCurrentChannelSizePtr = fRawDataBuffer +1;
408 fCurrentChannelDataPtr = fRawDataBuffer +2;
414 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::NewEvent()
422 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::NewChannel( )
424 *fCurrentChannelSizePtr = fCurrentChannelSize;
425 fCurrentChannelIdPtr += fCurrentChannelSize;
426 fCurrentChannelSizePtr += fCurrentChannelSize;
427 fCurrentChannelDataPtr += fCurrentChannelSize;
429 fCurrentChannelSize = 2;
435 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::WriteBunchData(const UShort_t *bunchdata, const int length, const UInt_t starttimebin )
437 fCurrentChannelDataPtr[fBufferIndex] = starttimebin;
438 fCurrentChannelSize ++;
440 fCurrentChannelDataPtr[fBufferIndex] = length;
441 fCurrentChannelSize ++;
446 for(int i=0; i < length; i++)
448 fCurrentChannelDataPtr[ fBufferIndex + i ] = bunchdata[i];
451 fCurrentChannelSize += length;
452 fTotalSize += length;
453 fBufferIndex += length;
458 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::SetChannelId( const UShort_t channeldid )
460 *fCurrentChannelIdPtr = channeldid;
465 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::ResetBuffer()
467 for(int i=0; i < fBufferSize ; i++ )
469 fRawDataBuffer[i] = 0;
475 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::CopyBufferToSharedMemory(UShort_t *memPtr, const int sizetotal, const int sizeused )
477 int sizerequested = (sizeof(int)*fTotalSize + sizeused);
479 if( sizerequested > sizetotal )
485 for(int i=0; i < fTotalSize; i++)
487 memPtr[i] = fRawDataBuffer[i];