// $Id$
/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * This file is property of and copyright by the ALICE HLT Project *
+ * 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. *
+ * 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 *
@brief The TPC conformal mapping tracker component.
*/
+// see header file for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+
#if __GNUC__>= 3
using namespace std;
#endif
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCConfMapper.h"
#include "AliHLTTPCVertex.h"
-#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCVertexData.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCInterMerger.h"
#include "AliHLTTPCMemHandler.h"
+#include "AliHLTTPCDefinitions.h"
//#include "AliHLTTPC.h"
-#include <stdlib.h>
-#include <errno.h>
+//#include <stdlib.h>
+//#include <cerrno>
// this is a global object used for automatic component registration, do not use this
AliHLTTPCSliceTrackerComponent gAliHLTTPCSliceTrackerComponent;
+/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCSliceTrackerComponent)
AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
fDoPP(false),
fMultiplicity(4000),
fBField(0.4),
-// BEGINN ############################################## MODIFIY JMT
fnonvertextracking(kFALSE),
fmainvertextracking(kTRUE),
-// END ################################################# MODIFIY JMT
fpInterMerger(NULL)
{
// see header file for class documentation
fEta[1] = 1.1;
}
-AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent& src)
- :
- fTracker(NULL),
- fVertex(NULL),
- fDoNonVertex(false),
- fDoPP(false),
- fMultiplicity(4000),
- fBField(0.4),
-// BEGINN ############################################## MODIFIY JMT
- fnonvertextracking(kFALSE),
- fmainvertextracking(kTRUE),
-// END ################################################# MODIFIY JMT
- fpInterMerger(NULL)
-{
- // see header file for class documentation
- HLTFatal("copy constructor untested");
-}
-
-AliHLTTPCSliceTrackerComponent& AliHLTTPCSliceTrackerComponent::operator=(const AliHLTTPCSliceTrackerComponent& src)
-{
- // see header file for class documentation
- HLTFatal("assignment operator untested");
- return *this;
-}
-
AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
{
+ // see header file for class documentation
}
// Public functions to implement AliHLTComponent's interface.
const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
{
+ // see header file for class documentation
return "TPCSliceTracker";
}
-void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
+void AliHLTTPCSliceTrackerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
{
+ // see header file for class documentation
list.clear();
- list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
- list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
+ list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
}
AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
{
- return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
+ // see header file for class documentation
+ return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
}
void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
+ // see header file for class documentation
// XXX TODO: Find more realistic values.
constBase = 0;
inputMultiplier = 0.2;
AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
{
+ // see header file for class documentation
return new AliHLTTPCSliceTrackerComponent;
}
Double_t minPtFit, Double_t maxangle,
Double_t goodDist, Double_t hitChi2Cut,
Double_t goodHitChi2, Double_t trackChi2Cut,
- Int_t maxdist, Double_t maxphi,Double_t maxeta, bool vertexConstraints )
+ Int_t maxdist, Double_t maxphi,Double_t maxeta, bool /*vertexConstraints*/ )
{
+ // see header file for class documentation
//fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ??
//Set parameters input to the tracker
//If no arguments are given, default parameters will be used
fTracker->SetMaxDca(minPtFit);
// fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
-// BEGINN ############################################## MODIFIY JMT
-#if 1
Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
}
-#else
- fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexConstraints);
- fTracker->SetTrackletCuts(maxangle,goodDist,vertexConstraints);
- if( vertexConstraints )
- fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
- else
- fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
-#endif
-// END ################################################# MODIFIY JMT
-
//fTracker->SetParamDone(true);
/* Matthias 13.12.2006
* the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
void AliHLTTPCSliceTrackerComponent::SetTrackerParam( bool doPP, int multiplicity, double bField )
{
+ // see header file for class documentation
AliHLTTPCTransform::SetBField( bField );
Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField );
SetTrackerParam( 50, // phi_segments: Devide the space into phi_segments
100, // ets_segments: Devide the space into eta_segments
3, // trackletlength: Number of hits a tracklet has to have
- 10, // tracklength: Number of hits a track has to have
+ 50, // tracklength: Number of hits a track has to have
6, // rowscopetracklet: Search range of rows for a tracklet
6, // rowscopetrack: Search range of rows for a track
0, // min_pt_fit: Cut for moment fit, use:SetMaxDca(min_pt_fit)
int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
{
+ // see header file for class documentation
Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
if ( fTracker || fVertex )
continue;
}
-// BEGINN ############################################## MODIFIY JMT
if ( !strcmp( argv[i], "nonvertextracking" ) ){
- fnonvertextracking = kTRUE;
- i++;
- continue;
+ fnonvertextracking = kTRUE;
+ i++;
+ continue;
}
if ( !strcmp( argv[i], "mainvertextrackingoff" ) ){
- fmainvertextracking = kFALSE;
- i++;
- continue;
+ fmainvertextracking = kFALSE;
+ i++;
+ continue;
}
-
+
if ( !strcmp( argv[i], "etarange" ) ){
- if ( argc <= i+1 ){
- Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Missing Eta-range specifiers." );
- return ENOTSUP;
- }
- fEta[1] = strtod( argv[i+1], &cpErr );
- if ( *cpErr ){
- Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Cannot convert Eta-range specifier '%s'.", argv[i+1] );
- return EINVAL;
- }
-
- i += 2;
- continue;
+ if ( argc <= i+1 ){
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Missing Eta-range specifiers." );
+ return ENOTSUP;
+ }
+ fEta[1] = strtod( argv[i+1], &cpErr );
+ if ( *cpErr ){
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Cannot convert Eta-range specifier '%s'.", argv[i+1] );
+ return EINVAL;
+ }
+
+ i += 2;
+ continue;
}
-// END ################################################# MODIFIY JMT
Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
return EINVAL;
}
-// #### -B0-CHANGE-START == JMT
if (fBField == 0.){
- // parameter for B=0 T
- fDoPP = kTRUE;
- fnonvertextracking = kTRUE;
- fmainvertextracking = kFALSE;
+ // parameter for B=0 T
+ fDoPP = kTRUE;
+ fnonvertextracking = kTRUE;
+ fmainvertextracking = kFALSE;
}
-// #### -B0-CHANGE-END == JMT
-
+
if (bDoMerger)
fpInterMerger = new AliHLTTPCInterMerger();
int AliHLTTPCSliceTrackerComponent::DoDeinit()
{
+ // see header file for class documentation
if ( fTracker )
delete fTracker;
fTracker = NULL;
}
int AliHLTTPCSliceTrackerComponent::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
Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" );
if ( evtData.fBlockCnt<=0 )
{
{
iter = blocks+ndx;
+ if(iter->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType){
+ HLTDebug("Data block type is not of type AliHLTTPCDefinitions::fgkClustersDataType");
+ continue;
+ }
+
slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
found = false;
slIter = slices.begin();
else
*slCntIter++;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
{
inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
vertexIter = iter;
fVertex->Read( inPtrV );
vertexSlice = slice;
}
- if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
{
patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
if ( minPatch>patch )
for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
{
iter = blocks+ndx;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
{
inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
vertexIter = iter;
{
iter = blocks+ndx;
- if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
+ if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
{
patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
pIter = patchIndices.begin();
}
outPtr = (AliHLTTPCTrackletData*)(outBPtr);
-// BEGINN ############################################## MODIFIY JMT
-#if 1
- fTracker->SetPointers();
+
if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
- Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
- fTracker->MainVertexTrackingA();
- fTracker->MainVertexTrackingB();
- fTracker->FillTracks();
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
+ fTracker->MainVertexTrackingA();
+ fTracker->MainVertexTrackingB();
+ fTracker->FillTracks();
}
else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
- Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
- fTracker->MainVertexTrackingA();
- fTracker->MainVertexTrackingB();
- fTracker->FillTracks();
- Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
- fTracker->NonVertexTracking();
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
+ fTracker->MainVertexTrackingA();
+ fTracker->MainVertexTrackingB();
+ fTracker->FillTracks();
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
+ fTracker->NonVertexTracking();
}
else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
- Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
- fTracker->NonVertexTracking();
- fTracker->FillTracks();
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
+ fTracker->NonVertexTracking();
+ fTracker->FillTracks();
}
-#else
- fTracker->MainVertexTracking_a();
- fTracker->MainVertexTracking_b();
- fTracker->FillTracks();
-
- if ( fDoNonVertex )
- fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
-#endif
-// END ################################################# MODIFIY JMT
-
+
UInt_t ntracks0 =0;
if(fpInterMerger){
AliHLTTPCMemHandler memory;
fpInterMerger->Merge();
}
ntracks0=0;
- mysize = fTracker->GetTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
+ AliHLTTPCTrackArray* pArray=fTracker->GetTracks();
+ mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets );
outPtr->fTrackletCnt = ntracks0;
Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
"Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.",
ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
+ fTracker->Reset();
+
tSize += mysize+sizeof(AliHLTTPCTrackletData);
outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
return 0;
}
+void AliHLTTPCSliceTrackerComponent::SetTrackerParam1()
+{
+ // see header file for class documentation
+ SetTrackerParam( 10, 20, 5, 10, 2,2,
+ 0, 1.31, 5, 100,
+ 50, 100, 50, 0.1, 0.1,
+ true );
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff