// @(#) $Id$
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project *
- * ALICE Experiment at CERN, All rights reserved. *
- * *
- * Primary Authors: Jochen Thaeder <thaeder@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. *
- **************************************************************************/
+// **************************************************************************
+// 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. *
+// *
+//***************************************************************************
+
///////////////////////////////////////////////////////////////////////////////
// //
#include "AliHLTTPCCATrackerComponent.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCCATracker.h"
-#include "AliHLTTPCCAHit.h"
#include "AliHLTTPCCAOutTrack.h"
+#include "AliHLTTPCCAParam.h"
+#include "AliHLTTPCCATrackConvertor.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTrackArray.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCDefinitions.h"
+#include "AliExternalTrackParam.h"
#include "TStopwatch.h"
#include "TMath.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "TObjString.h"
+#include "TObjArray.h"
+#include "AliHLTTPCCASliceOutput.h"
+const AliHLTComponentDataType AliHLTTPCCADefinitions::fgkTrackletsDataType = AliHLTComponentDataTypeInitializer( "CATRACKL", kAliHLTDataOriginTPC );
-// this is a global object used for automatic component registration, do not use this
-AliHLTTPCCATrackerComponent gAliHLTTPCCATrackerComponent;
-
+/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCCATrackerComponent)
+/** global object for registration
+ * Matthias 2009-01-13 temporarily using the global object approach again.
+ * CA cade had to be disabled because of various compilation problems, so
+ * the global object approach fits better for the moment.
+ */
+
+AliHLTTPCCATrackerComponent gAliHLTTPCCATrackerComponent;
+
AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
:
fTracker(NULL),
- fBField(0)
+ fSolenoidBz(0),
+ fMinNTrackClusters(0),
+ fClusterZCut(500.),
+ fFullTime(0),
+ fRecoTime(0),
+ fNEvents(0),
+ fNewOutputType(0)
{
// see header file for class documentation
// or
:
AliHLTProcessor(),
fTracker(NULL),
- fBField(0)
+ fSolenoidBz(0),
+ fMinNTrackClusters(30),
+ fClusterZCut(500.),
+ fFullTime(0),
+ fRecoTime(0),
+ fNEvents(0),
+ fNewOutputType(0)
{
// see header file for class documentation
HLTFatal("copy constructor untested");
AliHLTComponentDataType AliHLTTPCCATrackerComponent::GetOutputDataType()
{
// see header file for class documentation
- return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
+ if( fNewOutputType ) return AliHLTTPCCADefinitions::fgkTrackletsDataType;
+ else return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
}
void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
return new AliHLTTPCCATrackerComponent;
}
-int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
+Int_t AliHLTTPCCATrackerComponent::DoInit( Int_t argc, const char** argv )
{
- // Initialize the CA tracker component
- //
- // arguments could be:
- // bfield - the magnetic field value
- //
+ // Configure the CA tracker component
+
+ fSolenoidBz = 5;
+ fMinNTrackClusters = 0;
+ fClusterZCut = 500.;
+ fFullTime = 0;
+ fRecoTime = 0;
+ fNEvents = 0;
+ fNewOutputType = 0;
if ( fTracker ) return EINPROGRESS;
-
fTracker = new AliHLTTPCCATracker();
-
- // read command line
-
- int i = 0;
- char* cpErr;
- while ( i < argc ){
- if ( !strcmp( argv[i], "bfield" ) ){
- if ( i+1 >= argc )
- {
- Logging( kHLTLogError, "HLT::TPCCATracker::DoInit", "Missing B-field", "Missing B-field specifier." );
- return ENOTSUP;
- }
- fBField = strtod( argv[i+1], &cpErr );
- if ( *cpErr )
- {
- Logging( kHLTLogError, "HLT::TPCCATracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] );
- return EINVAL;
- }
- Logging( kHLTLogDebug, "HLT::TPCCATracker::DoInit", "Reading command line",
- "Magnetic field value is set to %f kG", fBField );
+ Int_t iResult = 0;
- i += 2;
- continue;
- }
-
- Logging(kHLTLogError, "HLT::TPCCATracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
- return EINVAL;
+ TString arguments="";
+ for (int i=0; i<argc; i++) {
+ TString argument=argv[i];
+ if (!arguments.IsNull()) arguments+=" ";
+ arguments+=argument;
}
-
- return 0;
+ if (!arguments.IsNull()) {
+ iResult=Configure(arguments.Data());
+ } else {
+ iResult=Reconfigure(NULL, NULL);
+ }
+ return iResult;
}
-int AliHLTTPCCATrackerComponent::DoDeinit()
+
+Int_t AliHLTTPCCATrackerComponent::DoDeinit()
{
// see header file for class documentation
if ( fTracker ) delete fTracker;
return 0;
}
-int AliHLTTPCCATrackerComponent::DoEvent
+Int_t AliHLTTPCCATrackerComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
+{
+ // see header file for class documentation
+
+ HLTWarning("TODO: dummy Reconfigure() method" );
+
+ return 0;
+
+ /*
+
+ Int_t iResult=0;
+ const char* path="HLT/ConfigTPC/CATrackerComponent";
+ const char* defaultNotify="";
+ if (cdbEntry) {
+ path=cdbEntry;
+ defaultNotify=" (default)";
+ }
+ if (path) {
+ HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
+ AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);//,GetRunNo());
+ if (pEntry) {
+ TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
+ if (pString) {
+ HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
+ iResult=Configure(pString->GetString().Data());
+ } else {
+ HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
+ }
+ } else {
+ HLTError("cannot fetch object \"%s\" from CDB", path);
+ }
+ }
+
+ const char* pathBField=kAliHLTCDBSolenoidBz;
+
+ if (pathBField) {
+ HLTInfo("reconfigure B-Field from entry %s, chain id %s", path,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
+ AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField);//,GetRunNo());
+ if (pEntry) {
+ TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
+ if (pString) {
+ HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
+ iResult=Configure(pString->GetString().Data());
+ } else {
+ HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
+ }
+ } else {
+ HLTError("cannot fetch object \"%s\" from CDB", path);
+ }
+ }
+ return iResult;
+*/
+}
+
+
+Bool_t AliHLTTPCCATrackerComponent::CompareClusters(AliHLTTPCSpacePointData *a, AliHLTTPCSpacePointData *b)
+{
+ //* Comparison function for sorting clusters
+ if( a->fPadRow<b->fPadRow ) return 1;
+ if( a->fPadRow>b->fPadRow ) return 0;
+ return (a->fZ < b->fZ);
+}
+
+
+Int_t AliHLTTPCCATrackerComponent::Configure( const char* arguments )
+{
+ //* Set parameters
+
+ Int_t iResult=0;
+ if (!arguments) return iResult;
+
+ TString allArgs=arguments;
+ TString argument;
+ Int_t bMissingParam=0;
+
+ TObjArray* pTokens=allArgs.Tokenize(" ");
+
+ Int_t nArgs = pTokens ?pTokens->GetEntries() :0;
+
+ for (int i=0; i<nArgs; i++ ){
+ argument=((TObjString*)pTokens->At(i))->GetString();
+ if (argument.IsNull()){
+ }
+ else 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 );
+ }
+ else if ( argument.CompareTo("-minNClustersOnTrack")==0 ||
+ argument.CompareTo("-minNTrackClusters")==0 ){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ fMinNTrackClusters = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+ HLTInfo("minNClustersOnTrack set to: %d", fMinNTrackClusters );
+ }
+ else if ( argument.CompareTo("-clusterZCut")==0 ){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ fClusterZCut = TMath::Abs( ((TObjString*)pTokens->At(i))->GetString().Atof());
+ HLTInfo("ClusterZCut set to: %f", fClusterZCut );
+ }
+ else if ( argument.CompareTo("-newOutputType")==0 ){
+ fNewOutputType = 1;
+ HLTInfo("NewOutputType is set");
+ }
+ else {
+ HLTError("Unknown option %s ", argument.Data());
+ iResult=-EINVAL;
+ }
+ }
+ delete pTokens;
+
+ if (bMissingParam) {
+ HLTError("Specifier missed for %s", argument.Data());
+ iResult=-EINVAL;
+ }
+
+ return iResult;
+}
+
+
+
+
+Int_t AliHLTTPCCATrackerComponent::DoEvent
(
const AliHLTComponentEventData& evtData,
const AliHLTComponentBlockData* blocks,
AliHLTUInt32_t& size,
vector<AliHLTComponentBlockData>& outputBlocks )
{
-
- AliHLTUInt32_t MaxBufferSize = size;
+ //* process event
+ AliHLTUInt32_t maxBufferSize = size;
size = 0; // output size
+ if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
+ return 0;
+ }
+
TStopwatch timer;
// Event reconstruction in one TPC slice with CA Tracker
-
- Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "DoEvent", "DoEvent()" );
+
+ //Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "CA::DoEvent()" );
if ( evtData.fBlockCnt<=0 )
{
- Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "no blocks in event" );
+ HLTWarning("no blocks in event" );
return 0;
}
}
if( slice<0 ){
- Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "no slices found in event" );
+ HLTWarning("no slices found in event" );
return 0;
}
// Initialize the tracker
- Double_t Bz = fBField;
{
if( !fTracker ) fTracker = new AliHLTTPCCATracker;
Int_t iSec = slice;
- Double_t inRmin = 83.65;
- // Double_t inRmax = 133.3;
- // Double_t outRmin = 133.5;
- Double_t outRmax = 247.7;
- Double_t plusZmin = 0.0529937;
- Double_t plusZmax = 249.778;
- Double_t minusZmin = -249.645;
- Double_t minusZmax = -0.0799937;
- Double_t dalpha = 0.349066;
- Double_t alpha = 0.174533 + dalpha*iSec;
+ Float_t inRmin = 83.65;
+ // Float_t inRmax = 133.3;
+ // Float_t outRmin = 133.5;
+ Float_t outRmax = 247.7;
+ Float_t plusZmin = 0.0529937;
+ Float_t plusZmax = 249.778;
+ Float_t minusZmin = -249.645;
+ Float_t minusZmax = -0.0799937;
+ Float_t dalpha = 0.349066;
+ Float_t alpha = 0.174533 + dalpha*iSec;
Bool_t zPlus = (iSec<18 );
- Double_t zMin = zPlus ?plusZmin :minusZmin;
- Double_t zMax = zPlus ?plusZmax :minusZmax;
+ Float_t zMin = zPlus ?plusZmin :minusZmin;
+ Float_t zMax = zPlus ?plusZmax :minusZmax;
//TPCZmin = -249.645, ZMax = 249.778
- // Double_t rMin = inRmin;
- // Double_t rMax = outRmax;
- Int_t NRows = AliHLTTPCTransform::GetNRows();
+ // Float_t rMin = inRmin;
+ // Float_t rMax = outRmax;
+ Int_t nRows = AliHLTTPCTransform::GetNRows();
- Double_t padPitch = 0.4;
- Double_t sigmaZ = 0.228808;
+ Float_t padPitch = 0.4;
+ Float_t sigmaZ = 0.228808;
- Double_t rowX[NRows];
- for( Int_t irow=0; irow<NRows; irow++){
+ Float_t *rowX = new Float_t [nRows];
+ for( Int_t irow=0; irow<nRows; irow++){
rowX[irow] = AliHLTTPCTransform::Row2X( irow );
}
AliHLTTPCCAParam param;
- param.Initialize( iSec, NRows, rowX, alpha, dalpha,
- inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, Bz );
- param.YErrorCorrection() = 1;
- param.ZErrorCorrection() = 2;
-
+ param.Initialize( iSec, nRows, rowX, alpha, dalpha,
+ inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
+ param.SetHitPickUpFactor( 2 );
+ param.Update();
fTracker->Initialize( param );
-
+ delete[] rowX;
}
// min and max patch numbers and row numbers
Int_t row[2] = {0,0};
- Int_t minPatch=INT_MAX, maxPatch = -1;
+ Int_t minPatch=100, maxPatch = -1;
// total n Hits
fTracker->StartEvent();
- AliHLTTPCCAHit vHits[nHitsTotal]; // CA hit array
- Double_t vHitStoreX[nHitsTotal]; // hit X coordinates
- Int_t vHitStoreID[nHitsTotal]; // hit ID's
- Int_t vHitRowID[nHitsTotal]; // hit ID's
-
- Int_t nHits = 0;
-
Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits",
"Total %d hits to read for slice %d", nHitsTotal, slice );
+
+ AliHLTTPCSpacePointData** vOrigClusters = new AliHLTTPCSpacePointData* [ nHitsTotal];
+
Int_t nClusters=0;
for( std::vector<unsigned long>::iterator pIter = patchIndices.begin(); pIter!=patchIndices.end(); pIter++ ){
Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits",
"Reading %d hits for slice %d - patch %d", inPtrSP->fSpacePointCnt, slice, patch );
- // Read patch hits, row by row
-
- Int_t oldRow = -1;
- Int_t nRowHits = 0;
- Int_t firstRowHit = 0;
for (UInt_t i=0; i<inPtrSP->fSpacePointCnt; i++ ){
- AliHLTTPCSpacePointData* pSP = &(inPtrSP->fSpacePoints[i]);
+ vOrigClusters[nClusters++] = &(inPtrSP->fSpacePoints[i]);
+ }
+ }
- if( pSP->fPadRow != oldRow ){
- if( oldRow>=0 ) fTracker->ReadHitRow( oldRow, vHits+firstRowHit, nRowHits );
- oldRow = pSP->fPadRow;
- firstRowHit = nHits;
- nRowHits = 0;
- }
- AliHLTTPCCAHit &h = vHits[nHits];
- if( TMath::Abs(pSP->fX- fTracker->Rows()[pSP->fPadRow].X() )>1.e-4 ) cout<<"row "<<(Int_t)pSP->fPadRow<<" "<<fTracker->Rows()[pSP->fPadRow].X()-pSP->fX <<endl;
-
- h.Y() = pSP->fY;
- h.Z() = pSP->fZ;
- h.ErrY() = TMath::Sqrt(TMath::Abs(pSP->fSigmaY2));
- h.ErrZ() = TMath::Sqrt(TMath::Abs(pSP->fSigmaZ2));
- if( h.ErrY()<.1 ) h.ErrY() = .1;
- if( h.ErrZ()<.1 ) h.ErrZ() = .1;
- if( h.ErrY()>1. ) h.ErrY() = 1.;
- if( h.ErrZ()>1. ) h.ErrZ() = 1.;
- h.ID() = nHits;
+ // sort clusters since they are not sorted fore some reason
+
+ sort( vOrigClusters, vOrigClusters+nClusters, CompareClusters );
+
+ Float_t *vHitStoreX = new Float_t [nHitsTotal]; // hit X coordinates
+ Float_t *vHitStoreY = new Float_t [nHitsTotal]; // hit Y coordinates
+ Float_t *vHitStoreZ = new Float_t [nHitsTotal]; // hit Z coordinates
+ Int_t *vHitStoreIntID = new Int_t [nHitsTotal]; // hit ID's
+ Int_t *vHitStoreID = new Int_t [nHitsTotal]; // hit ID's
+ Int_t *vHitRowID = new Int_t [nHitsTotal]; // hit ID's
+
+ Int_t nHits = 0;
+
+ {
+ Int_t rowNHits[200];
+ Int_t rowFirstHits[200];
+ for( Int_t ir=0; ir<200; ir++ ) rowNHits[ir] = 0;
+ Int_t oldRow = -1;
+ for (Int_t i=0; i<nClusters; i++ ){
+ AliHLTTPCSpacePointData* pSP = vOrigClusters[i];
+ if( oldRow>=0 && pSP->fPadRow < oldRow )
+ HLTError("CA: clusters from row %d are readed twice",oldRow);
+
+ if( TMath::Abs(pSP->fZ)>fClusterZCut) continue;
+
vHitStoreX[nHits] = pSP->fX;
+ vHitStoreY[nHits] = pSP->fY;
+ vHitStoreZ[nHits] = pSP->fZ;
+ vHitStoreIntID[nHits] = nHits;
vHitStoreID[nHits] = pSP->fID;
vHitRowID[nHits] = pSP->fPadRow;
- nHits++;
- nRowHits++;
- nClusters++;
+ nHits++;
+ rowNHits[pSP->fPadRow]++;
}
- if( oldRow>=0 ) fTracker->ReadHitRow( oldRow, vHits+firstRowHit, nRowHits );
+
+ Int_t firstRowHit = 0;
+ for( Int_t ir=0; ir<200; ir++ ){
+ rowFirstHits[ir] = firstRowHit;
+ firstRowHit+=rowNHits[ir];
+ }
+
+ fTracker->ReadEvent( rowFirstHits, rowNHits, vHitStoreX, vHitStoreY, vHitStoreZ, nHits );
}
+ if( vOrigClusters ) delete[] vOrigClusters;
+
// reconstruct the event
TStopwatch timerReco;
Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
"%d tracks found for slice %d",fTracker->NOutTracks(), slice);
- // write reconstructed tracks
- AliHLTTPCTrackletData* outPtr = (AliHLTTPCTrackletData*)(outputPtr);
-
- AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;
-
- Int_t ntracks = fTracker->NOutTracks();
-
- UInt_t mySize = ((AliHLTUInt8_t *)currOutTracklet) - ((AliHLTUInt8_t *)outputPtr);
-
- outPtr->fTrackletCnt = 0;
-
- for( int itr=0; itr<ntracks; itr++ ){
-
- AliHLTTPCCAOutTrack &t = fTracker->OutTracks()[itr];
-
- //Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Wrtite output","track %d with %d hits", itr, t.NHits());
+ // write reconstructed tracks
- // calculate output track size
+ UInt_t mySize = 0;
+ Int_t ntracks = *fTracker->NOutTracks();
- UInt_t dSize = sizeof(AliHLTTPCTrackSegmentData) + t.NHits()*sizeof(UInt_t);
-
- if( mySize + dSize > MaxBufferSize ){
- Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "Wrtite output","Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", MaxBufferSize, mySize, ntracks-itr+1);
- ret = -ENOSPC;
- break;
- }
-
- // convert CA track parameters to HLT Track Segment
+
+ if( !fNewOutputType ){
- Int_t iFirstHit = fTracker->OutTrackHits()[t.FirstHitRef()];
- Int_t iLastHit = fTracker->OutTrackHits()[t.FirstHitRef()+t.NHits()-1];
+ AliHLTTPCTrackletData* outPtr = (AliHLTTPCTrackletData*)(outputPtr);
- AliHLTTPCCAHit &firstHit = vHits[iFirstHit];
- AliHLTTPCCAHit &lastHit = vHits[iLastHit];
-
- t.Param().TransportBz(Bz, vHitStoreX[iFirstHit], firstHit.Y(), firstHit.Z() );
-
- currOutTracklet->fX = t.Param().Par()[0];
- currOutTracklet->fY = t.Param().Par()[1];
- currOutTracklet->fZ = t.Param().Par()[2];
- Double_t qp = t.Param().Par()[6];
- Double_t p = TMath::Abs(qp)>1.e-5 ?1./TMath::Abs(qp) :1.e5;
- Double_t ex = t.Param().Par()[3];
- Double_t ey = t.Param().Par()[4];
- Double_t ez = t.Param().Par()[5];
- Double_t et = TMath::Sqrt( ex*ex + ey*ey );
+ AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;
- currOutTracklet->fCharge = (qp>0) ?+1 :(qp<0 ?-1 :0);
- currOutTracklet->fPt = p*et;
-
- Double_t h3 = TMath::Abs(ex) >1.e-5 ? p*ex/et :0;
- Double_t h4 = TMath::Abs(ey) >1.e-5 ? p*ey/et :0;
- Double_t h5;
- Double_t h6 = - currOutTracklet->fCharge * p * currOutTracklet->fPt;
-
- currOutTracklet->fPterr = ( h3*h3*t.Param().Cov()[9] + h4*h4*t.Param().Cov()[14] + h6*h6*t.Param().Cov()[27]
- + 2.*(h3*h4*t.Param().Cov()[13]+h3*h6*t.Param().Cov()[24]+h4*h6*t.Param().Cov()[25] )
- );
- currOutTracklet->fPsi = TMath::ATan2(ey, ex);
+ mySize = ((AliHLTUInt8_t *)currOutTracklet) - ((AliHLTUInt8_t *)outputPtr);
- h3 = ex/(et*et);
- h4 = -ey/(et*et);
- currOutTracklet->fPsierr = h3*h3*t.Param().Cov()[9] + h4*h4*t.Param().Cov()[14] + 2.*h3*h4*t.Param().Cov()[13];
+ outPtr->fTrackletCnt = 0;
- currOutTracklet->fTgl = TMath::Abs(et)>1.e-5 ? ez/et :1.e5;
+ for( Int_t itr=0; itr<ntracks; itr++ ){
- if( TMath::Abs(et) >1.e-2 ){
- h3 = -ez*ex/et/et;
- h4 = -ez*ey/et/et;
- h5 = 1.;
- currOutTracklet->fTglerr = ( h3*h3*t.Param().Cov()[9] + h4*h4*t.Param().Cov()[14] + h5*h5*t.Param().Cov()[20]
- + 2.*(h3*h4*t.Param().Cov()[13]+h3*h5*t.Param().Cov()[18]+h4*h5*t.Param().Cov()[19] )
- )/et/et;
- }else{
- currOutTracklet->fTglerr = 1.e-2;
- }
-
- currOutTracklet->fCharge = -currOutTracklet->fCharge;
-
- t.Param().TransportBz(Bz, vHitStoreX[iLastHit], lastHit.Y(), lastHit.Z() );
-
- currOutTracklet->fLastX = t.Param().Par()[0];
- currOutTracklet->fLastY = t.Param().Par()[1];
- currOutTracklet->fLastZ = t.Param().Par()[2];
-
+ AliHLTTPCCAOutTrack &t = fTracker->OutTracks()[itr];
+
+ //Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Wrtite output","track %d with %d hits", itr, t.NHits());
+
+ if( t.NHits()<fMinNTrackClusters ) continue;
+
+ // calculate output track size
+
+ UInt_t dSize = sizeof(AliHLTTPCTrackSegmentData) + t.NHits()*sizeof(UInt_t);
+
+ 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);
+ ret = -ENOSPC;
+ break;
+ }
+
+ // convert CA track parameters to HLT Track Segment
+
+ Int_t iFirstRow = 1000;
+ Int_t iLastRow = -1;
+ Int_t iFirstHit = fTracker->OutTrackHits()[t.FirstHitRef()];
+ Int_t iLastHit = iFirstHit;
+ for( Int_t ih=0; ih<t.NHits(); ih++ ){
+ Int_t hitID = fTracker->OutTrackHits()[t.FirstHitRef() + ih ];
+ Int_t iRow = vHitRowID[hitID];
+ if( iRow<iFirstRow ){ iFirstRow = iRow; iFirstHit = hitID; }
+ if( iRow>iLastRow ){ iLastRow = iRow; iLastHit = hitID; }
+ }
+
+ AliHLTTPCCATrackParam par = t.StartPoint();
+
+ par.TransportToX( vHitStoreX[iFirstHit], .99 );
+
+ AliExternalTrackParam tp;
+ AliHLTTPCCATrackConvertor::GetExtParam( par, tp, 0 );
+
+ currOutTracklet->fX = tp.GetX();
+ currOutTracklet->fY = tp.GetY();
+ currOutTracklet->fZ = tp.GetZ();
+ currOutTracklet->fCharge = (Int_t ) tp.GetSign();
+ currOutTracklet->fPt = TMath::Abs(tp.GetSignedPt());
+ Float_t snp = tp.GetSnp() ;
+ if( snp>.999 ) snp=.999;
+ if( snp<-.999 ) snp=-.999;
+ currOutTracklet->fPsi = TMath::ASin( snp );
+ currOutTracklet->fTgl = tp.GetTgl();
+
+ currOutTracklet->fY0err = tp.GetSigmaY2();
+ currOutTracklet->fZ0err = tp.GetSigmaZ2();
+ Float_t h = -currOutTracklet->fPt*currOutTracklet->fPt;
+ currOutTracklet->fPterr = h*h*tp.GetSigma1Pt2();
+ h = 1./TMath::Sqrt(1-snp*snp);
+ currOutTracklet->fPsierr = h*h*tp.GetSigmaSnp2();
+ currOutTracklet->fTglerr = tp.GetSigmaTgl2();
+
+ if( par.TransportToX( vHitStoreX[iLastHit],.99 ) ){
+ currOutTracklet->fLastX = par.GetX();
+ currOutTracklet->fLastY = par.GetY();
+ currOutTracklet->fLastZ = par.GetZ();
+ } else {
+ currOutTracklet->fLastX = vHitStoreX[iLastHit];
+ currOutTracklet->fLastY = vHitStoreY[iLastHit];
+ currOutTracklet->fLastZ = vHitStoreZ[iLastHit];
+ }
+ //if( currOutTracklet->fLastX<10. ) {
+ //HLTError("CA last point: hitxyz=%f,%f,%f, track=%f,%f,%f, tracklet=%f,%f,%f, nhits=%d",vHitStoreX[iLastHit],vHitStoreY[iLastHit],vHitStoreZ[iLastHit],
+ //par.GetX(), par.GetY(),par.GetZ(),currOutTracklet->fLastX,currOutTracklet->fLastY ,currOutTracklet->fLastZ, t.NHits());
+ //}
#ifdef INCLUDE_TPC_HOUGH
#ifdef ROWHOUGHPARAMS
- currOutTracklet->fTrackID = 0;
- currOutTracklet->fRowRange1 = vHitRowID[iFirstHit];
- currOutTracklet->fRowRange2 = vHitRowID[iLastHit];
- currOutTracklet->fSector = slice;
- currOutTracklet->fPID = 211;
+ currOutTracklet->fTrackID = 0;
+ currOutTracklet->fRowRange1 = vHitRowID[iFirstHit];
+ currOutTracklet->fRowRange2 = vHitRowID[iLastHit];
+ currOutTracklet->fSector = slice;
+ currOutTracklet->fPID = 211;
#endif
#endif // INCLUDE_TPC_HOUGH
-
-
- currOutTracklet->fNPoints = t.NHits();
-
- for( Int_t i=0; i<t.NHits(); i++ ){
- currOutTracklet->fPointIDs[i] = vHitStoreID[fTracker->OutTrackHits()[t.FirstHitRef()+i]];
+
+
+ currOutTracklet->fNPoints = t.NHits();
+
+ for( Int_t i=0; i<t.NHits(); i++ ){
+ currOutTracklet->fPointIDs[i] = vHitStoreID[fTracker->OutTrackHits()[t.FirstHitRef()+i]];
+ }
+
+ currOutTracklet = (AliHLTTPCTrackSegmentData*)( (Byte_t *)currOutTracklet + dSize );
+ mySize+=dSize;
+ outPtr->fTrackletCnt++;
+ }
+ } else { // new output type
+
+ mySize = fTracker->Output()->EstimateSize( fTracker->Output()->NTracks(),
+ fTracker->Output()->NTrackClusters() );
+ if( mySize <= maxBufferSize ){
+ const AliHLTUInt8_t* outputevent = reinterpret_cast<const AliHLTUInt8_t*>(fTracker->Output());
+ for( UInt_t i=0; i<mySize; i++ ) outputPtr[i] = outputevent[i];
+ } else {
+ HLTWarning("Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
+ mySize = 0;
+ ret = -ENOSPC;
}
-
- currOutTracklet = (AliHLTTPCTrackSegmentData*)( (Byte_t *)currOutTracklet + dSize );
- mySize+=dSize;
- outPtr->fTrackletCnt++;
}
-
-
- AliHLTComponentBlockData bd;
- FillBlockData( bd );
- bd.fOffset = 0;
- bd.fSize = mySize;
- bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
- outputBlocks.push_back( bd );
-
+
+ if( vHitStoreX ) delete[] vHitStoreX;
+ if( vHitStoreY ) delete[] vHitStoreY;
+ if( vHitStoreZ ) delete[] vHitStoreZ;
+ if( vHitStoreIntID ) delete[] vHitStoreIntID;
+ if( vHitStoreID ) delete[] vHitStoreID;
+ if( vHitRowID ) delete[] vHitRowID;
+
+ if( mySize>0 ){
+ AliHLTComponentBlockData bd;
+ FillBlockData( bd );
+ bd.fOffset = 0;
+ bd.fSize = mySize;
+ bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
+ outputBlocks.push_back( bd );
+ }
size = mySize;
- timerReco.Stop();
+ timer.Stop();
- // Set log level to "Warning" for on-line system monitoring
+ fFullTime+= timer.RealTime();
+ fRecoTime+= timerReco.RealTime();
+ fNEvents++;
- Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "Tracks",
- "CATracker slice %d: output %d tracks; input %d clusters, patches %d..%d, rows %d..%d; reco time %d/%d us",
- slice, ntracks, nClusters, minPatch, maxPatch, row[0], row[1], (Int_t) (timer.RealTime()*1.e6), (Int_t) (timerReco.RealTime()*1.e6) );
+ // Set log level to "Warning" for on-line system monitoring
+ Int_t hz = (Int_t) (fFullTime>1.e-10 ?fNEvents/fFullTime :100000);
+ Int_t hz1 = (Int_t) (fRecoTime>1.e-10 ?fNEvents/fRecoTime :100000);
+ HLTWarning( "CATracker slice %d: output %d tracks; input %d clusters, patches %d..%d, rows %d..%d; reco time %d/%d Hz",
+ slice, ntracks, nClusters, minPatch, maxPatch, row[0], row[1], hz, hz1 );
return ret;
-
}