X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTPCLib%2FAliHLTTPCGlobalMergerComponent.cxx;h=db322e267f14524a2cfbc45871b61817ca4c0bb2;hb=0aff7a9935880c203a1ce16f1024f2f54e26e6bc;hp=a7e4212565419743dc217438dac7d48f47f80661;hpb=96bda103806b63d894a623f577c592424aed2c9e;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx b/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx index a7e42125654..db322e267f1 100644 --- a/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx +++ b/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx @@ -1,20 +1,21 @@ // $Id$ -/************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * - * * - * Authors: Matthias Richter * - * Timm Steinbeck * - * 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 * +//* Timm Steinbeck * +//* 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 @@ -22,10 +23,11 @@ @brief HLT TPC global merger component. */ -#if __GNUC__== 3 +#if __GNUC__>= 3 using namespace std; #endif +#include #include "AliHLTTPCGlobalMergerComponent.h" #include "AliHLTTPCTransform.h" #include "AliHLTTPCGlobalMerger.h" @@ -34,16 +36,14 @@ using namespace std; #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 -#include +#include +#include -// 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() : @@ -57,22 +57,6 @@ 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 @@ -82,216 +66,254 @@ AliHLTTPCGlobalMergerComponent::~AliHLTTPCGlobalMergerComponent() // 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& 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& 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 slices; - std::vector::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 slices; + std::vector::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; +}