[u/mrichter/AliRoot.git] / HLT / ITS / tracking / AliHLTITSTrackerComponent.cxx

// @(#) $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.                           *
//                                                                          *
// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
//                  Ivan Kisel <kisel@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.                    *
//                                                                          *
//***************************************************************************


/////////////////////////////////////////////////////
//                                                 //
// a ITS tracker processing component for the HLT  //
//                                                 //
/////////////////////////////////////////////////////

#if __GNUC__>= 3
using namespace std;
#endif

#include "AliHLTITSTrackerComponent.h"
#include "AliHLTArray.h"
#include "AliExternalTrackParam.h"
#include "TStopwatch.h"
#include "TMath.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.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"


/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp( AliHLTITSTrackerComponent )
AliHLTITSTrackerComponent::AliHLTITSTrackerComponent()
    :
    fSolenoidBz( 0 ),
    fFullTime( 0 ),
    fRecoTime( 0 ),
    fNEvents( 0 ),
    fTracker(0)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTITSTrackerComponent::AliHLTITSTrackerComponent( const AliHLTITSTrackerComponent& )
    :
    AliHLTProcessor(),
    fSolenoidBz( 0 ),
    fFullTime( 0 ),
    fRecoTime( 0 ),
    fNEvents( 0 ),
    fTracker(0)
{
  // see header file for class documentation
  HLTFatal( "copy constructor untested" );
}

AliHLTITSTrackerComponent& AliHLTITSTrackerComponent::operator=( const AliHLTITSTrackerComponent& )
{
  // see header file for class documentation
  HLTFatal( "assignment operator untested" );
  return *this;
}

AliHLTITSTrackerComponent::~AliHLTITSTrackerComponent()
{
  // see header file for class documentation
  delete fTracker;
}

//
// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process
//

const char* AliHLTITSTrackerComponent::GetComponentID()
{
  // see header file for class documentation
  return "ITSTracker";
}

void AliHLTITSTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list )
{
  // see header file for class documentation
  list.clear();
  list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
  list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
  list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD );
}

AliHLTComponentDataType AliHLTITSTrackerComponent::GetOutputDataType()
{
  // see header file for class documentation  
  return fgkITSTracksDataType;
}

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
}

AliHLTComponent* AliHLTITSTrackerComponent::Spawn()
{
  // see header file for class documentation
  return new AliHLTITSTrackerComponent;
}

void AliHLTITSTrackerComponent::SetDefaultConfiguration()
{
  // 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;
  fTracker = 0;
}

int AliHLTITSTrackerComponent::ReadConfigurationString(  const char* arguments )
{
  // Set configuration parameters for the CA tracker component from the string

  int iResult = 0;
  if ( !arguments ) return iResult;

  TString allArgs = arguments;
  TString argument;
  int bMissingParam = 0;

  TObjArray* pTokens = allArgs.Tokenize( " " );

  int nArgs =  pTokens ? pTokens->GetEntries() : 0;

  for ( int i = 0; i < nArgs; i++ ) {
    argument = ( ( TObjString* )pTokens->At( i ) )->GetString();
    if ( argument.IsNull() ) continue;

    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 );
      continue;
    }

    //if ( argument.CompareTo( "-minNClustersOnTrack" ) == 0 ) {
    //if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
    //fMinNTrackClusters = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
    //HLTInfo( "minNClustersOnTrack set to: %d", fMinNTrackClusters );
    //continue;
    //}

    HLTError( "Unknown option \"%s\"", argument.Data() );
    iResult = -EINVAL;
  }
  delete pTokens;

  if ( bMissingParam ) {
    HLTError( "Specifier missed for parameter \"%s\"", argument.Data() );
    iResult = -EINVAL;
  }

  return iResult;
}


int AliHLTITSTrackerComponent::ReadCDBEntry( const char* cdbEntry, const char* chainId )
{
  // see header file for class documentation

  const char* defaultNotify = "";

  if ( !cdbEntry ) {
    cdbEntry = "HLT/ConfigITS/ITSTracker";
    defaultNotify = " (default)";
    chainId = 0;
  }

  HLTInfo( "configure from entry \"%s\"%s, chain id %s", cdbEntry, defaultNotify, ( chainId != NULL && chainId[0] != 0 ) ? chainId : "<none>" );
  AliCDBEntry *pEntry = AliCDBManager::Instance()->Get( cdbEntry );//,GetRunNo());

  if ( !pEntry ) {
    HLTError( "cannot fetch object \"%s\" from CDB", cdbEntry );
    return -EINVAL;
  }

  TObjString* pString = dynamic_cast<TObjString*>( pEntry->GetObject() );

  if ( !pString ) {
    HLTError( "configuration object \"%s\" has wrong type, required TObjString", cdbEntry );
    return -EINVAL;
  }

  HLTInfo( "received configuration object string: \"%s\"", pString->GetString().Data() );

  return  ReadConfigurationString( pString->GetString().Data() );
}


int AliHLTITSTrackerComponent::Configure( const char* cdbEntry, const char* chainId, const char *commandLine )
{
  // Configure the component
  // There are few levels of configuration,
  // parameters which are set on one step can be overwritten on the next step

  //* read hard-coded values

  SetDefaultConfiguration();

  //* read the default CDB entry

  int iResult1 = ReadCDBEntry( NULL, chainId );

  //* read magnetic field

  int iResult2 = ReadCDBEntry( kAliHLTCDBSolenoidBz, chainId );

  //* read the actual CDB entry if required

  int iResult3 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0;

  //* read extra parameters from input (if they are)

  int iResult4 = 0;

  if ( commandLine && commandLine[0] != '\0' ) {
    HLTInfo( "received configuration string from HLT framework: \"%s\"", commandLine );
    iResult4 = ReadConfigurationString( commandLine );
  }

  // Initialise the tracker here

  return iResult1 ? iResult1 : ( iResult2 ? iResult2 : ( iResult3 ? iResult3 : iResult4 ) );
}


int AliHLTITSTrackerComponent::DoInit( int argc, const char** argv )
{
  // Configure the ITS tracker component

  if ( fTracker ) return EINPROGRESS;
  fTracker = new AliITStrackerHLT();

  TString arguments = "";
  for ( int i = 0; i < argc; i++ ) {
    if ( !arguments.IsNull() ) arguments += " ";
    arguments += argv[i];
  }

  return Configure( NULL, NULL, arguments.Data() );
}


int AliHLTITSTrackerComponent::DoDeinit()
{
  // see header file for class documentation
  delete fTracker;
  fTracker = 0;
  return 0;
}


int AliHLTITSTrackerComponent::Reconfigure( const char* cdbEntry, const char* chainId )
{
  // Reconfigure the component from OCDB .

  return Configure( cdbEntry, chainId, NULL );
}


