#include "TMath.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
+#include "AliGeomManager.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "AliITStrackerHLT.h"
#include "AliHLTDataTypes.h"
#include "AliHLTExternalTrackParam.h"
#include "AliHLTGlobalBarrelTrack.h"
-
-
+#include "AliGeomManager.h"
+#include "AliHLTTrackMCLabel.h"
+#include <map>
/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp( AliHLTITSTrackerComponent )
AliHLTITSTrackerComponent::AliHLTITSTrackerComponent()
:
fSolenoidBz( 0 ),
- fFullTime( 0 ),
- fRecoTime( 0 ),
- fNEvents( 0 ),
+ fBenchmark("ITSTracker"),
fTracker(0)
{
// see header file for class documentation
:
AliHLTProcessor(),
fSolenoidBz( 0 ),
- fFullTime( 0 ),
- fRecoTime( 0 ),
- fNEvents( 0 ),
+ fBenchmark("ITSTracker"),
fTracker(0)
{
// see header file for class documentation
// see header file for class documentation
list.clear();
list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
+ list.push_back( kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC );
list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD );
list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD );
+ list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITS );
}
AliHLTComponentDataType AliHLTITSTrackerComponent::GetOutputDataType()
{
// see header file for class documentation
- return kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
+ 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);
+ tgtList.push_back( kAliHLTDataTypeTrackMC|kAliHLTDataOriginITS );
+ 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.;
- fFullTime = 0;
- fRecoTime = 0;
- fNEvents = 0;
+ fSolenoidBz = -5.00668;
+
}
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;
}
//* 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(0);
+ 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);
+ fBenchmark.Reset();
+ fBenchmark.SetTimer(0,"total");
+ fBenchmark.SetTimer(1,"reco");
+ return ret;
}
AliHLTUInt32_t maxBufferSize = size;
size = 0; // output size
-
+
if (!IsDataEvent()) return 0;
if ( evtData.fBlockCnt <= 0 ) {
return 0;
}
-
- TStopwatch timer;
+ fBenchmark.StartNewEvent();
+ fBenchmark.Start(0);
// Event reconstruction in ITS
vector< AliExternalTrackParam > tracksTPC;
+ vector< int > tracksTPCLab;
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) ) ||
+ (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITS) )
+ ){
+ AliHLTITSClusterData *inPtr=reinterpret_cast<AliHLTITSClusterData*>( iter->fPtr );
+ nClustersTotal+=inPtr->fSpacePointCnt;
+ }
+ }
+
+
+ fTracker->StartLoadClusters(nClustersTotal);
+
+ // first read MC information (if present)
+
+ std::map<int,int> mcLabels;
+
+ for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC);
+ pBlock!=NULL; pBlock=GetNextInputBlock()) {
+
+ fBenchmark.AddInput(pBlock->fSize);
+
+ AliHLTTrackMCData* dataPtr = reinterpret_cast<AliHLTTrackMCData*>( pBlock->fPtr );
+ if (sizeof(AliHLTTrackMCData)+dataPtr->fCount*sizeof(AliHLTTrackMCLabel)==pBlock->fSize) {
+ for( unsigned int il=0; il<dataPtr->fCount; il++ ){
+ AliHLTTrackMCLabel &lab = dataPtr->fLabels[il];
+ mcLabels[lab.fTrackID] = lab.fMCLabel;
+ }
+ } else {
+ HLTWarning("data mismatch in block %s (0x%08x): count %d, size %d -> ignoring track MC information",
+ DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification,
+ dataPtr->fCount, pBlock->fSize);
+ }
+ }
+
+
+
+ for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
+
+ const AliHLTComponentBlockData* iter = blocks+ndx;
+
// Read TPC tracks
if( iter->fDataType == ( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC ) ){
+ fBenchmark.AddInput(iter->fSize);
AliHLTTracksData* dataPtr = ( AliHLTTracksData* ) iter->fPtr;
int nTracks = dataPtr->fCount;
AliHLTExternalTrackParam* currOutTrack = dataPtr->fTracklets;
for( int itr=0; itr<nTracks; itr++ ){
AliHLTGlobalBarrelTrack t(*currOutTrack);
+ Int_t mcLabel = -1;
+ if( mcLabels.find(currOutTrack->fTrackID)!=mcLabels.end() )
+ mcLabel = mcLabels[currOutTrack->fTrackID];
+
tracksTPC.push_back( t );
+ tracksTPCLab.push_back(mcLabel);
tracksTPCId.push_back( currOutTrack->fTrackID );
unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + currOutTrack->fNPoints * sizeof( unsigned int );
currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
if ( (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD) ) ||
(iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ) ||
- (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD) )
+ (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD) ) ||
+ (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITS) )
){
+
+ fBenchmark.AddInput(iter->fSize);
AliHLTITSClusterData *inPtr=reinterpret_cast<AliHLTITSClusterData*>( iter->fPtr );
int nClusters = inPtr->fSpacePointCnt;
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];
-
- AliITSRecPoint p( lab, hit, info );
- clusters.push_back( p );
+ fTracker->LoadCluster( AliITSRecPoint( lab, hit, info ) );
+ //cout<<"SG "<<d.fLayer<<" "<<d.fTracks[0]<<endl;
}
}
}// end read input blocks
- // set clusters to tracker
-
-
- fTracker->LoadClusters( clusters );
- //timer.Stop();
// Reconstruct the event
- TStopwatch timerReco;
-
- fTracker->Reconstruct( tracksTPC );
+ fBenchmark.Start(1);
+ fTracker->Reconstruct( &(tracksTPC[0]), &(tracksTPCLab[0]), tracksTPC.size() );
+ fBenchmark.Stop(1);
- timerReco.Stop();
// Fill output tracks
int nITSUpdated = 0;
{
- unsigned int mySize = 0;
-
- AliHLTTracksData* outPtr = ( AliHLTTracksData* )( outputPtr );
+
+ for( int iOut=0; iOut<=1; iOut++ ){
- AliHLTExternalTrackParam* currOutTrack = outPtr->fTracklets;
+ unsigned int blockSize = 0;
- mySize = ( ( AliHLTUInt8_t * )currOutTrack ) - ( ( AliHLTUInt8_t * )outputPtr );
+ AliHLTTracksData* outPtr = ( AliHLTTracksData* )( outputPtr + size );
+ AliHLTExternalTrackParam* currOutTrack = outPtr->fTracklets;
- outPtr->fCount = 0;
-
- int nTracks = fTracker->Tracks().size();
+ blockSize = ( ( AliHLTUInt8_t * )currOutTrack ) - ( ( AliHLTUInt8_t * )outPtr );
- for ( int itr = 0; itr < nTracks; itr++ ) {
+ 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;
+ }
- const AliExternalTrackParam &tp = fTracker->Tracks()[itr];
- int id = tracksTPCId[fTracker->Tracks()[itr].TPCtrackId()];
+ 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();
+ }
- int nClusters = 0;
- if( fTracker->Tracks()[itr].GetNumberOfClusters()>0 ) nITSUpdated++;
-
- unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + nClusters * sizeof( unsigned int );
-
- if ( mySize + dSize > maxBufferSize ) {
- HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, mySize, nTracks - itr + 1 );
- iResult = -ENOSPC;
- break;
+ 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++;
}
+
- currOutTrack->fAlpha = tp.GetAlpha();
- currOutTrack->fX = tp.GetX();
- currOutTrack->fY = tp.GetY();
- currOutTrack->fZ = tp.GetZ();
- currOutTrack->fLastX = 0;
- currOutTrack->fLastY = 0;
- currOutTrack->fLastZ = 0;
- currOutTrack->fq1Pt = tp.GetSigned1Pt();
- currOutTrack->fSinPsi = tp.GetSnp();
- currOutTrack->fTgl = tp.GetTgl();
- for( int i=0; i<15; i++ ) currOutTrack->fC[i] = tp.GetCovariance()[i];
- currOutTrack->fTrackID = id;
- currOutTrack->fFlags = 0;
- currOutTrack->fNPoints = nClusters;
- currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
- mySize += dSize;
- outPtr->fCount++;
+ AliHLTComponentBlockData resultData;
+ FillBlockData( resultData );
+ resultData.fOffset = size;
+ resultData.fSize = blockSize;
+ if( iOut==0 ){
+ resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
+ } else {
+ resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut;
+ }
+ fBenchmark.AddOutput(resultData.fSize);
+ outputBlocks.push_back( resultData );
+ size += resultData.fSize;
}
-
+ }
+
+ {// fill MC labels
+ unsigned int blockSize = 0;
+
+ AliHLTTrackMCData* outPtr = ( AliHLTTrackMCData* )( outputPtr +size );
+ AliHLTTrackMCLabel* currOutLabel = outPtr->fLabels;
+
+ blockSize = ( ( AliHLTUInt8_t * )currOutLabel ) - ( ( AliHLTUInt8_t * )outPtr );
+
+ outPtr->fCount = 0;
+
+ AliHLTITSTrack *tracks= fTracker->Tracks();
+ int nTracks = fTracker->NTracks();
+
+ for ( int itr = 0; itr < nTracks; itr++ ) {
+ AliHLTITSTrack &t = tracks[itr];
+ //cout<<"SG out:"<<tracksTPCId[t.TPCtrackId()]<<" "<<t.GetLabel()<<endl;
+ if( t.GetLabel()<0 ) continue;
+ int id = tracksTPCId[t.TPCtrackId()];
+
+ if ( blockSize + sizeof(AliHLTTrackMCLabel) > maxBufferSize ) {
+ HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d mc labels are not stored", maxBufferSize, blockSize, nTracks - itr + 1 );
+ iResult = -ENOSPC;
+ break;
+ }
+ currOutLabel->fTrackID = id;
+ currOutLabel->fMCLabel = t.GetLabel();
+ blockSize += sizeof(AliHLTTrackMCLabel);
+ currOutLabel++;
+ outPtr->fCount++;
+ }
+
AliHLTComponentBlockData resultData;
FillBlockData( resultData );
- resultData.fOffset = 0;
- resultData.fSize = mySize;
- resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
+ resultData.fOffset = size;
+ resultData.fSize = blockSize;
+ resultData.fDataType = kAliHLTDataTypeTrackMC|kAliHLTDataOriginITS;
outputBlocks.push_back( resultData );
- size = resultData.fSize;
-
+ size+= resultData.fSize;
}
-
- timer.Stop();
- fFullTime += timer.RealTime();
- fRecoTime += timerReco.RealTime();
- fNEvents++;
+
+ fBenchmark.Stop(0);
// 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, clusters.size(), tracksTPC.size(), hz, hz1 );
+ HLTInfo( "ITS Tracker: output %d tracks; input %d clusters, %d tracks",
+ nITSUpdated, nClustersTotal, tracksTPC.size() );
+ HLTInfo(fBenchmark.GetStatistics());
return iResult;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff