-// @(#) $Id: AliHLTITSTrackerComponent.cxx 32659 2009-06-02 16:08:40Z sgorbuno $
+// $Id: AliHLTITSTrackerComponent.cxx 32659 2009-06-02 16:08:40Z sgorbuno $
// **************************************************************************
// This file is property of and copyright by the ALICE HLT Project *
// ALICE Experiment at CERN, All rights reserved. *
// *
//***************************************************************************
+/// @file AliHLTITSTrackerComponent.cxx
+/// @author Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de>
+/// @date June 2009
+/// @brief An ITS tracker processing component for the HLT
+
/////////////////////////////////////////////////////
// //
#include "TMath.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
+#include "AliGeomManager.h"
#include "TObjString.h"
#include "TObjArray.h"
-#include "AliHLTTPCDefinitions.h"
#include "AliITStrackerHLT.h"
-#include "AliHLTITSTrackDataHeader.h"
-#include "AliHLTTPCDefinitions.h"
-#include "AliHLTTPCTrackArray.h"
-#include "AliHLTTPCTrackletDataFormat.h"
-#include "AliHLTTPCTrack.h"
#include "AliHLTITSSpacePointData.h"
#include "AliHLTITSClusterDataFormat.h"
#include "AliHLTDataTypes.h"
+#include "AliHLTExternalTrackParam.h"
+#include "AliHLTGlobalBarrelTrack.h"
+#include "AliGeomManager.h"
{
// see header file for class documentation
list.clear();
- list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
+ list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD );
+ list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD );
}
AliHLTComponentDataType AliHLTITSTrackerComponent::GetOutputDataType()
{
// see header file for class documentation
- return fgkITSTracksDataType;
+ return kAliHLTMultipleDataType;
+}
+
+int AliHLTITSTrackerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
+{
+ // see header file for class documentation
+ tgtList.clear();
+ tgtList.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginITS);
+ tgtList.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut);
+ return tgtList.size();
}
void AliHLTITSTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
// define guess for the output data size
constBase = 200; // minimum size
- inputMultiplier = 0.5; // size relative to input
+ inputMultiplier = 2.; // size relative to input
}
AliHLTComponent* AliHLTITSTrackerComponent::Spawn()
// Set default configuration for the CA tracker component
// Some parameters can be later overwritten from the OCDB
- fSolenoidBz = 5.;
+ fSolenoidBz = -5.00668;
fFullTime = 0;
fRecoTime = 0;
fNEvents = 0;
- fTracker = 0;
}
int AliHLTITSTrackerComponent::ReadConfigurationString( const char* arguments )
if ( argument.CompareTo( "-solenoidBz" ) == 0 ) {
if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
- fSolenoidBz = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
- HLTInfo( "Magnetic Field set to: %f", fSolenoidBz );
+ HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz());
continue;
}
const char* defaultNotify = "";
if ( !cdbEntry ) {
+ return 0;// need to add the HLT/ConfigITS/ITSTracker directory to cdb SG!!!
cdbEntry = "HLT/ConfigITS/ITSTracker";
defaultNotify = " (default)";
chainId = 0;
//* read magnetic field
- int iResult2 = ReadCDBEntry( kAliHLTCDBSolenoidBz, chainId );
+ int iResult2 = 0; //ReadCDBEntry( kAliHLTCDBSolenoidBz, chainId );
+ fSolenoidBz = GetBz();
//* read the actual CDB entry if required
{
// Configure the ITS tracker component
- if ( fTracker ) return EINPROGRESS;
- fTracker = new AliITStrackerHLT();
+ if ( fTracker ) return -EINPROGRESS;
+
+ if(AliGeomManager::GetGeometry()==NULL){
+ AliGeomManager::LoadGeometry();
+ }
+ AliGeomManager::ApplyAlignObjsFromCDB("ITS");
TString arguments = "";
for ( int i = 0; i < argc; i++ ) {
arguments += argv[i];
}
- return Configure( NULL, NULL, arguments.Data() );
+ int ret = Configure( NULL, NULL, arguments.Data() );
+
+ // Check field
+ if (!TGeoGlobalMagField::Instance()) {
+ HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
+ return -ENODEV;
+ }
+ fSolenoidBz=GetBz();
+
+ fTracker = new AliITStrackerHLT(0);
+
+ return ret;
}
AliHLTUInt32_t maxBufferSize = size;
size = 0; // output size
-
- if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) ) {
- return 0;
- }
+
+ if (!IsDataEvent()) return 0;
if ( evtData.fBlockCnt <= 0 ) {
HLTWarning( "no blocks in event" );
vector< AliExternalTrackParam > tracksTPC;
vector< int > tracksTPCId;
- std::vector<AliITSRecPoint> clusters;
- int currentTrackID = 0;
+ int nClustersTotal = 0;
+
+ for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
+
+ const AliHLTComponentBlockData* iter = blocks+ndx;
+
+ if ( (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD) ) ||
+ (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ) ||
+ (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD) )
+ ){
+ AliHLTITSClusterData *inPtr=reinterpret_cast<AliHLTITSClusterData*>( iter->fPtr );
+ nClustersTotal+=inPtr->fSpacePointCnt;
+ }
+ }
+
+
+ fTracker->StartLoadClusters(nClustersTotal);
for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
const AliHLTComponentBlockData* iter = blocks+ndx;
// Read TPC tracks
-
- if ( iter->fDataType == AliHLTTPCDefinitions::fgkTracksDataType ){
- AliHLTTPCTrackArray tracks;
- AliHLTTPCTrackletData *inPtr=(AliHLTTPCTrackletData*)iter->fPtr;
- iResult=tracks.FillTracksChecked( inPtr->fTracklets, inPtr->fTrackletCnt, iter->fSize, -1, 0 );
- if ( iResult < 0 ){
- HLTError("internal mismatch in array");
- iResult=-EFAULT;
- break;
- }
- for (int i=0; i<tracks.GetNTracks(); i++) {
- AliHLTTPCTrack* pTrack = tracks[i];
- if( !pTrack ) continue;
- if( pTrack->Convert2AliKalmanTrack() ){
- //HLTError("conversion to AliKalmanTrack failed for track %d of %d", i, pTracks->GetNTracks());
- continue;
- }
- tracksTPC.push_back( *pTrack );
- tracksTPCId.push_back(currentTrackID++);
+
+ if( iter->fDataType == ( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC ) ){
+ AliHLTTracksData* dataPtr = ( AliHLTTracksData* ) iter->fPtr;
+ int nTracks = dataPtr->fCount;
+ AliHLTExternalTrackParam* currOutTrack = dataPtr->fTracklets;
+ for( int itr=0; itr<nTracks; itr++ ){
+ AliHLTGlobalBarrelTrack t(*currOutTrack);
+ tracksTPC.push_back( t );
+ tracksTPCId.push_back( currOutTrack->fTrackID );
+ unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + currOutTrack->fNPoints * sizeof( unsigned int );
+ currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
}
}
+
// Read ITS clusters
if ( (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD) ) ||
- (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) )
+ (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ) ||
+ (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD) )
){
AliHLTITSClusterData *inPtr=reinterpret_cast<AliHLTITSClusterData*>( iter->fPtr );
int nClusters = inPtr->fSpacePointCnt;
for( int icl=0; icl<nClusters; icl++ ){
AliHLTITSSpacePointData &d = inPtr->fSpacePoints[icl];
- AliITSRecPoint p;
- p.SetY( d.fY );
- p.SetZ( d.fZ );
- p.SetSigmaY2( d.fSigmaY2 );
- p.SetSigmaZ2( d.fSigmaZ2 );
- p.SetSigmaYZ( d.fSigmaYZ );
- p.SetQ( d.fQ );
- p.SetNy( d.fNy );
- p.SetNz( d.fNz );
- p.SetLayer( d.fLayer );
- p.SetDetectorIndex( d.fIndex );
- p.SetLabel(0, d.fTracks[0] );
- p.SetLabel(1, d.fTracks[1] );
- p.SetLabel(2, d.fTracks[2] );
- clusters.push_back( p );
+
+ Int_t lab[4] = { d.fTracks[0], d.fTracks[1], d.fTracks[2], d.fIndex };
+ Int_t info[3] = { d.fNy, d.fNz, d.fLayer };
+ Float_t hit[6] = { d.fY, d.fZ, d.fSigmaY2, d.fSigmaZ2, d.fQ, d.fSigmaYZ };
+ if( d.fLayer==4 ) hit[5] = -hit[5];
+ fTracker->LoadCluster( AliITSRecPoint( lab, hit, info ) );
}
}
}// end read input blocks
- // set clusters to tracker
-
- fTracker->LoadClusters( clusters );
-
// Reconstruct the event
TStopwatch timerReco;
- fTracker->Reconstruct( tracksTPC );
-
+ fTracker->Reconstruct( &(tracksTPC[0]), tracksTPC.size() );
+
timerReco.Stop();
// Fill output tracks
-
+ int nITSUpdated = 0;
{
- unsigned int mySize = 0;
-
- // check if there was enough space in the output buffer
- int nTracks = fTracker->Tracks().size();
- mySize = sizeof( AliHLTITSTrackDataHeader ) + nTracks*sizeof( AliHLTITSTrackData );
- if ( mySize > maxBufferSize ) {
- mySize = 0;
- iResult = -ENOSPC;
- nTracks=0;
- } else {
- AliHLTITSTrackDataHeader *outPtr = ( AliHLTITSTrackDataHeader* )( outputPtr );
- outPtr->fTrackletCnt = nTracks;
- AliHLTITSTrackData *tr = outPtr->fTracks;
- for( int itr=0; itr<nTracks; itr++ ){
- tr->fTrackParam = fTracker->Tracks()[itr];
- tr->fTPCId = tracksTPCId[fTracker->Tracks()[itr].TPCtrackId()];
- tr->fClusterIds[0] = 0;
- tr->fClusterIds[1] = 0;
- tr->fClusterIds[2] = 0;
- tr->fClusterIds[3] = 0;
- tr->fClusterIds[4] = 0;
- tr->fClusterIds[5] = 0;
- tr++;
+ for( int iOut=0; iOut<=1; iOut++ ){
+
+ unsigned int blockSize = 0;
+
+ AliHLTTracksData* outPtr = ( AliHLTTracksData* )( outputPtr + size );
+ AliHLTExternalTrackParam* currOutTrack = outPtr->fTracklets;
+
+ blockSize = ( ( AliHLTUInt8_t * )currOutTrack ) - ( ( AliHLTUInt8_t * )outPtr );
+
+ if ( size + blockSize > maxBufferSize ) {
+ HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, size + blockSize );
+ iResult = -ENOSPC;
+ break;
}
- }
- AliHLTComponentBlockData resultData;
- FillBlockData( resultData );
- resultData.fOffset = 0;
- resultData.fSize = mySize;
- resultData.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( 0, 35, 0, 5 );
- outputBlocks.push_back( resultData );
- size = resultData.fSize;
+ outPtr->fCount = 0;
+ AliHLTITSTrack *tracks=0;
+ int nTracks = 0;
+ if( iOut==0 ){
+ tracks = fTracker->Tracks();
+ nTracks = fTracker->NTracks();
+ } else{
+ tracks = fTracker->ITSOutTracks();
+ nTracks = fTracker->NITSOutTracks();
+ }
+
+ for ( int itr = 0; itr < nTracks; itr++ ) {
+ AliHLTITSTrack &t = tracks[itr];
+ int id = tracksTPCId[t.TPCtrackId()];
+ int nClusters = t.GetNumberOfClusters();
+ if( iOut==0 && nClusters>0 ) nITSUpdated++;
+
+ unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + nClusters * sizeof( unsigned int );
+
+ if ( size + blockSize + dSize > maxBufferSize ) {
+ HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, size + blockSize + dSize, nTracks - itr + 1 );
+ iResult = -ENOSPC;
+ break;
+ }
+
+ currOutTrack->fAlpha = t.GetAlpha();
+ currOutTrack->fX = t.GetX();
+ currOutTrack->fY = t.GetY();
+ currOutTrack->fZ = t.GetZ();
+ currOutTrack->fLastX = 0;
+ currOutTrack->fLastY = 0;
+ currOutTrack->fLastZ = 0;
+ currOutTrack->fq1Pt = t.GetSigned1Pt();
+ currOutTrack->fSinPsi = t.GetSnp();
+ currOutTrack->fTgl = t.GetTgl();
+ for( int i=0; i<15; i++ ) currOutTrack->fC[i] = t.GetCovariance()[i];
+ currOutTrack->fTrackID = id;
+ currOutTrack->fFlags = 0;
+ currOutTrack->fNPoints = nClusters;
+ for ( int i = 0; i < nClusters; i++ ) currOutTrack->fPointIDs[i] = t.GetClusterIndex( i );
+ currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
+ blockSize += dSize;
+ outPtr->fCount++;
+ }
+
- HLTInfo( "ITS tracker:: output %d tracks",nTracks );
+ AliHLTComponentBlockData resultData;
+ FillBlockData( resultData );
+ resultData.fOffset = 0;
+ resultData.fSize = blockSize;
+ if( iOut==0 ){
+ resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
+ } else {
+ resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut;
+ }
+ outputBlocks.push_back( resultData );
+ size += resultData.fSize;
+ }
}
+
+ timer.Stop();
+ fFullTime += timer.RealTime();
+ fRecoTime += timerReco.RealTime();
+ fNEvents++;
+
+ // Set log level to "Warning" for on-line system monitoring
+ int hz = ( int ) ( fFullTime > 1.e-10 ? fNEvents / fFullTime : 100000 );
+ int hz1 = ( int ) ( fRecoTime > 1.e-10 ? fNEvents / fRecoTime : 100000 );
+ HLTInfo( "ITS Tracker: output %d tracks; input %d clusters, %d tracks; time: full %d / reco %d Hz",
+ nITSUpdated, nClustersTotal, tracksTPC.size(), hz, hz1 );
+
return iResult;
}