int AliHLTITSTrackerComponent::DoEvent
(
  const AliHLTComponentEventData& evtData,
  const AliHLTComponentBlockData* blocks,
  AliHLTComponentTriggerData& /*trigData*/,
  AliHLTUInt8_t* outputPtr,
  AliHLTUInt32_t& size,
  vector<AliHLTComponentBlockData>& outputBlocks )
{
  //* process event

  AliHLTUInt32_t maxBufferSize = size;
  size = 0; // output size

  if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) ) {
    return 0;
  }

  if ( evtData.fBlockCnt <= 0 ) {
    HLTWarning( "no blocks in event" );
    return 0;
  }


  TStopwatch timer;

  // Event reconstruction in ITS

  int iResult=0;

  int nBlocks = evtData.fBlockCnt;

  
  vector< AliExternalTrackParam > tracksTPC;
  vector< int > tracksTPCId;
  std::vector<AliITSRecPoint> clusters;

  int currentTrackID = 0;

  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++);    
      }
    }

    // Read ITS clusters

    if ( (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD) ) || 
	 (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ) 
	 ){

      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 );
      }   
    }
    
  }// end read input blocks
  
  // set clusters to tracker

  fTracker->LoadClusters( clusters );

  // Reconstruct the event

  TStopwatch timerReco;
  
  fTracker->Reconstruct( tracksTPC );

  timerReco.Stop();
  
  // Fill output tracks

  {
    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++;
      }
    }

    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;

    HLTInfo( "ITS tracker:: output %d tracks",nTracks );
  }
  return iResult;
}
Commit	Line	Data
6edb0fb5	1	// @(#) $Id: AliHLTITSTrackerComponent.cxx 32659 2009-06-02 16:08:40Z sgorbuno $
	2	// **************************************************************************
	3	// This file is property of and copyright by the ALICE HLT Project *
	4	// ALICE Experiment at CERN, All rights reserved. *
	5	// *
	6	// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
	7	// Ivan Kisel <kisel@kip.uni-heidelberg.de> *
	8	// for The ALICE HLT Project. *
	9	// *
	10	// Permission to use, copy, modify and distribute this software and its *
	11	// documentation strictly for non-commercial purposes is hereby granted *
	12	// without fee, provided that the above copyright notice appears in all *
	13	// copies and that both the copyright notice and this permission notice *
	14	// appear in the supporting documentation. The authors make no claims *
	15	// about the suitability of this software for any purpose. It is *
	16	// provided "as is" without express or implied warranty. *
	17	// *
	18	//***************************************************************************
	19
	20
	21	/////////////////////////////////////////////////////
	22	// //
	23	// a ITS tracker processing component for the HLT //
	24	// //
	25	/////////////////////////////////////////////////////
	26
	27	#if __GNUC__>= 3
	28	using namespace std;
	29	#endif
	30
	31	#include "AliHLTITSTrackerComponent.h"
	32	#include "AliHLTArray.h"
	33	#include "AliExternalTrackParam.h"
	34	#include "TStopwatch.h"
	35	#include "TMath.h"
	36	#include "AliCDBEntry.h"
	37	#include "AliCDBManager.h"
	38	#include "TObjString.h"
	39	#include "TObjArray.h"
	40	#include "AliHLTTPCDefinitions.h"
	41	#include "AliITStrackerHLT.h"
	42	#include "AliHLTITSTrackDataHeader.h"
	43	#include "AliHLTTPCDefinitions.h"
	44	#include "AliHLTTPCTrackArray.h"
	45	#include "AliHLTTPCTrackletDataFormat.h"
	46	#include "AliHLTTPCTrack.h"
	47	#include "AliHLTITSSpacePointData.h"
	48	#include "AliHLTITSClusterDataFormat.h"
	49	#include "AliHLTDataTypes.h"
	50
	51
	52
	53	/** ROOT macro for the implementation of ROOT specific class methods */
	54	ClassImp( AliHLTITSTrackerComponent )
	55	AliHLTITSTrackerComponent::AliHLTITSTrackerComponent()
	56	:
	57	fSolenoidBz( 0 ),
	58	fFullTime( 0 ),
	59	fRecoTime( 0 ),
	60	fNEvents( 0 ),
	61	fTracker(0)
	62	{
	63	// see header file for class documentation
	64	// or
65	// refer to README to build package
66	// or
67	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
68	}
69
70	AliHLTITSTrackerComponent::AliHLTITSTrackerComponent( const AliHLTITSTrackerComponent& )
71	:
72	AliHLTProcessor(),
73	fSolenoidBz( 0 ),
74	fFullTime( 0 ),
75	fRecoTime( 0 ),
76	fNEvents( 0 ),
77	fTracker(0)
78	{
79	// see header file for class documentation
80	HLTFatal( "copy constructor untested" );
81	}
82
83	AliHLTITSTrackerComponent& AliHLTITSTrackerComponent::operator=( const AliHLTITSTrackerComponent& )
84	{
85	// see header file for class documentation
86	HLTFatal( "assignment operator untested" );
87	return *this;
88	}
89
90	AliHLTITSTrackerComponent::~AliHLTITSTrackerComponent()
91	{
92	// see header file for class documentation
93	delete fTracker;
94	}
95
96	//
97	// Public functions to implement AliHLTComponent's interface.
98	// These functions are required for the registration process
99	//
100
101	const char* AliHLTITSTrackerComponent::GetComponentID()
102	{
103	// see header file for class documentation
104	return "ITSTracker";
105	}
106
107	void AliHLTITSTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list )
108	{
109	// see header file for class documentation
110	list.clear();
111	list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
112	list.push_back( kAliHLTDataTypeClusters\|kAliHLTDataOriginITSSSD );
113	list.push_back( kAliHLTDataTypeClusters\|kAliHLTDataOriginITSSPD );
114	}
115
116	AliHLTComponentDataType AliHLTITSTrackerComponent::GetOutputDataType()
117	{
118	// see header file for class documentation
119	return fgkITSTracksDataType;
120	}
121
122	void AliHLTITSTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
123	{
124	// define guess for the output data size
125	constBase = 200; // minimum size
126	inputMultiplier = 0.5; // size relative to input
127	}
128
129	AliHLTComponent* AliHLTITSTrackerComponent::Spawn()
130	{
131	// see header file for class documentation
132	return new AliHLTITSTrackerComponent;
133	}
134
135	void AliHLTITSTrackerComponent::SetDefaultConfiguration()
136	{
137	// Set default configuration for the CA tracker component
138	// Some parameters can be later overwritten from the OCDB
139
140	fSolenoidBz = 5.;
141	fFullTime = 0;
142	fRecoTime = 0;
143	fNEvents = 0;
144	fTracker = 0;
145	}
146
147	int AliHLTITSTrackerComponent::ReadConfigurationString( const char* arguments )
148	{
149	// Set configuration parameters for the CA tracker component from the string
150
151	int iResult = 0;
152	if ( !arguments ) return iResult;
153
154	TString allArgs = arguments;
155	TString argument;
156	int bMissingParam = 0;
157
158	TObjArray* pTokens = allArgs.Tokenize( " " );
159
160	int nArgs = pTokens ? pTokens->GetEntries() : 0;
161
162	for ( int i = 0; i < nArgs; i++ ) {
163	argument = ( ( TObjString* )pTokens->At( i ) )->GetString();
164	if ( argument.IsNull() ) continue;
165
166	if ( argument.CompareTo( "-solenoidBz" ) == 0 ) {
167	if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
168	fSolenoidBz = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
169	HLTInfo( "Magnetic Field set to: %f", fSolenoidBz );
170	continue;
171	}
172
173	//if ( argument.CompareTo( "-minNClustersOnTrack" ) == 0 ) {
174	//if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
175	//fMinNTrackClusters = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
176	//HLTInfo( "minNClustersOnTrack set to: %d", fMinNTrackClusters );
177	//continue;
178	//}
179
180	HLTError( "Unknown option \"%s\"", argument.Data() );
181	iResult = -EINVAL;
182	}
183	delete pTokens;
184
185	if ( bMissingParam ) {
186	HLTError( "Specifier missed for parameter \"%s\"", argument.Data() );
187	iResult = -EINVAL;
188	}
189
190	return iResult;
191	}
192
193
194	int AliHLTITSTrackerComponent::ReadCDBEntry( const char* cdbEntry, const char* chainId )
195	{
196	// see header file for class documentation
197
198	const char* defaultNotify = "";
199
200	if ( !cdbEntry ) {
201	cdbEntry = "HLT/ConfigITS/ITSTracker";
202	defaultNotify = " (default)";
203	chainId = 0;
204	}
205
206	HLTInfo( "configure from entry \"%s\"%s, chain id %s", cdbEntry, defaultNotify, ( chainId != NULL && chainId[0] != 0 ) ? chainId : "<none>" );
207	AliCDBEntry *pEntry = AliCDBManager::Instance()->Get( cdbEntry );//,GetRunNo());
208
209	if ( !pEntry ) {
210	HLTError( "cannot fetch object \"%s\" from CDB", cdbEntry );
211	return -EINVAL;
212	}
213
214	TObjString* pString = dynamic_cast<TObjString*>( pEntry->GetObject() );
215
216	if ( !pString ) {
217	HLTError( "configuration object \"%s\" has wrong type, required TObjString", cdbEntry );
218	return -EINVAL;
219	}
220
221	HLTInfo( "received configuration object string: \"%s\"", pString->GetString().Data() );
222
223	return ReadConfigurationString( pString->GetString().Data() );
224	}
225
226
227	int AliHLTITSTrackerComponent::Configure( const char* cdbEntry, const char* chainId, const char *commandLine )
228	{
229	// Configure the component
230	// There are few levels of configuration,
231	// parameters which are set on one step can be overwritten on the next step
232
233	//* read hard-coded values
234
235	SetDefaultConfiguration();
236
237	//* read the default CDB entry
238
239	int iResult1 = ReadCDBEntry( NULL, chainId );
240
241	//* read magnetic field
242
243	int iResult2 = ReadCDBEntry( kAliHLTCDBSolenoidBz, chainId );
244
245	//* read the actual CDB entry if required
246
247	int iResult3 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0;
248
249	//* read extra parameters from input (if they are)
250
251	int iResult4 = 0;
252
253	if ( commandLine && commandLine[0] != '\0' ) {
254	HLTInfo( "received configuration string from HLT framework: \"%s\"", commandLine );
255	iResult4 = ReadConfigurationString( commandLine );
256	}
257
258	// Initialise the tracker here
259
260	return iResult1 ? iResult1 : ( iResult2 ? iResult2 : ( iResult3 ? iResult3 : iResult4 ) );
261	}
262
263
264
265	int AliHLTITSTrackerComponent::DoInit( int argc, const char** argv )
266	{
267	// Configure the ITS tracker component
268
269	if ( fTracker ) return EINPROGRESS;
270	fTracker = new AliITStrackerHLT();
271
272	TString arguments = "";
273	for ( int i = 0; i < argc; i++ ) {
274	if ( !arguments.IsNull() ) arguments += " ";
275	arguments += argv[i];
276	}
277
278	return Configure( NULL, NULL, arguments.Data() );
279	}
280
281
282	int AliHLTITSTrackerComponent::DoDeinit()
283	{
284	// see header file for class documentation
285	delete fTracker;
286	fTracker = 0;
287	return 0;
288	}
289
290
291
292	int AliHLTITSTrackerComponent::Reconfigure( const char* cdbEntry, const char* chainId )
293	{
294	// Reconfigure the component from OCDB .
295
296	return Configure( cdbEntry, chainId, NULL );
297	}
298
299
300
301	int AliHLTITSTrackerComponent::DoEvent
302	(
303	const AliHLTComponentEventData& evtData,
304	const AliHLTComponentBlockData* blocks,
305	AliHLTComponentTriggerData& /trigData/,
306	AliHLTUInt8_t* outputPtr,
307	AliHLTUInt32_t& size,
308	vector<AliHLTComponentBlockData>& outputBlocks )
309	{
310	//* process event
311
312	AliHLTUInt32_t maxBufferSize = size;
313	size = 0; // output size
314
315	if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) \|\| GetFirstInputBlock( kAliHLTDataTypeEOR ) ) {
316	return 0;
317	}
318
319	if ( evtData.fBlockCnt <= 0 ) {
320	HLTWarning( "no blocks in event" );
321	return 0;
322	}
323
324
325	TStopwatch timer;
326
327	// Event reconstruction in ITS
328
329	int iResult=0;
330
331	int nBlocks = evtData.fBlockCnt;
332
333
334	vector< AliExternalTrackParam > tracksTPC;
335	vector< int > tracksTPCId;
336	std::vector<AliITSRecPoint> clusters;
337
338	int currentTrackID = 0;
339
340	for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
341
342	const AliHLTComponentBlockData* iter = blocks+ndx;
343
344	// Read TPC tracks
345
346	if ( iter->fDataType == AliHLTTPCDefinitions::fgkTracksDataType ){
347	AliHLTTPCTrackArray tracks;
348	AliHLTTPCTrackletData inPtr=(AliHLTTPCTrackletData)iter->fPtr;
349	iResult=tracks.FillTracksChecked( inPtr->fTracklets, inPtr->fTrackletCnt, iter->fSize, -1, 0 );
350	if ( iResult < 0 ){
351	HLTError("internal mismatch in array");
352	iResult=-EFAULT;
353	break;
354	}
355	for (int i=0; i<tracks.GetNTracks(); i++) {
356	AliHLTTPCTrack* pTrack = tracks[i];
357	if( !pTrack ) continue;
358	if( pTrack->Convert2AliKalmanTrack() ){
359	//HLTError("conversion to AliKalmanTrack failed for track %d of %d", i, pTracks->GetNTracks());
360	continue;
361	}
362	tracksTPC.push_back( *pTrack );
363	tracksTPCId.push_back(currentTrackID++);
364	}
365	}
366
367	// Read ITS clusters
368
369	if ( (iter->fDataType == (kAliHLTDataTypeClusters\|kAliHLTDataOriginITSSSD) ) \|\|
370	(iter->fDataType == (kAliHLTDataTypeClusters\|kAliHLTDataOriginITSSPD) )
371	){
372
373	AliHLTITSClusterData inPtr=reinterpret_cast<AliHLTITSClusterData>( iter->fPtr );
374	int nClusters = inPtr->fSpacePointCnt;
375	for( int icl=0; icl<nClusters; icl++ ){
376	AliHLTITSSpacePointData &d = inPtr->fSpacePoints[icl];
377	AliITSRecPoint p;
378	p.SetY( d.fY );
379	p.SetZ( d.fZ );
380	p.SetSigmaY2( d.fSigmaY2 );
381	p.SetSigmaZ2( d.fSigmaZ2 );
382	p.SetSigmaYZ( d.fSigmaYZ );
383	p.SetQ( d.fQ );
384	p.SetNy( d.fNy );
385	p.SetNz( d.fNz );
386	p.SetLayer( d.fLayer );
387	p.SetDetectorIndex( d.fIndex );
388	p.SetLabel(0, d.fTracks[0] );
389	p.SetLabel(1, d.fTracks[1] );
390	p.SetLabel(2, d.fTracks[2] );
391	clusters.push_back( p );
392	}
393	}
394
395	}// end read input blocks
396
397	// set clusters to tracker
398
399	fTracker->LoadClusters( clusters );
400
401	// Reconstruct the event
402
403	TStopwatch timerReco;
404
405	fTracker->Reconstruct( tracksTPC );
406
407	timerReco.Stop();
408
409	// Fill output tracks
410
411	{
412	unsigned int mySize = 0;
413
414	// check if there was enough space in the output buffer
415
416	int nTracks = fTracker->Tracks().size();
417	mySize = sizeof( AliHLTITSTrackDataHeader ) + nTracks*sizeof( AliHLTITSTrackData );
418	if ( mySize > maxBufferSize ) {
419	mySize = 0;
420	iResult = -ENOSPC;
421	nTracks=0;
422	} else {
423	AliHLTITSTrackDataHeader outPtr = ( AliHLTITSTrackDataHeader )( outputPtr );
424	outPtr->fTrackletCnt = nTracks;
425	AliHLTITSTrackData *tr = outPtr->fTracks;
426	for( int itr=0; itr<nTracks; itr++ ){
427	tr->fTrackParam = fTracker->Tracks()[itr];
428	tr->fTPCId = tracksTPCId[fTracker->Tracks()[itr].TPCtrackId()];
429	tr->fClusterIds[0] = 0;
430	tr->fClusterIds[1] = 0;
431	tr->fClusterIds[2] = 0;
432	tr->fClusterIds[3] = 0;
433	tr->fClusterIds[4] = 0;
434	tr->fClusterIds[5] = 0;
435	tr++;
436	}
437	}
438
439	AliHLTComponentBlockData resultData;
440	FillBlockData( resultData );
441	resultData.fOffset = 0;
442	resultData.fSize = mySize;
443	resultData.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( 0, 35, 0, 5 );
444	outputBlocks.push_back( resultData );
445	size = resultData.fSize;
446
447	HLTInfo( "ITS tracker:: output %d tracks",nTracks );
448	}
449	return iResult;
450	}