// $Id$
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
- * Timm Steinbeck <timm@kip.uni-heidelberg.de> *
- * for The ALICE Off-line Project. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* *
+//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
+//* Timm Steinbeck <timm@kip.uni-heidelberg.de> *
+//* for The ALICE HLT Project. *
+//* *
+//* Permission to use, copy, modify and distribute this software and its *
+//* documentation strictly for non-commercial purposes is hereby granted *
+//* without fee, provided that the above copyright notice appears in all *
+//* copies and that both the copyright notice and this permission notice *
+//* appear in the supporting documentation. The authors make no claims *
+//* about the suitability of this software for any purpose. It is *
+//* provided "as is" without express or implied warranty. *
+//**************************************************************************
/** @file AliHLTTPCGlobalMergerComponent.cxx
@author Timm Steinbeck, Matthias Richter
@brief HLT TPC global merger component.
*/
-#if __GNUC__== 3
+#if __GNUC__>= 3
using namespace std;
#endif
+#include <climits>
#include "AliHLTTPCGlobalMergerComponent.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCGlobalMerger.h"
#include "AliHLTTPCTrackSegmentData.h"
#include "AliHLTTPCTrackArray.h"
#include "AliHLTTPCTrackletDataFormat.h"
-#include "AliHLTTPCSpacePointData.h"
-#include "AliHLTTPCClusterDataFormat.h"
+//#include "AliHLTTPCSpacePointData.h"
+//#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCDefinitions.h"
-#include <stdlib.h>
-#include <errno.h>
+#include <cstdlib>
+#include <cerrno>
-// this is a global object used for automatic component registration, do not use this
-AliHLTTPCGlobalMergerComponent gAliHLTTPCGlobalMergerComponent;
-
-ClassImp(AliHLTTPCGlobalMergerComponent)
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTTPCGlobalMergerComponent);
AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent()
:
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}
-AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent(const AliHLTTPCGlobalMergerComponent&)
- :
- fGlobalMerger(NULL),
- fVertex(NULL)
-{
- // see header file for class documentation
- HLTFatal("copy constructor untested");
-}
-
-AliHLTTPCGlobalMergerComponent& AliHLTTPCGlobalMergerComponent::operator=(const AliHLTTPCGlobalMergerComponent&)
-{
- // see header file for class documentation
- HLTFatal("assignment operator untested");
- return *this;
-}
-
AliHLTTPCGlobalMergerComponent::~AliHLTTPCGlobalMergerComponent()
{
// see header file for class documentation
// These functions are required for the registration process
const char* AliHLTTPCGlobalMergerComponent::GetComponentID()
- {
+{
// see header file for class documentation
- return "TPCGlobalMerger";
- }
+ return "TPCGlobalMerger";
+}
-void AliHLTTPCGlobalMergerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
- {
+void AliHLTTPCGlobalMergerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
+{
// see header file for class documentation
- list.clear();
- list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
- list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
- }
+ list.clear();
+ list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
+}
AliHLTComponentDataType AliHLTTPCGlobalMergerComponent::GetOutputDataType()
- {
+{
// see header file for class documentation
- return AliHLTTPCDefinitions::fgkTracksDataType;
- }
+ return AliHLTTPCDefinitions::fgkTracksDataType;
+}
void AliHLTTPCGlobalMergerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
- {
+{
// see header file for class documentation
- // XXX TODO: Find more realistic values.
- constBase = 0;
- inputMultiplier = 1.0;
- }
+ // XXX TODO: Find more realistic values.
+ constBase = 0;
+ inputMultiplier = 1.0;
+}
AliHLTComponent* AliHLTTPCGlobalMergerComponent::Spawn()
- {
+{
// see header file for class documentation
- return new AliHLTTPCGlobalMergerComponent;
- }
+ return new AliHLTTPCGlobalMergerComponent;
+}
void AliHLTTPCGlobalMergerComponent::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
- {
+{
// see header file for class documentation
- fGlobalMerger->SetParameter( maxy, maxz, maxkappa, maxpsi, maxtgl );
- }
+ fGlobalMerger->SetParameter( maxy, maxz, maxkappa, maxpsi, maxtgl );
+}
-int AliHLTTPCGlobalMergerComponent::DoInit( int argc, const char** argv )
- {
+int AliHLTTPCGlobalMergerComponent::DoInit( int /*argc*/, const char** /*argv*/ )
+{
// see header file for class documentation
- if ( fGlobalMerger || fVertex )
- return EINPROGRESS;
- fGlobalMerger = new AliHLTTPCGlobalMerger();
- fVertex = new AliHLTTPCVertex();
- SetMergerParameters();
- return 0;
- }
+ if ( fGlobalMerger || fVertex )
+ return EINPROGRESS;
+ fGlobalMerger = new AliHLTTPCGlobalMerger();
+ fVertex = new AliHLTTPCVertex();
+ SetMergerParameters();
+ return 0;
+}
int AliHLTTPCGlobalMergerComponent::DoDeinit()
- {
+{
// see header file for class documentation
- if ( fGlobalMerger )
- delete fGlobalMerger;
- fGlobalMerger = NULL;
- if ( fVertex )
- delete fVertex;
- fVertex = NULL;
- return 0;
- }
+ if ( fGlobalMerger )
+ delete fGlobalMerger;
+ fGlobalMerger = NULL;
+ if ( fVertex )
+ delete fVertex;
+ fVertex = NULL;
+ return 0;
+}
int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
- AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
- AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
- {
+ AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks )
+{
// see header file for class documentation
- const AliHLTComponentBlockData* iter = NULL;
- const AliHLTComponentBlockData* lastVertexBlock = NULL;
- unsigned long ndx;
-
- std::vector<SliceData> slices;
- std::vector<SliceData>::iterator sdIter, sdEnd;
- int minSlice = INT_MAX, maxSlice = 0;
- bool found;
- AliHLTTPCTrackletData* inPtr;
- AliHLTTPCTrackletData* outPtr;
- UInt_t tSize = 0;
- Int_t slice=0;
-
- // Create sorted (by slice number) list of data (tracks and vertex) for each slice present.
- // also note the min and max slice numbers
- for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+ int iResult=0;
+ AliHLTUInt32_t capacity=size;
+ size=0;
+
+ if (!IsDataEvent()) return 0;
+
+ const AliHLTComponentBlockData* iter = NULL;
+ const AliHLTComponentBlockData* lastVertexBlock = NULL;
+ unsigned long ndx;
+
+ std::vector<SliceData> slices;
+ std::vector<SliceData>::iterator sdIter, sdEnd;
+ int minSlice = INT_MAX, maxSlice = 0;
+ bool found;
+ AliHLTTPCTrackletData* inPtr;
+ AliHLTTPCTrackletData* outPtr;
+ UInt_t tSize = 0;
+ Int_t slice=0;
+
+ // Create sorted (by slice number) list of data (tracks and vertex) for each slice present.
+ // also note the min and max slice numbers
+ for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+ {
+ iter = blocks+ndx;
+ bool bIsTrackSegDataBlock=false;
+ bool bIsVertexDataBlock=false;
+ if(!(bIsTrackSegDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkTrackSegmentsDataType)) &&
+ !(bIsVertexDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkVertexDataType))){
+ continue;
+ }
+
+ slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
+ if (slice<0 || slice>=AliHLTTPCTransform::GetNSlice()) {
+ HLTError("invalid slice number %d extracted from specification 0x%08lx, skipping block of type %s",
+ slice, iter->fSpecification, DataType2Text(iter->fDataType).c_str());
+ // just remember the error, if there are other valid blocks ignore the
+ // error, return code otherwise
+ iResult=-EBADF;
+ continue;
+ }
+ if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr( *iter )) {
+ // the code was not written for/ never used with multiple slices
+ // in one data block/ specification
+ HLTWarning("specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code",
+ iter->fSpecification, DataType2Text(iter->fDataType).c_str());
+ }
+ found=false;
+ sdIter = slices.begin();
+ sdEnd = slices.end();
+ while ( sdIter != sdEnd )
{
- iter = blocks+ndx;
- slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
- found=false;
- sdIter = slices.begin();
- sdEnd = slices.end();
- while ( sdIter != sdEnd )
- {
- if ( sdIter->fSlice > slice || sdIter->fSlice == slice )
- break;
- sdIter++;
- }
- if ( sdIter==sdEnd || sdIter->fSlice>slice )
+ if ( sdIter->fSlice > slice || sdIter->fSlice == slice )
+ break;
+ sdIter++;
+ }
+ if ( sdIter==sdEnd || sdIter->fSlice>slice )
+ {
+ if ( sdIter == sdEnd )
+ maxSlice = slice;
+ if ( sdIter==slices.begin() )
+ minSlice = slice;
+ SliceData sd;
+ sd.fSlice = slice;
+ sd.fVertexBlock = NULL;
+ sd.fVertexBlockIndex = 0;
+ sd.fTrackletBlock = NULL;
+ sd.fTrackletBlockIndex = 0;
+ sdIter = slices.insert( sdIter, sd );
+ }
+ if ( sdIter->fSlice == slice )
+ {
+ if (bIsTrackSegDataBlock)
{
- if ( sdIter == sdEnd )
- maxSlice = slice;
- if ( sdIter==slices.begin() )
- minSlice = slice;
- SliceData sd;
- sd.fSlice = slice;
- sd.fVertexBlock = NULL;
- sd.fVertexBlockIndex = 0;
- sd.fTrackletBlock = NULL;
- sd.fTrackletBlockIndex = 0;
- sdIter = slices.insert( sdIter, sd );
+ if ( !sdIter->fTrackletBlock )
+ {
+ sdIter->fTrackletBlock = iter;
+ sdIter->fTrackletBlockIndex = ndx;
+ }
+ else
+ {
+ Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate track data block",
+ "Duplicate track data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
+ slice, evtData.fEventID, evtData.fEventID, sdIter->fTrackletBlockIndex, ndx );
+ }
}
- if ( sdIter->fSlice == slice )
+ if (bIsVertexDataBlock)
{
- if ( iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType )
+ lastVertexBlock = iter;
+ if ( !sdIter->fVertexBlock )
{
- if ( !sdIter->fTrackletBlock )
- {
- sdIter->fTrackletBlock = iter;
- sdIter->fTrackletBlockIndex = ndx;
- }
- else
- {
- Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate track data block",
- "Duplicate track data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
- slice, evtData.fEventID, evtData.fEventID, sdIter->fTrackletBlockIndex, ndx );
- }
+ sdIter->fVertexBlock = iter;
+ sdIter->fVertexBlockIndex = ndx;
}
- if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
+ else
{
- lastVertexBlock = iter;
- if ( !sdIter->fVertexBlock )
- {
- sdIter->fVertexBlock = iter;
- sdIter->fVertexBlockIndex = ndx;
- }
- else
- {
- Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate vertex data block",
- "Duplicate vertex data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
- slice, evtData.fEventID, evtData.fEventID, sdIter->fVertexBlockIndex, ndx );
- }
+ Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate vertex data block",
+ "Duplicate vertex data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
+ slice, evtData.fEventID, evtData.fEventID, sdIter->fVertexBlockIndex, ndx );
}
}
}
+ }
- //fGlobalMerger->Setup( minSlice, maxSlice );
- fGlobalMerger->Setup( 0, 35 );
+ // skip the processing if there was no track segment data
+ if (slices.size()==0) {
+ return iResult;
+ }
+ iResult=0;
- if ( !lastVertexBlock )
+ //fGlobalMerger->Setup( minSlice, maxSlice );
+ fGlobalMerger->Setup( 0, 35 );
+
+ if ( !lastVertexBlock )
+ {
+ Logging( kHLTLogInfo, "HLT::GlobalMerger::DoEvent", "No vertex data block",
+ "No vertex data block found for event 0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
+ fVertex->SetZero();
+ }
+ else
+ fVertex->Read( (AliHLTTPCVertexData*)( lastVertexBlock->fPtr ) );
+
+ // Add all tracks into the merger
+ sdIter = slices.begin();
+ sdEnd = slices.end();
+ int lastSlice = -1;
+ while ( sdIter != sdEnd )
+ {
+ if ( sdIter->fVertexBlock )
{
- Logging( kHLTLogInfo, "HLT::GlobalMerger::DoEvent", "No vertex data block",
- "No vertex data block found for event 0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
- fVertex->SetZero();
+ fVertex->Read( (AliHLTTPCVertexData*)( sdIter->fVertexBlock->fPtr ) );
+ fGlobalMerger->SetVertex( fVertex );
}
- else
- fVertex->Read( (AliHLTTPCVertexData*)( lastVertexBlock->fPtr ) );
-
- // Add all tracks into the merger
- sdIter = slices.begin();
- sdEnd = slices.end();
- int lastSlice = -1;
- while ( sdIter != sdEnd )
+ for ( int slNr=lastSlice+1; slNr<=sdIter->fSlice; slNr++ )
+ fGlobalMerger->InitSlice( slNr );
+ if ( sdIter->fTrackletBlock )
{
- if ( sdIter->fVertexBlock )
+ inPtr = (AliHLTTPCTrackletData*)( sdIter->fTrackletBlock->fPtr );
+ if ( !inPtr )
{
- fVertex->Read( (AliHLTTPCVertexData*)( sdIter->fVertexBlock->fPtr ) );
- fGlobalMerger->SetVertex( fVertex );
+ Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "No track data block",
+ "No track data block found for event 0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
}
- for ( int slNr=lastSlice+1; slNr<=sdIter->fSlice; slNr++ )
- fGlobalMerger->InitSlice( slNr );
- if ( sdIter->fTrackletBlock )
+ else
{
- inPtr = (AliHLTTPCTrackletData*)( sdIter->fTrackletBlock->fPtr );
- if ( !inPtr )
- {
- Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "No track data block",
- "No track data block found for event 0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
- }
- else
- {
- //fGlobalMerger->InitSlice( sdIter->fSlice );
- fGlobalMerger->FillTracks( inPtr->fTrackletCnt, inPtr->fTracklets );
- }
- }
- lastSlice = sdIter->fSlice;
- sdIter++;
+ //fGlobalMerger->InitSlice( sdIter->fSlice );
+ fGlobalMerger->FillTracks( inPtr->fTrackletCnt, inPtr->fTracklets );
+ }
}
- for ( int slNr=lastSlice+1; slNr<=35; slNr++ )
- fGlobalMerger->InitSlice( slNr );
+ lastSlice = sdIter->fSlice;
+ sdIter++;
+ }
+ for ( int slNr=lastSlice+1; slNr<=35; slNr++ )
+ fGlobalMerger->InitSlice( slNr );
- // Now we can really merge
- fGlobalMerger->Merge();
- fGlobalMerger->AddAllTracks();
+ // Now we can really merge
+ fGlobalMerger->Merge();
+ fGlobalMerger->AddAllTracks();
- UInt_t ntracks0=0;
- outPtr = (AliHLTTPCTrackletData*)(outputPtr);
+ // check if there was enough space in the output buffer
+ UInt_t ntracks0=fGlobalMerger->GetOutTracks()->GetNTracks();
+ if (outputPtr==NULL || (sizeof(AliHLTTPCTrackletData)+ntracks0*sizeof(AliHLTTPCTrackSegmentData)>capacity)) {
+ iResult=-ENOSPC;
+ } else {
+ outPtr = (AliHLTTPCTrackletData*)(outputPtr);
- tSize = fGlobalMerger->GetOutTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
- outPtr->fTrackletCnt = ntracks0;
+ tSize = fGlobalMerger->GetOutTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
+ outPtr->fTrackletCnt = ntracks0;
- tSize += sizeof(AliHLTTPCTrackletData);
+ tSize += sizeof(AliHLTTPCTrackletData);
- AliHLTComponentBlockData bd;
- FillBlockData( bd );
- bd.fOffset = 0;
- bd.fSize = tSize;
- bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, 0, 5 );
- outputBlocks.push_back( bd );
+ AliHLTComponentBlockData bd;
+ FillBlockData( bd );
+ bd.fOffset = 0;
+ bd.fSize = tSize;
+ bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, 0, 5 );
+ outputBlocks.push_back( bd );
+ }
- size = tSize;
- return 0;
- }
+ size = tSize;
+ return iResult;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff