#include "AliHLT3DTrackParam.h"
#include "TMath.h"
-ClassImp(AliHLT3DTrackParam);
+ClassImp(AliHLT3DTrackParam)
//* Transport utilities
//-*- Mode: C++ -*-
// @(#) $Id$
-//* This file is property of and copyright by the ALICE HLT Project *
-//* ALICE Experiment at CERN, All rights reserved. *
-//* See cxx source for full Copyright notice *
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* See cxx source for full Copyright notice *
+
+//* *
+//* AliHLT3DTrackParam class is under development and currently not in use *
+//* *
#ifndef ALIHLT3DTRACKPARAM_H
#define ALIHLT3DTRACKPARAM_H
Int_t GetNDF() const { return fNDF; }
Int_t GetCharge() const { return fSignQ; }
- Double_t GetParameter ( int i ) const ;
- Double_t GetCovariance( int i ) const ;
- Double_t GetCovariance( int i, int j ) const ;
+ Double_t GetParameter ( int i ) const { return fParam[i]; }
+ Double_t GetCovariance( int i ) const { return fCov[i]; }
+ Double_t GetCovariance( int i, int j ) const { return fCov[( j<=i ) ? i*(i+1)/2+j :j*(j+1)/2+i]; }
//* Accessors with calculations( &value, &estimated sigma )
//* error flag returned (0 means no error during calculations)
#include "AliHLTTPCCACell.h"
-ClassImp(AliHLTTPCCACell);
+ClassImp(AliHLTTPCCACell)
+
+void AliHLTTPCCACell::Dummy()
+{
+}
//* ALICE Experiment at CERN, All rights reserved. *
//* See cxx source for full Copyright notice *
+//* *
+//* The AliHLTTPCCACell class describes the "Cell" object --- *
+//* the set of neghbouring clusters in the same TPC row. *
+//* The cells are used as the minimal data units *
+//* by the Cellular Automaton tracking algorithm. *
+//* *
+
#ifndef ALIHLTTPCCACELL_H
#define ALIHLTTPCCACELL_H
/**
* @class AliHLTTPCCACell
+ *
+ * The AliHLTTPCCACell class describes the "Cell" object ---
+ * the set of neghbouring clusters in the same TPC row.
+ * Cells are used as the minimal data units
+ * by the Cellular Automaton tracking algorithm.
+ *
*/
class AliHLTTPCCACell
{
AliHLTTPCCACell(): fFirstHitRef(0),fNHits(0),fY(0),fZ(0),fErrY(0),fErrZ(0),fIDown(0),fIUp(0),fIUsed(0){}
+ virtual ~AliHLTTPCCACell(){}
+
Float_t &Y(){ return fY; }
Float_t &Z(){ return fZ; }
Float_t &ErrY(){ return fErrY; }
Int_t fIDown, fIUp; // indices of 2 neighboring cells in up & down directions
Int_t fIUsed; // if it is used by a reconstructed track
+ private:
+
+ void Dummy(); // to make rulechecker happy by having something in .cxx file
+
ClassDef(AliHLTTPCCACell,1);
};
#include "AliHLTTPCCADisplay.h"
#include "AliHLTTPCCATracker.h"
-#include "TString.h"
+ //#include "TString.h"
#include "Riostream.h"
#include "TMath.h"
#include "TStyle.h"
#include "TCanvas.h"
-#include <vector>
+#include <algorithm>
-ClassImp(AliHLTTPCCADisplay);
+ClassImp(AliHLTTPCCADisplay)
AliHLTTPCCADisplay &AliHLTTPCCADisplay::Instance()
{
return gAliHLTTPCCADisplay;
}
-AliHLTTPCCADisplay::AliHLTTPCCADisplay() : fXY(0), fZY(0), fAsk(1), fSectorView(1), fSector(0),
+AliHLTTPCCADisplay::AliHLTTPCCADisplay() : fYX(0), fZX(0), fAsk(1), fSectorView(1), fSector(0),
fCos(1), fSin(0), fZMin(-250), fZMax(250),
fRInnerMin(83.65), fRInnerMax(133.3), fROuterMin(133.5), fROuterMax(247.7),
fTPCZMin(-250.), fTPCZMax(250), fArc(), fLine(), fPLine(), fMarker(), fBox(), fCrown(), fLatex()
}
AliHLTTPCCADisplay::AliHLTTPCCADisplay( const AliHLTTPCCADisplay& )
- : fXY(0), fZY(0), fAsk(1), fSectorView(1), fSector(0),
+ : fYX(0), fZX(0), fAsk(1), fSectorView(1), fSector(0),
fCos(1), fSin(0), fZMin(-250), fZMax(250),
fRInnerMin(83.65), fRInnerMax(133.3), fROuterMin(133.5), fROuterMax(247.7),
fTPCZMin(-250.), fTPCZMax(250), fArc(), fLine(), fPLine(), fMarker(), fBox(), fCrown(), fLatex()
AliHLTTPCCADisplay::~AliHLTTPCCADisplay()
{
// destructor
- delete fXY;
- delete fZY;
+ delete fYX;
+ delete fZX;
}
void AliHLTTPCCADisplay::Init()
gStyle->SetCanvasBorderMode(0);
gStyle->SetCanvasBorderSize(1);
gStyle->SetCanvasColor(0);
- fXY = new TCanvas ("XY", "XY window", -1, 0, 600, 600);
- fZY = new TCanvas ("ZY", "ZY window", -610, 0, 590, 600);
+ fYX = new TCanvas ("YX", "YX window", -1, 0, 600, 600);
+ fZX = new TCanvas ("ZX", "ZX window", -610, 0, 590, 600);
fMarker = TMarker(0.0, 0.0, 6);
}
{
// update windows
if( !fAsk ) return;
- fXY->Update();
- fZY->Update();
+ fYX->Update();
+ fZX->Update();
}
void AliHLTTPCCADisplay::Clear()
{
// clear windows
- fXY->Clear();
- fZY->Clear();
+ fYX->Clear();
+ fZX->Clear();
}
void AliHLTTPCCADisplay::Ask()
char symbol;
if (fAsk){
Update();
- cout<<"ask> "<<endl;
+ std::cout<<"ask> "<<std::endl;
do{
- cin.get(symbol);
+ std::cin.get(symbol);
if (symbol == 'r')
fAsk = false;
} while (symbol != '\n');
Double_t cx = 0;
Double_t cy = r0;
- fXY->Range(cx-dr, cy-dr, cx+dr, cy+dr);
+ fYX->Range(cx-dr, cy-dr, cx+dr, cy+dr);
Double_t cz = .5*(sec->Param().ZMax()+sec->Param().ZMin());
Double_t dz = .5*(sec->Param().ZMax()-sec->Param().ZMin())*1.2;
- fZY->Range(cz-dz, cy-dr, cz+dz, cy+dr);
+ fZX->Range(cz-dz, cy-dr, cz+dz, cy+dr);
}
}
{
// Get color with respect to Z coordinate
const Color_t kMyColor[11] = { kGreen, kBlue, kYellow, kMagenta, kCyan,
- kOrange, kSpring, kTeal, kAzure, kViolet, kPink };
+ kOrange, kSpring, kTeal, kAzure, kViolet, kPink };
Double_t zz = (z-fZMin)/(fZMax-fZMin);
Int_t iz = (int) (zz*11);
if( iz<0 ) iz = 0;
if( iz>10 ) iz = 10;
- return kMyColor[iz]-4;
+ return kMyColor[iz];
}
void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const
void AliHLTTPCCADisplay::DrawTPC()
{
// schematically draw TPC detector
- fXY->Range(-fROuterMax, -fROuterMax, fROuterMax, fROuterMax);
- fXY->Clear();
+ fYX->Range(-fROuterMax, -fROuterMax, fROuterMax, fROuterMax);
+ fYX->Clear();
{
fArc.SetLineColor(kBlack);
fArc.SetFillStyle(0);
- fXY->cd();
+ fYX->cd();
for( Int_t iSec=0; iSec<18; iSec++){
fCrown.SetLineColor(kBlack);
fCrown.SetFillStyle(0);
fCrown.DrawCrown(0,0,fROuterMin, fROuterMax, 360./18.*iSec, 360./18.*(iSec+1) );
}
}
- fZY->cd();
- fZY->Range( fTPCZMin, -fROuterMax, fTPCZMax, fROuterMax );
- fZY->Clear();
+ fZX->cd();
+ fZX->Range( fTPCZMin, -fROuterMax, fTPCZMax, fROuterMax );
+ fZX->Clear();
}
void AliHLTTPCCADisplay::DrawSector( AliHLTTPCCATracker *sec )
{
// draw current the TPC sector
- fXY->cd();
+ fYX->cd();
Double_t r0 = .5*(sec->Param().RMax()+sec->Param().RMin());
Double_t dr = .5*(sec->Param().RMax()-sec->Param().RMin());
Double_t cx = r0*sec->Param().CosAlpha();
fLine.SetLineColor(kBlack);
- fZY->cd();
+ fZX->cd();
Double_t cz = .5*(sec->Param().ZMax()+sec->Param().ZMin());
Double_t dz = .5*(sec->Param().ZMax()-sec->Param().ZMin())*1.2;
AliHLTTPCCAHit *h = &(row.Hits()[iHit]);
if( color<0 ) color = GetColor( h->Z() );
- Double_t dgy = 3.*TMath::Abs(h->ErrY()*fSector->Param().CosAlpha() - fSector->Param().ErrX()*fSector->Param().SinAlpha() );
- Double_t dx = fSector->Param().ErrX()*TMath::Sqrt(12.)/2.;
- Double_t dy = h->ErrY()*3.;
- Double_t dz = h->ErrZ()*3.;
+ //Double_t dgy = 3.*TMath::Abs(h->ErrY()*fSector->Param().CosAlpha() - fSector->Param().ErrX()*fSector->Param().SinAlpha() );
+ //Double_t dx = fSector->Param().ErrX()*TMath::Sqrt(12.)/2.;
+ //Double_t dy = h->ErrY()*3.;
+ //Double_t dz = h->ErrZ()*3.;
fMarker.SetMarkerColor(color);
fArc.SetLineColor(color);
fArc.SetFillStyle(0);
Double_t vx, vy;
Sec2View( row.X(), h->Y(), &vx, &vy );
- fXY->cd();
- if( fSectorView ) fArc.DrawEllipse( vx, vy, dx, dy, 0,360, 90);
- else fArc.DrawEllipse( vx, vy, dx, dy, 0,360, fSector->Param().Alpha()*180./3.1415);
+ fYX->cd();
+ //if( fSectorView ) fArc.DrawEllipse( vx, vy, dx, dy, 0,360, 90);
+ //else fArc.DrawEllipse( vx, vy, dx, dy, 0,360, fSector->Param().Alpha()*180./3.1415);
fMarker.DrawMarker(vx, vy);
- fZY->cd();
- if( fSectorView ) fArc.DrawEllipse( h->Z(), vy, dz, dx, 0,360, 90 );
- else fArc.DrawEllipse( h->Z(), vy, dz, dgy, 0,360, fSector->Param().Alpha()*180./3.1415);
+ fZX->cd();
+ //if( fSectorView ) fArc.DrawEllipse( h->Z(), vy, dz, dx, 0,360, 90 );
+ //else fArc.DrawEllipse( h->Z(), vy, dz, dgy, 0,360, fSector->Param().Alpha()*180./3.1415);
fMarker.DrawMarker(h->Z(), vy);
}
if( color<0 ) color = GetColor(cell.Z());
fLine.SetLineColor(color);
fLine.SetLineWidth(width);
- fXY->cd();
+ fYX->cd();
fLine.DrawLine(vx-vdx,vy-vdy, vx+vdx, vy+vdy );
- fZY->cd();
+ fZX->cd();
fLine.DrawLine(cell.Z()-3*cell.ErrZ(),vy-vdy, cell.Z()+3*cell.ErrZ(), vy+vdy );
fLine.SetLineWidth(1);
}
//fPLine.SetFillColor(color);
fPLine.SetFillStyle(-1);
- fXY->cd();
+ fYX->cd();
fPLine.DrawPolyLine(5, lx, ly );
- fZY->cd();
+ fZX->cd();
fPLine.DrawPolyLine(5, lz, ly );
DrawCell( iRow1, cell1, 1, color );
DrawCell( iRow2, cell2, 1, color );
}
-Bool_t CompareCellDS( const pair<int,double> &a, const pair<int,double> &b )
-{
- // function used to sort cells track along trajectory, pair<cell index, track length>
- return (a.second<b.second);
-}
-
void AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrack &track, Int_t color )
{
// draw track
- if( track.NCells()<2 ) return;
+ if( track.NCells()<2 ) return;
+ int width = 3;
Double_t b = -5;
- std::vector<pair<int,double> > vCells;
+ AliHLTTPCCADisplayTmpCell *vCells = new AliHLTTPCCADisplayTmpCell[track.NCells()];
+
AliHLTTPCCATrackPar t = track.Param();
for( Int_t iCell=0; iCell<track.NCells(); iCell++ ){
AliHLTTPCCACell &c = fSector->GetTrackCell(track,iCell);
AliHLTTPCCARow &row = fSector->GetTrackCellRow(track,iCell);
Double_t xyz[3] = {row.X(), c.Y(), c.Z()};
- if( iCell==0 ) t.TransportBz(-5, xyz);
- pair<int,double> tmp(iCell, t.GetDsToPointBz(-5.,xyz));
- vCells.push_back(tmp);
+ if( iCell==0 ) t.TransportBz(-5, xyz);
+ vCells[iCell].Index() = iCell;
+ vCells[iCell].S() = t.GetDsToPointBz(-5.,xyz);
}
- sort(vCells.begin(), vCells.end(), CompareCellDS );
+ sort(vCells, vCells + track.NCells(), AliHLTTPCCADisplayTmpCell::CompareCellDS );
t.Normalize();
const Double_t kCLight = 0.000299792458;
Double_t bc = b*kCLight;
//for( Int_t iCell=0; iCell<track.fNCells-1; iCell++ )
{
- AliHLTTPCCACell &c1 = fSector->GetTrackCell(track,vCells[0].first);
- AliHLTTPCCACell &c2 = fSector->GetTrackCell(track,vCells[track.NCells()-1].first);
- AliHLTTPCCARow &row1 = fSector->GetTrackCellRow(track,vCells[0].first);
- AliHLTTPCCARow &row2 = fSector->GetTrackCellRow(track,vCells[track.NCells()-1].first);
- if( color<0 ) color = GetColor( (c1.Z()+c2.Z())/2. );
+ AliHLTTPCCACell &c1 = fSector->GetTrackCell(track,vCells[0].Index());
+ AliHLTTPCCACell &c2 = fSector->GetTrackCell(track,vCells[track.NCells()-1].Index());
+ AliHLTTPCCARow &row1 = fSector->GetTrackCellRow(track,vCells[0].Index());
+ AliHLTTPCCARow &row2 = fSector->GetTrackCellRow(track,vCells[track.NCells()-1].Index());
+ Double_t x1, y1, z1, x2, y2, z2;
+ {
+ Double_t xyz[3] = {row1.X(), c1.Y(), c1.Z()};
+ t.TransportBz(-5, xyz);
+ x1 = t.Par()[0]; y1 = t.Par()[1]; z1 = t.Par()[2];
+ }
+ {
+ Double_t xyz[3] = {row2.X(), c2.Y(), c2.Z()};
+ t.TransportBz(-5, xyz);
+ x2 = t.Par()[0]; y2 = t.Par()[1]; z2 = t.Par()[2];
+ }
+
+ if( color<0 ) color = GetColor( (z1+z2)/2. );
Double_t vx1, vy1, vx2, vy2;
- Sec2View(row1.X(), c1.Y(), &vx1, &vy1 );
- Sec2View(row2.X(), c2.Y(), &vx2, &vy2 );
+ Sec2View(x1, y1, &vx1, &vy1 );
+ Sec2View(x2, y2, &vx2, &vy2 );
fLine.SetLineColor( color );
- fLine.SetLineWidth(3);
+ fLine.SetLineWidth( width );
if( TMath::Abs(q)>.1 ){
Double_t qq = pt/q;
a1 = a2-da;
fArc.SetFillStyle(0);
fArc.SetLineColor(color);
- fArc.SetLineWidth(3);
+ fArc.SetLineWidth(width);
- fXY->cd();
+ fYX->cd();
fArc.DrawArc(vx,vy,r, a1,a2,"only");
} else {
- fXY->cd();
+ fYX->cd();
fLine.DrawLine(vx1,vy1, vx2, vy2 );
}
+
}
for( Int_t iCell=0; iCell<track.NCells()-1; iCell++ ){
- AliHLTTPCCACell &c1 = fSector->GetTrackCell(track,vCells[iCell].first);
- AliHLTTPCCACell &c2 = fSector->GetTrackCell(track,vCells[iCell+1].first);
- AliHLTTPCCARow &row1 = fSector->GetTrackCellRow(track,vCells[iCell].first);
- AliHLTTPCCARow &row2 = fSector->GetTrackCellRow(track,vCells[iCell+1].first);
+ AliHLTTPCCACell &c1 = fSector->GetTrackCell(track,vCells[iCell].Index());
+ AliHLTTPCCACell &c2 = fSector->GetTrackCell(track,vCells[iCell+1].Index());
+ AliHLTTPCCARow &row1 = fSector->GetTrackCellRow(track,vCells[iCell].Index());
+ AliHLTTPCCARow &row2 = fSector->GetTrackCellRow(track,vCells[iCell+1].Index());
+ ConnectCells( fSector->GetTrackCellIRow(track,vCells[iCell].Index()),c1,
+ fSector->GetTrackCellIRow(track,vCells[iCell+1].Index()),c2, color );
Double_t x1, y1, z1, x2, y2, z2;
{
Double_t xyz[3] = {row1.X(), c1.Y(), c1.Z()};
Sec2View(x2, y2, &vx2, &vy2 );
fLine.SetLineColor(color);
- fLine.SetLineWidth(1);
+ fLine.SetLineWidth(width);
- fZY->cd();
+ fZX->cd();
fLine.DrawLine(z1,vy1, z2, vy2 );
}
fLine.SetLineWidth(1);
+ delete[] vCells;
}
//-*- Mode: C++ -*-
// @(#) $Id$
-//* This file is property of and copyright by the ALICE HLT Project *
-//* ALICE Experiment at CERN, All rights reserved. *
-//* See cxx source for full Copyright notice *
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* See cxx source for full Copyright notice *
+
+//* *
+//* AliHLTTPCCADisplay class is a debug utility. *
+//* It is not used in the normal data processing. *
+//* *
#ifndef ALIHLTTPCCADISPLAY_H
#define ALIHLTTPCCADISPLAY_H
class AliHLTTPCCACell;
class AliHLTTPCCATrack;
-#include "TCanvas.h"
+class TCanvas;
#include "TArc.h"
#include "TLine.h"
#include "TPolyLine.h"
protected:
- TCanvas *fXY, *fZY; // two views
+ TCanvas *fYX, *fZX; // two views
Bool_t fAsk; // flag to ask for the pressing key
Bool_t fSectorView; // switch between sector/TPC zoomv
AliHLTTPCCATracker *fSector; // current CA tracker, includes sector geometry
TCrown fCrown; //!
TLatex fLatex; //!
+ class AliHLTTPCCADisplayTmpCell{
+ public:
+ Int_t &Index(){ return fIndex; }
+ Double_t &S(){ return fS; }
+
+ static Bool_t CompareCellDS( const AliHLTTPCCADisplayTmpCell &a,
+ const AliHLTTPCCADisplayTmpCell &b )
+ {
+ return (a.fS < b.fS);
+ }
+ protected:
+ Int_t fIndex; // cell index
+ Double_t fS; // cell position on the track
+ };
+
+
ClassDef(AliHLTTPCCADisplay,1);
};
#include "AliHLTTPCCAHit.h"
-ClassImp(AliHLTTPCCAHit);
+ClassImp(AliHLTTPCCAHit)
-void AliHLTTPCCAHit::Set( Int_t ID, Double_t Y, Double_t Z,
- Double_t ErrY, Double_t ErrZ )
+void AliHLTTPCCAHit::Dummy()
{
- // set parameters
- fID = ID;
- fY = Y;
- fZ = Z;
- fErrY = ErrY;
- fErrZ = ErrZ;
+ // do nothing
}
#ifndef ALIHLTTPCCAHIT_H
#define ALIHLTTPCCAHIT_H
-
#include "Rtypes.h"
/**
* @class AliHLTTPCCAHit
+ *
+ * The AliHLTTPCCAHit class is the internal representation
+ * of the TPC clusters for the AliHLTTPCCATracker algorithm.
+ *
*/
class AliHLTTPCCAHit
{
public:
AliHLTTPCCAHit(): fY(0),fZ(0),fErrY(0),fErrZ(0),fID(0){;}
+ virtual ~AliHLTTPCCAHit(){}
Float_t &Y(){ return fY; }
Float_t &Z(){ return fZ; }
void Set( Int_t ID, Double_t Y, Double_t Z,
Double_t ErrY, Double_t ErrZ );
-
protected:
+
Float_t fY, fZ; // Y and Z position of the TPC cluster
Float_t fErrY, fErrZ; // position errors
- Int_t fID; // external ID of this hit,
+ Int_t fID; // external unique ID of this hit,
// used as cluster index in track->hit reference array
-
+ private:
+
+ void Dummy(); // to make rulechecker happy by having something in .cxx file
ClassDef(AliHLTTPCCAHit,1);
};
+
+inline void AliHLTTPCCAHit::Set( Int_t ID, Double_t Y, Double_t Z,
+ Double_t ErrY, Double_t ErrZ )
+{
+ //* set parameters
+ fID = ID;
+ fY = Y;
+ fZ = Z;
+ fErrY = ErrY;
+ fErrZ = ErrZ;
+}
+
+
#endif
#include "AliHLTTPCCAOutTrack.h"
-ClassImp(AliHLTTPCCAOutTrack);
+ClassImp(AliHLTTPCCAOutTrack)
+
+void AliHLTTPCCAOutTrack::Dummy()
+{
+}
/**
* @class AliHLTTPCCAOutTrack
+ * AliHLTTPCCAOutTrack class is used to store the final
+ * reconstructed tracks which will be then readed
+ * by the AliHLTTPCCATrackerComponent
+ *
+ * The class contains no temporary variables, etc.
+ *
*/
class AliHLTTPCCAOutTrack
{
public:
AliHLTTPCCAOutTrack():fFirstHitRef(0),fNHits(0),fParam(){}
-
+ virtual ~AliHLTTPCCAOutTrack(){}
+
Int_t &NHits() { return fNHits; }
Int_t &FirstHitRef() { return fFirstHitRef; }
AliHLTTPCCATrackPar &Param() { return fParam; }
Int_t fNHits; // number of track hits
AliHLTTPCCATrackPar fParam;// fitted track parameters
+ private:
+
+ void Dummy(); // to make rulechecker happy by having something in .cxx file
+
ClassDef(AliHLTTPCCAOutTrack,1);
};
#include "TMath.h"
-ClassImp(AliHLTTPCCAParam);
+ClassImp(AliHLTTPCCAParam)
AliHLTTPCCAParam::AliHLTTPCCAParam()
- : fISec(0),fNRows(63),fRowXFirst(85.225), fRowXStep(0.75),fAlpha(0.174533), fDAlpha(0.349066),
+ : fISec(0),fNRows(63),fAlpha(0.174533), fDAlpha(0.349066),
fCosAlpha(0), fSinAlpha(0), fAngleMin(0), fAngleMax(0), fRMin(83.65), fRMax(133.3),
fZMin(0.0529937), fZMax(249.778), fErrZ(0.228808), fErrX(0), fErrY(0),fPadPitch(0.4),fBz(-5.),
- fCellConnectionFactor(5), fTrackChiCut(6), fTrackChi2Cut(0), fMaxTrackMatchDRow(3),
+ fCellConnectionFactor(3), fTrackConnectionFactor(5), fTrackChiCut(6), fTrackChi2Cut(0), fMaxTrackMatchDRow(4),
fYErrorCorrection(0.33), fZErrorCorrection(0.45)
{
Update();
}
void AliHLTTPCCAParam::Initialize( Int_t iSec,
- Int_t NRows,
- Double_t RowXFirst, Double_t RowXStep,
+ Int_t NRows, Double_t RowX[],
Double_t Alpha, Double_t DAlpha,
Double_t RMin, Double_t RMax,
Double_t ZMin, Double_t ZMax,
fErrZ = ZSigma;
fBz = Bz;
fNRows = NRows;
- fRowXFirst = RowXFirst;
- fRowXStep = RowXStep;
+ for( Int_t irow=0; irow<NRows; irow++ ){
+ fRowX[irow] = RowX[irow];
+ }
+
Update();
}
}
void AliHLTTPCCAParam::Sec2Global( Double_t x, Double_t y, Double_t z,
- Double_t *X, Double_t *Y, Double_t *Z ) const
+ Double_t *X, Double_t *Y, Double_t *Z ) const
{
// conversion of coorinates sector->global
*X = x*fCosAlpha - y*fSinAlpha;
* @class ALIHLTTPCCAParam
* parameters of the CATracker, including geometry information
* and some reconstructon constants.
+ *
+ * The class is under construction.
+ *
*/
class AliHLTTPCCAParam
{
AliHLTTPCCAParam();
virtual ~AliHLTTPCCAParam(){;}
- void Initialize( Int_t iSec, Int_t NRows, Double_t RowXFirst, Double_t RowXStep,
+ void Initialize( Int_t iSec, Int_t NRows, Double_t RowX[],
Double_t Alpha, Double_t DAlpha,
Double_t RMin, Double_t RMax, Double_t ZMin, Double_t ZMax,
Double_t PadPitch, Double_t ZSigma, Double_t Bz );
Double_t *X, Double_t *Y, Double_t *Z ) const;
Int_t &ISec(){ return fISec;}
Int_t &NRows(){ return fNRows;}
- Double_t &RowXFirst(){ return fRowXFirst; }
- Double_t &RowXStep(){ return fRowXStep; }
+
+ Double_t &RowX( Int_t iRow ){ return fRowX[iRow]; }
Double_t &Alpha(){ return fAlpha;}
Double_t &DAlpha(){ return fDAlpha;}
Double_t &Bz(){ return fBz;}
Double_t &CellConnectionFactor(){ return fCellConnectionFactor; }
+ Double_t &TrackConnectionFactor(){ return fTrackConnectionFactor; }
Double_t &TrackChiCut() { return fTrackChiCut; }
- Double_t TrackChi2Cut(){ return fTrackChi2Cut; }
+ Double_t &TrackChi2Cut(){ return fTrackChi2Cut; }
Int_t &MaxTrackMatchDRow(){ return fMaxTrackMatchDRow; }
Double_t &YErrorCorrection(){ return fYErrorCorrection; }
Double_t &ZErrorCorrection(){ return fZErrorCorrection; }
Int_t fISec; // sector number
Int_t fNRows; // number of rows
- Double_t fRowXFirst, fRowXStep; // X coordinate of the first row and step between rows
Double_t fAlpha, fDAlpha; // sector angle and angular size
Double_t fCosAlpha, fSinAlpha;// sign and cosine of the sector angle
Double_t fAngleMin, fAngleMax; // minimal and maximal angle
Double_t fBz; // magnetic field value (only constant field can be used)
Double_t fCellConnectionFactor; // allowed distance in Chi^2/3.5 for neighbouring cells
+ Double_t fTrackConnectionFactor; // allowed distance in Chi^2/3.5 for neighbouring tracks
Double_t fTrackChiCut; // cut for track Sqrt(Chi2/NDF);
Double_t fTrackChi2Cut;// cut for track Chi^2/NDF
Int_t fMaxTrackMatchDRow;// maximal jump in TPC row for connecting track segments
Double_t fYErrorCorrection;// correction factor for Y error of input clusters
Double_t fZErrorCorrection;// correction factor for Z error of input clusters
+ Double_t fRowX[200];// X-coordinate of rows
+
ClassDef(AliHLTTPCCAParam,1);
};
#include "AliHLTTPCCARow.h"
-ClassImp(AliHLTTPCCARow);
+ClassImp(AliHLTTPCCARow)
AliHLTTPCCARow::AliHLTTPCCARow() :fHits(0),fCells(0),fCellHitPointers(0),fNHits(0),fNCells(0),fX(0)
{
// clear memory
delete[] fHits;
delete[] fCells;
- delete[] fCellHitPointers;
fHits = 0;
fCells = 0;
fCellHitPointers = 0;
/**
* @class ALIHLTTPCCARow
- * hit and cells container for one TPC row
+ *
+ * The ALIHLTTPCCARow class is a hit and cells container for one TPC row.
+ * It is the internal class of the AliHLTTPCCATracker algorithm.
+ *
*/
class AliHLTTPCCARow
{
#include "AliHLTTPCCATrack.h"
-ClassImp(AliHLTTPCCATrack);
+ClassImp(AliHLTTPCCATrack)
+
+void AliHLTTPCCATrack::Dummy()
+{
+}
#ifndef ALIHLTTPCCATRACK_H
#define ALIHLTTPCCATRACK_H
-
-#include "Rtypes.h"
#include "AliHLTTPCCATrackPar.h"
/**
* @class ALIHLTTPCCAtrack
+ *
+ * The class describes the [partially] reconstructed TPC track [candidate].
+ * The class is dedicated for internal use by the AliHLTTPCCATracker algorithm.
+ *
*/
class AliHLTTPCCATrack
{
public:
AliHLTTPCCATrack():fUsed(0),fNCells(0),fIFirstCell(0),fParam(){}
+ virtual ~AliHLTTPCCATrack(){}
static bool CompareSize(const AliHLTTPCCATrack &t1, const AliHLTTPCCATrack &t2 ){
return t2.fNCells<t1.fNCells;
AliHLTTPCCATrackPar fParam; // fitted track parameters
+ void Dummy(); // to make rulechecker happy by having something in .cxx file
+
ClassDef(AliHLTTPCCATrack,1);
};
#include "AliHLTTPCCATrackPar.h"
#include "TMath.h"
-ClassImp(AliHLTTPCCATrackPar);
+ClassImp(AliHLTTPCCATrackPar)
void AliHLTTPCCATrackPar::Init()
{
for( Int_t i=0; i<7; i++ ) fP[i] = 0;
for( Int_t i=0; i<28; i++ ) fC[i] = 0;
- fC[0] = fC[2] = fC[5] = 10000;
- fC[9] = fC[14] = fC[20] = 10000.;
+ fC[0] = fC[2] = fC[5] = 100.;
+ fC[9] = fC[14] = fC[20] = 100.;
fC[27] = 10.;
fChi2 = 0;
fNDF = -5;
void AliHLTTPCCATrackPar::Normalize( Double_t Direction[3] )
{
- //* Normalize the track
+ //* Normalize the track directions
+ //* (Px,Py,Pz,qp)-> (Px,Py,Pz,qp)/sqrt(Px²+Py²+Pz²)
+ //*
Double_t p2 = fP[3]*fP[3] + fP[4]*fP[4] + fP[5]*fP[5];
if( p2<1.e-4 ) return;
Double_t AliHLTTPCCATrackPar::GetDsToPointBz( Double_t Bz, const Double_t xyz[3], const Double_t *T0 ) const
{
- //* Get dS to a certain space point for Bz field
+ //* Get dS distance to the given space point for Bz field
+ //*
+
const Double_t kCLight = 0.000299792458;
Double_t bq = Bz*T0[6]*kCLight;
Double_t pt2 = T0[3]*T0[3] + T0[4]*T0[4];
T0[5] = T0[5];
T0[6] = T0[6];
-
- Double_t mJ[7][7] = { {1,0,0, sB, cB, 0, dsB*px + dcB*py },
- {0,1,0, -cB, sB, 0, - dcB*px + dsB*py },
- {0,0,1, 0, 0, S, 0 },
- {0,0,0, c, s, 0, (-s*px + c*py)*bs },
- {0,0,0, -s, c, 0, (-c*px - s*py)*bs },
- {0,0,0, 0, 0, 1, 0 },
- {0,0,0, 0, 0, 0, 1 } };
-
- for( Int_t i=0; i<7; i++){
- fP[i] = T0[i];
- for( Int_t j=0; j<7; j++) fP[i] += mJ[i][j]*d[j];
- }
-
- Double_t mA[7][7];
- for( Int_t k=0,i=0; i<7; i++)
- for( Int_t j=0; j<=i; j++, k++ ) mA[i][j] = mA[j][i] = fC[k];
-
- Double_t mJC[7][7];
- for( Int_t i=0; i<7; i++ )
- for( Int_t j=0; j<7; j++ ){
- mJC[i][j]=0;
- for( Int_t k=0; k<7; k++ ) mJC[i][j]+=mJ[i][k]*mA[k][j];
- }
+ //* The Jacobian matrix is:
+ //* J[7][7] = { {1,0,0, sB, cB, 0, dsB*px + dcB*py },
+ //* {0,1,0, -cB, sB, 0, - dcB*px + dsB*py },
+ //* {0,0,1, 0, 0, S, 0 },
+ //* {0,0,0, c, s, 0, (-s*px + c*py)*bs },
+ //* {0,0,0, -s, c, 0, (-c*px - s*py)*bs },
+ //* {0,0,0, 0, 0, 1, 0 },
+ //* {0,0,0, 0, 0, 0, 1 } };
+ //*
+ //* below the fP=T0+J*(fP-T0) and fC=J*fC*Jt operations are performed
+ //*
+
+ Double_t h0 = dsB*px + dcB*py;
+ Double_t h1 = - dcB*px + dsB*py ;
+ Double_t h3 = (-s*px + c*py)*bs ;
+ Double_t h4 = (-c*px - s*py)*bs ;
+
+
+ fP[0] = T0[0] + d[0] + sB*d[3] + cB*d[4] + h0*d[6];
+ fP[1] = T0[1] + d[1] - cB*d[3] + sB*d[4] + h1*d[6];
+ fP[2] = T0[2] + d[2] + S*d[5];
+ fP[3] = T0[3] + c*d[3] + s*d[4] + h3*d[6];
+ fP[4] = T0[4] - s*d[3] + c*d[4] + h4*d[6];
+ fP[5] = T0[5] + d[5];
+ fP[6] = T0[6] + d[6];
- for( Int_t k=0,i=0; i<7; i++)
- for( Int_t j=0; j<=i; j++, k++ ){
- fC[k] = 0;
- for( Int_t l=0; l<7; l++ ) fC[k]+=mJC[i][l]*mJ[j][l];
- }
+
+ Double_t
+ c00 = fC[ 0],
+ c01 = fC[ 1], c02 = fC[ 2],
+ c03 = fC[ 3], c04 = fC[ 4], c05 = fC[ 5],
+ c06 = fC[ 6], c07 = fC[ 7], c08 = fC[ 8], c09 = fC[ 9],
+ c10 = fC[10], c11 = fC[11], c12 = fC[12], c13 = fC[13], c14 = fC[14],
+ c15 = fC[15], c16 = fC[16], c17 = fC[17], c18 = fC[18], c19 = fC[19], c20 = fC[20],
+ c21 = fC[21], c22 = fC[22], c23 = fC[23], c24 = fC[24], c25 = fC[25], c26 = fC[26], c27 = fC[27];
+
+ fC[ 0] = c00 + 2*c10*cB + c14*cB*cB + 2*c21*h0 + 2*c25*cB*h0 + c27*h0*h0 + 2*c06*sB + 2*c13*cB*sB + 2*c24*h0*sB + c09*sB*sB;
+ fC[ 1] = c01 - c06*cB + c21*h1 + c10*sB + sB*(c07 - c09*cB + c24*h1 + c13*sB)
+ + cB*(c11 - c13*cB + c25*h1 + c14*sB) + h0*(c22 - c24*cB + c27*h1 + c25*sB);
+ fC[ 2] = c02 - 2*c07*cB + c09*cB*cB + 2*c22*h1 - 2*c24*cB*h1 + c27*h1*h1
+ + 2*c11*sB - 2*c13*cB*sB + 2*c25*h1*sB + c14*sB*sB;
+ fC[ 3] = c03 + c12*cB + c23*h0 + c15*S + c19*cB*S + c26*h0*S + c08*sB + c18*S*sB;
+ fC[ 4] = c04 + c16*S - cB*(c08 + c18*S) + h1*(c23 + c26*S) + (c12 + c19*S)*sB;
+ fC[ 5] = c05 + S*(2*c17 + c20*S);
+ fC[ 6] = c21*h3 + c25*cB*h3 + c27*h0*h3 + c10*s + c14*cB*s + c25*h0*s + c24*h3*sB + c13*s*sB + c*(c06 + c13*cB + c24*h0 + c09*sB);
+ fC[ 7] = c*c07 + c22*h3 + c11*s - cB*(c*c09 + c24*h3 + c13*s) +
+ h1*(c*c24 + c27*h3 + c25*s) + (c*c13 + c25*h3 + c14*s)*sB;
+ fC[ 8] = c23*h3 + c12*s + c26*h3*S + c19*s*S + c*(c08 + c18*S);
+ fC[ 9] = c*c*c09 + c27*h3*h3 + 2*c*(c24*h3 + c13*s) + s*(2*c25*h3 + c14*s);
+ fC[10] = c21*h4 + c25*cB*h4 + c27*h0*h4 - c06*s - c13*cB*s - c24*h0*s
+ + c24*h4*sB - c09*s*sB + c*(c10 + c14*cB + c25*h0 + c13*sB);
+ fC[11] = c22*h4 - c24*cB*h4 + c27*h1*h4 - c07*s + c09*cB*s - c24*h1*s +
+ c25*h4*sB - c13*s*sB + c*(c11 - c13*cB + c25*h1 + c14*sB);
+ fC[12] = c23*h4 - c08*s + c26*h4*S - c18*s*S + c*(c12 + c19*S);
+ fC[13] = c*c*c13 + c27*h3*h4 - s*(c24*h3 - c25*h4 + c13*s) + c*(c25*h3 + c24*h4 - c09*s + c14*s);
+ fC[14] = c*c*c14 + 2*c*c25*h4 + c27*h4*h4 - 2*c*c13*s - 2*c24*h4*s + c09*s*s;
+ fC[15] = c15 + c19*cB + c26*h0 + c18*sB;
+ fC[16] = c16 - c18*cB + c26*h1 + c19*sB;
+ fC[17] = c17 + c20*S;
+ fC[18] = c*c18 + c26*h3 + c19*s;
+ fC[19] = c*c19 + c26*h4 - c18*s;
+ fC[20] = c20;
+ fC[21] = c21 + c25*cB + c27*h0 + c24*sB;
+ fC[22] = c22 - c24*cB + c27*h1 + c25*sB;
+ fC[23] = c23 + c26*S;
+ fC[24] = c*c24 + c27*h3 + c25*s;
+ fC[25] = c*c25 + c27*h4 - c24*s;
+ fC[26] = c26;
+ fC[27] = c27;
}
void AliHLTTPCCATrackPar::TransportBz( Double_t Bz, Double_t dS )
}
-void AliHLTTPCCATrackPar::Filter( const Double_t m[3], const Double_t V[6], const Double_t V1[6] )
+void AliHLTTPCCATrackPar::Filter( const Double_t m[], const Double_t V[], const Double_t G[6] )
{
- //* !
+ //* Add the measurement m to the track using the Kalman Filter mathematics
+ //* m[3] is the measurement
+ //* V[6] is the low-triangular covariance matrix
+ //* G[6] is the track->measurement "connection matrix", additional to V[]
+ //*
+
Double_t
c00 = fC[ 0],
c10 = fC[ 1], c11 = fC[ 2],
c50 = fC[15], c51 = fC[16], c52 = fC[17],
c60 = fC[21], c61 = fC[22], c62 = fC[23];
- double
+ Double_t
z0 = m[0]-fP[0],
z1 = m[1]-fP[1],
z2 = m[2]-fP[2];
- Double_t mS[6] = { c00+V[0]+V1[0], c10+V[1]+V1[1], c11+V[2]+V1[2],
- c20+V[3]+V1[3], c21+V[4]+V1[4], c22+V[5]+V1[5] };
+ Double_t mS[6] = { c00+V[0]+G[0], c10+V[1]+G[1], c11+V[2]+G[2],
+ c20+V[3]+G[3], c21+V[4]+G[4], c22+V[5]+G[5] };
Double_t mSi[6];
mSi[0] = mS[4]*mS[4] - mS[2]*mS[5];
mSi[1] = mS[1]*mS[5] - mS[3]*mS[4];
void AliHLTTPCCATrackPar::Rotate( Double_t alpha )
{
- //* !
+ //* Rotate the track parameters on the alpha angle
+
Double_t cA = TMath::Cos( alpha );
Double_t sA = TMath::Sin( alpha );
Double_t x= fP[0], y= fP[1], px= fP[3], py= fP[4];
void AliHLTTPCCATrackPar::ConvertTo5( Double_t alpha, Double_t T[], Double_t C[] )
-const {
- //* !
+const
+{
+ //* Convert the track parameterisation to {y,z,ty,tz,q/p,x}
+ //* The result is stored in T[], corresponding covariance matrix in C[]
+ //*
+ //* The method is used for debuging
+ //*
+
AliHLTTPCCATrackPar t = *this;
t.Rotate(alpha);
Double_t
//-*- Mode: C++ -*-
// @(#) $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. *
- * See cxx source for full Copyright notice */
#ifndef ALIHLTTPCCATRACKPAR_H
#define ALIHLTTPCCATRACKPAR_H
/**
* @class AliHLTTPCCATrackPar
+ *
+ * AliHLTTPCCATrackPar class describes the track parametrisation
+ * which is used by the AliHLTTPCCATracker slice tracker.
+ * The class is under development.
+ *
*/
-class AliHLTTPCCATrackPar {
+class AliHLTTPCCATrackPar
+{
public:
- AliHLTTPCCATrackPar(): fChi2(0), fNDF(0){;}
+ AliHLTTPCCATrackPar(): fChi2(0), fNDF(0){}
+ virtual ~AliHLTTPCCATrackPar(){}
Double_t *Par(){ return fP; }
Double_t *Cov(){ return fC; }
Double_t GetDsToPointBz( Double_t Bz, const Double_t xyz[3] ) const;
Double_t GetDsToPointBz( Double_t Bz, const Double_t xyz[3], const Double_t *T0 ) const;
- void TransportBz( Double_t Bz, const Double_t xyz[3] ){
+ void TransportBz( Double_t Bz, const Double_t xyz[3] )
+ {
TransportBz( Bz,GetDsToPointBz(Bz, xyz)) ;
}
- void TransportBz( Double_t Bz, const Double_t xyz[3], Double_t *T0 ){
+ void TransportBz( Double_t Bz, const Double_t xyz[3], Double_t *T0 )
+ {
TransportBz( Bz,GetDsToPointBz(Bz, xyz, T0), T0) ;
}
- void TransportBz( Double_t Bz, Double_t x, Double_t y, Double_t z ){
+ void TransportBz( Double_t Bz, Double_t x, Double_t y, Double_t z )
+ {
Double_t xyz[3] = {x,y,z};
TransportBz(Bz, xyz);
}
void GetConnectionMatrix( Double_t Bz, const Double_t p[3], Double_t G[6], const Double_t *T0 ) const ;
- void GetConnectionMatrix( Double_t Bz, const Double_t p[3], Double_t G[6] ) const {
+ void GetConnectionMatrix( Double_t Bz, const Double_t p[3], Double_t G[6] ) const
+ {
GetConnectionMatrix( Bz, p, G, fP );
}
private:
- Double_t fP[7]; // parameters: X, Y, Z, ex, ey, ez, q/P
- Double_t fC[28]; // Covariance matrix
- Double_t fChi2; // Chi^2
- Int_t fNDF; // NDF
+ Double_t fP[7]; // track parameters: X, Y, Z, ex, ey, ez, q/P
+ Double_t fC[28]; // the covariance matrix in the low-triangular form
+ Double_t fChi2; // the chi^2 value
+ Int_t fNDF; // the Number of Degrees of Freedom
ClassDef(AliHLTTPCCATrackPar, 0);
#include "TMath.h"
//#include "Riostream.h"
#include <vector>
-#ifndef __SUNPRO_CC
#include <algo.h>
-#endif
-
+#include "TStopwatch.h"
//#define DRAW
#ifdef DRAW
#include "AliHLTTPCCADisplay.h"
#include "TApplication.h"
-#include "TROOT.h"
-#include "TSystem.h"
#endif //DRAW
-ClassImp(AliHLTTPCCATracker);
+ClassImp(AliHLTTPCCATracker)
AliHLTTPCCATracker::AliHLTTPCCATracker()
- :fParam(),fRows(0),fOutTrackHits(0),fNOutTrackHits(0),fOutTracks(0),fNOutTracks(0),fTrackCells(0),fNHitsTotal(0),fTracks(0),fNTracks(0)
+ :fParam(),fRows(0),fOutTrackHits(0),fNOutTrackHits(0),fOutTracks(0),fNOutTracks(0),fTrackCells(0),fNHitsTotal(0),fTracks(0),fNTracks(0),fCellHitPointers(0)
{
// constructor
fRows = new AliHLTTPCCARow[fParam.NRows()];
}
AliHLTTPCCATracker::AliHLTTPCCATracker( const AliHLTTPCCATracker& )
- :fParam(),fRows(0),fOutTrackHits(0),fNOutTrackHits(0),fOutTracks(0),fNOutTracks(0),fTrackCells(0),fNHitsTotal(0),fTracks(0),fNTracks(0)
+ :fParam(),fRows(0),fOutTrackHits(0),fNOutTrackHits(0),fOutTracks(0),fNOutTracks(0),fTrackCells(0),fNHitsTotal(0),fTracks(0),fNTracks(0),fCellHitPointers(0)
{
// dummy
}
AliHLTTPCCATracker &AliHLTTPCCATracker::operator=( const AliHLTTPCCATracker& )
{
// dummy
+ fRows=0;
+ fOutTrackHits=0;
+ fOutTracks=0;
+ fNOutTracks=0;
+ fTrackCells=0;
return *this;
}
fParam.Update();
fRows = new AliHLTTPCCARow[fParam.NRows()];
for( Int_t irow=0; irow<fParam.NRows(); irow++ ){
- fRows[irow].X() = fParam.RowXFirst() + irow*fParam.RowXStep();
+ fRows[irow].X() = fParam.RowX(irow);
}
StartEvent();
}
delete[] fTrackCells;
delete[] fOutTrackHits;
delete[] fOutTracks;
+ delete[] fCellHitPointers;
fTracks = 0;
fTrackCells = 0;
fOutTrackHits = 0;
void AliHLTTPCCATracker::Reconstruct()
{
// reconstruction of event
+ fTimers[0] = 0;
+ fTimers[1] = 0;
+ fTimers[2] = 0;
+ fTimers[3] = 0;
+ //cout<<"Find Cells..."<<endl;
FindCells();
- FindTracks();
-}
+ //cout<<"Find Tracks..."<<endl;
+ FindTracks();
+ //cout<<"Find Tracks OK"<<endl;
+ }
void AliHLTTPCCATracker::FindCells()
{
// cell finder - neighbouring hits are grouped to cells
+ TStopwatch timer;
+ Bool_t *vUsed = new Bool_t [fNHitsTotal];
+ fCellHitPointers = new Int_t [fNHitsTotal];
+ AliHLTTPCCACell *vCells = new AliHLTTPCCACell[fNHitsTotal];
+
+ Int_t lastCellHitPointer = 0;
for( Int_t irow=0; irow<fParam.NRows(); irow++ ){
AliHLTTPCCARow &row=fRows[irow];
Int_t nHits = row.NHits();
if( nHits<1 ) continue;
- row.CellHitPointers() = new Int_t[ nHits ];
+ row.CellHitPointers() = fCellHitPointers + lastCellHitPointer;
Int_t nPointers = 0;
- std::vector<AliHLTTPCCACell> vCells;
- Bool_t vUsed[10000];
+ Int_t nCells = 0;
+
for (Int_t ih = 0; ih<nHits; ih++) vUsed[ih] = 0;
-
+
for (Int_t ih = 0; ih<nHits; ih++){
if( vUsed[ih] ) continue;
// cell start
- AliHLTTPCCACell cell;
+ AliHLTTPCCACell &cell = vCells[nCells++];
cell.FirstHitRef() = nPointers;
cell.NHits() = 1;
cell.IDown() = -1;
if( vUsed[j] ) continue;
AliHLTTPCCAHit &h1 = row.Hits()[j];
Double_t dy = TMath::Abs(h.Y() - h1.Y() );
- if( dy>(h.ErrY()+h1.ErrY())*4. ) break;
+ if( dy>(h.ErrY()+h1.ErrY())*3.5*2 ) break;
Double_t dz = TMath::Abs(h.Z() - h1.Z() );
- if( dz>(h.ErrZ()+h1.ErrZ())*4. ) continue;
+ if( dz>(h.ErrZ()+h1.ErrZ())*3.5*2 ) continue;
Double_t d2 = dz*dz+dy*dy;
if( d2<d2min ){
d2min = d2;
cell.Z() = .5*(h.Z() + h1.Z());
cell.ErrY() = .5*(TMath::Abs(h.Y() - h1.Y())/3 + h.ErrY() + h1.ErrY());
cell.ErrZ() = .5*(TMath::Abs(h.Z() - h1.Z())/3 + h.ErrZ() + h1.ErrZ());
- vCells.push_back(cell);
}
- row.Cells() = new AliHLTTPCCACell[vCells.size()];
- row.NCells() = vCells.size();
- for( Int_t i=0; i<vCells.size(); i++ ) row.Cells()[i]=vCells[i];
+ row.Cells() = new AliHLTTPCCACell[nCells];
+ row.NCells() = nCells;
+ lastCellHitPointer += nPointers;
+ for( Int_t i=0; i<nCells; i++ ) row.Cells()[i]=vCells[i];
}
+ delete[] vUsed;
+ delete[] vCells;
+ timer.Stop();
+ fTimers[0] = timer.CpuTime();
}
#ifdef DRAW
if( !gApplication ){
TApplication *myapp = new TApplication("myapp",0,0);
- }
+ }
+ //AliHLTTPCCADisplay::Instance().Init();
AliHLTTPCCADisplay::Instance().SetCurrentSector( this );
AliHLTTPCCADisplay::Instance().DrawSector( this );
- //for (Int_t i = 0; i<fHits.size(); i++) AliHLTTPCCADisplay::Instance().DrawHit( i );
- //cout<<"hits"<<endl;
- //AliHLTTPCCADisplay::Instance().Ask();
- //AliHLTTPCCADisplay::Instance().Clear();
- //AliHLTTPCCADisplay::Instance().DrawSector( this );
+ for( Int_t iRow=0; iRow<fParam.NRows(); iRow++ )
+ for (Int_t i = 0; i<fRows[iRow].NHits(); i++)
+ AliHLTTPCCADisplay::Instance().DrawHit( iRow, i );
+ cout<<"hits"<<endl;
+ AliHLTTPCCADisplay::Instance().Ask();
+ AliHLTTPCCADisplay::Instance().Clear();
+ AliHLTTPCCADisplay::Instance().DrawSector( this );
for( Int_t iRow=0; iRow<fParam.NRows(); iRow++ )
for (Int_t i = 0; i<fRows[iRow].NCells(); i++)
AliHLTTPCCADisplay::Instance().DrawCell( iRow, i );
- //cout<<"cells"<<endl;
- AliHLTTPCCADisplay::Instance().Ask();
+ cout<<"cells"<<endl;
+ AliHLTTPCCADisplay::Instance().Ask();
Int_t nConnectedCells = 0;
#endif
std::vector<Int_t> vTrackCells;
fTrackCells = new Int_t[2*fNHitsTotal];
+ TStopwatch timer1;
+ Double_t factor2 = 3.5*fParam.CellConnectionFactor()*3.5*fParam.CellConnectionFactor();
+
for( Int_t iRow1=0; iRow1<fParam.NRows()-1; iRow1++ ){
AliHLTTPCCARow &row1 = fRows[iRow1];
Int_t lastRow2 = iRow1+3;
for (Int_t i2 = 0; i2<row2.NCells(); i2++){
AliHLTTPCCACell *c2 = &(row2.Cells()[i2]);
Double_t sy2 = c2->ErrY()*c2->ErrY();
+ Double_t dy = c1->Y()-c2->Y();
+ if( dy*dy>factor2*(sy1+sy2) ){
+ if( dy>0 ) continue;
+ else break;
+ }
Double_t sz2 = c2->ErrZ()*c2->ErrZ();
- Double_t dist1 = sqrt( (c1->Y()-c2->Y())*(c1->Y()-c2->Y())/(sy1+sy2) );
- Double_t dist2 = sqrt( (c1->Z()-c2->Z())*(c1->Z()-c2->Z())/(sz1+sz2) );
- if( dist1>3.5*fParam.CellConnectionFactor() ) continue;
- if( dist2>3.5*fParam.CellConnectionFactor() ) continue;
+ Double_t dz = c1->Z()-c2->Z();
+ if( dz*dz>factor2*(sz1+sz2) ) continue;
if( c1->IUp() ==-1 ) c1->IUp() = (i2<<8)+iRow2;
else c1->IUp() = -2;
if( c2->IDown() ==-1 ) c2->IDown() = (i1<<8)+iRow1;
}
}
+ timer1.Stop();
+ fTimers[1] = timer1.CpuTime();
+
+ TStopwatch timer2;
+
Int_t nOutTrackHits = 0;
Int_t nTrackCells = 0;
for( Int_t iRow1=0; iRow1<fParam.NRows(); iRow1++ ){
- AliHLTTPCCARow &row1 = fRows[iRow1];
+ AliHLTTPCCARow &row1 = fRows[iRow1];
for (Int_t i1 = 0; i1<row1.NCells(); i1++){
AliHLTTPCCACell *c1 = &(row1.Cells()[i1]);
- if( c1->IDown()==-2 || c1->IUp()==-2 ) continue;
+ //if( c1->IDown()==-2 || c1->IUp()==-2 ) continue;
if( c1->IUsed()>0 ) continue;
c1->IUsed() = 1;
AliHLTTPCCATrack track;
AliHLTTPCCACell *next = &(row2.Cells()[last->IUp()>>8]);
if( next->IDown()==-2 || next->IUp()==-2 ) break;
#ifdef DRAW
- AliHLTTPCCADisplay::Instance().ConnectCells( lastRow,*last,iRow2,*next );
+ AliHLTTPCCADisplay::Instance().ConnectCells( lastRow,*last,iRow2,*next );
nConnectedCells++;
#endif
next->IUsed() = 1;
vTracks.push_back(track);
}
}
+
+ timer2.Stop();
+ fTimers[2] = timer2.CpuTime();
Int_t nTracks = vTracks.size();
std::sort( vTracks.begin(), vTracks.end(), AliHLTTPCCATrack::CompareSize);
+
+#ifdef DRAW
+ if( nConnectedCells>0 ) AliHLTTPCCADisplay::Instance().Ask();
+#endif
+
fTracks = new AliHLTTPCCATrack[nTracks];
fNTracks = 0;
vTrackCells.clear();
- Int_t * vMatchedTracks = new Int_t[nTracks];
+ Int_t *vMatchedTracks = new Int_t[nTracks];
+
+ //cout<<"nTracks = "<<nTracks<<endl;
+ TStopwatch timer3;
+
for( Int_t itr=0; itr<nTracks; itr++ ){
AliHLTTPCCATrack &iTrack = vTracks[itr];
- if( iTrack.Used() ) continue;
+ if( iTrack.NCells()<3 ) break;
+
+#ifdef DRAW
FitTrack( iTrack );
- if( iTrack.Param().Chi2() > fParam.TrackChi2Cut()*iTrack.Param().NDF() ) continue;
+ //AliHLTTPCCADisplay::Instance().Ask();
+ AliHLTTPCCADisplay::Instance().DrawTrack( iTrack );
+ //AliHLTTPCCADisplay::Instance().Ask();
+#endif
+ if( iTrack.Used() ) continue;
+
+
+ FitTrack( iTrack, 1 );
+ if( iTrack.Param().Chi2() > fParam.TrackChi2Cut()*iTrack.Param().NDF() ) continue;
Int_t iFirstRow = GetTrackCellIRow( iTrack, 0);
Int_t iLastRow = GetTrackCellIRow( iTrack, iTrack.NCells()-1);
AliHLTTPCCACell *iFirstCell = &GetTrackCell( iTrack, 0);
- AliHLTTPCCACell *iLastCell = &GetTrackCell( iTrack, iTrack.NCells()-1);
-
+ AliHLTTPCCACell *iLastCell = &GetTrackCell( iTrack, iTrack.NCells()-1);
Bool_t updated = 1;
Int_t nMatched = 0;
- std::vector<Int_t> vMatchedCells;
+ std::vector<Int_t> vMatchedCellsFront;
+ std::vector<Int_t> vMatchedCellsBack;
while( updated ){
updated = 0;
- for( Int_t jtr=1; jtr<nTracks; jtr++ ){
+ for( Int_t jtr=itr+1; jtr<nTracks; jtr++ ){
AliHLTTPCCATrack &jTrack = vTracks[jtr];
if( jTrack.Used() ) continue;
Int_t jFirstRow = GetTrackCellIRow( jTrack, 0);
Double_t sz1 = iC->ErrZ()*iC->ErrZ();
Double_t sy2 = jC->ErrY()*jC->ErrY();
Double_t sz2 = jC->ErrZ()*jC->ErrZ();
- Double_t dist1 = sqrt( (dy)/(sy1+sy2) );
- Double_t dist2 = sqrt( (dz)/(sz1+sz2) );
- if( dist1>3.5*5*fParam.CellConnectionFactor() ) continue;
- if( dist2>3.5*5*fParam.CellConnectionFactor() ) continue;
+ Double_t dist1 = sqrt( (dy*dy)/(sy1+sy2) );
+ Double_t dist2 = sqrt( (dz*dz)/(sz1+sz2) );
+ if( dist1>3.5*fParam.TrackConnectionFactor() ) continue;
+ if( dist2>3.5*fParam.TrackConnectionFactor() ) continue;
}
AliHLTTPCCATrackPar t = iTrack.Param();
//t.Chi2() = 0;
if( iCase==0 ){
iFirstRow = jFirstRow;
iFirstCell = jFirstCell;
+ for( Int_t i=jTrack.NCells()-1; i>=0; i-- ){
+ vMatchedCellsBack.push_back(fTrackCells[jTrack.IFirstCell()+i]);
+ }
}else if( iCase ==1 ){
iFirstRow = jLastRow;
iFirstCell = jLastCell;
+ for( Int_t i=0; i<jTrack.NCells(); i++){
+ vMatchedCellsBack.push_back(fTrackCells[jTrack.IFirstCell()+i]);
+ }
}else if( iCase == 2 ){
iLastRow = jFirstRow;
iLastCell = jFirstCell;
+ for( Int_t i=jTrack.NCells()-1; i>=0; i-- ){
+ vMatchedCellsFront.push_back(fTrackCells[jTrack.IFirstCell()+i]);
+ }
}else{
iLastRow = jLastRow;
iLastCell = jLastCell;
+ for( Int_t i=0; i<jTrack.NCells(); i++){
+ vMatchedCellsFront.push_back(fTrackCells[jTrack.IFirstCell()+i]);
+ }
}
t.Normalize();
- for( Int_t i=0; i<jTrack.NCells(); i++){
- vMatchedCells.push_back(fTrackCells[jTrack.IFirstCell()+i]);
- }
//t.NDF()+= iTrack.Param().NDF();
//t.Chi2()+= iTrack.Param().Chi2();
iTrack.Param() = t;
updated = 1;
break;
}
- }
+ }// while updated
if(0){
Double_t t0[7];
AliHLTTPCCACell &c = row.Cells()[ind>>8];
nHits+=c.NHits();
}
- for( UInt_t i=0; i<vMatchedCells.size(); i++){
- Int_t ind = vMatchedCells[i];
+ for( UInt_t i=0; i<vMatchedCellsBack.size(); i++){
+ Int_t ind = vMatchedCellsBack[i];
AliHLTTPCCARow &row = fRows[ind%256];
AliHLTTPCCACell &c = row.Cells()[ind>>8];
nHits+=c.NHits();
}
-
- if( nHits<5 ){
+ for( UInt_t i=0; i<vMatchedCellsFront.size(); i++){
+ Int_t ind = vMatchedCellsFront[i];
+ AliHLTTPCCARow &row = fRows[ind%256];
+ AliHLTTPCCACell &c = row.Cells()[ind>>8];
+ nHits+=c.NHits();
+ }
+ Int_t nCells = iTrack.NCells()+vMatchedCellsBack.size()+vMatchedCellsFront.size();
+ if( nHits<5 || nCells<3){
for( Int_t i=0; i<nMatched; i++ ) vTracks[vMatchedTracks[i]].Used()=0;
continue;
}
iTrack.Used() = 1;
- Int_t oldNCells = vTrackCells.size();
+
+ AliHLTTPCCATrack &mTrack = fTracks[fNTracks++];
+ mTrack = iTrack;
+ mTrack.IFirstCell() = vTrackCells.size();
+ mTrack.NCells() = 0;
+
+ for( Int_t i=vMatchedCellsBack.size()-1; i>=0; i-- ){
+ vTrackCells.push_back(vMatchedCellsBack[i]);
+ mTrack.NCells()++;
+ }
for( Int_t i=0; i<iTrack.NCells() ; i++){
vTrackCells.push_back(fTrackCells[iTrack.IFirstCell()+i]);
- }
- iTrack.IFirstCell() = oldNCells;
- for( UInt_t i=0; i<vMatchedCells.size(); i++){
- vTrackCells.push_back(vMatchedCells[i]);
- iTrack.NCells()++;
- }
- fTracks[fNTracks++] = iTrack;
+ mTrack.NCells()++;
+ }
+ for( UInt_t i=0; i<vMatchedCellsFront.size(); i++){
+ vTrackCells.push_back(vMatchedCellsFront[i]);
+ mTrack.NCells()++;
+ }
nOutTrackHits+= nHits;
}
- delete [] vMatchedTracks;
+
+ timer3.Stop();
+ fTimers[3] = timer3.CpuTime();
+
+ delete[] vMatchedTracks;
//fTrackCells = new Int_t[vTrackCells.size()];
for( UInt_t i=0; i<vTrackCells.size(); i++ ) fTrackCells[i] = vTrackCells[i];
#ifdef DRAW
- if( nConnectedCells>0 ) AliHLTTPCCADisplay::Instance().Ask();
+ if( nTracks>0 ) AliHLTTPCCADisplay::Instance().Ask();
#endif
+ //cout<<"n out Tracks = "<<fNTracks<<endl;
fOutTrackHits = new Int_t[nOutTrackHits];
fNOutTrackHits = 0;
for( Int_t itr=0; itr<fNOutTracks; itr++ ){
AliHLTTPCCATrack &t = fTracks[itr];
#ifdef DRAW
- AliHLTTPCCADisplay::Instance().DrawTrack( t );
+ AliHLTTPCCADisplay::Instance().DrawTrack( t );
+ //AliHLTTPCCADisplay::Instance().Ask();
#endif
AliHLTTPCCAOutTrack &tmp = fOutTracks[itr];
tmp.FirstHitRef() = fNOutTrackHits;
}
t0[6] = 0;
+ Int_t step = track.NCells()/3;
+
for( Int_t iter=0; iter<nIter; iter++ ){
t.Init();
for( Int_t i=0; i<7; i++) t.Par()[i] = t0[i];
}
t.Init();
for( Int_t i=0; i<7; i++ ) t.Par()[i] = t0[i];
-
- for( Int_t i=0; i<track.NCells() ; i++){
+
+ //AliHLTTPCCATrackPar tt = t;
+
+ for( Int_t i=0; i<track.NCells() ; i+=step){
AliHLTTPCCACell &c = GetTrackCell(track,i);
AliHLTTPCCARow &row = GetTrackCellRow(track,i);
for( Int_t j=0; j<c.NHits(); j++){
t.TransportBz(fParam.Bz(),m, t0);
t.GetConnectionMatrix(fParam.Bz(),m, mV1, t0);
t.Filter(m, mV, mV1);
+ //tt.TransportBz(fParam.Bz(),m, t0);
+ //tt.GetConnectionMatrix(fParam.Bz(),m, mV1, t0);
+ //tt.Filter(m, mV, mV1);
}
}
t.Normalize();
/**
* @class AliHLTTPCCATracker
+ *
+ * Slice tracker for ALICE HLT.
+ * The class reconstructs tracks in one slice of TPC.
+ * The reconstruction algorithm is based on the Cellular Automaton method
+ *
+ * The CA tracker is designed stand-alone.
+ * It is integrated to the HLT framework via AliHLTTPCCATrackerComponent interface.
+ * The class is under construction.
+ *
*/
class AliHLTTPCCATracker
{
AliHLTTPCCATracker();
AliHLTTPCCATracker( const AliHLTTPCCATracker& );
AliHLTTPCCATracker &operator=( const AliHLTTPCCATracker& );
+
virtual ~AliHLTTPCCATracker();
void Initialize( AliHLTTPCCAParam ¶m );
void StartEvent();
- void ReadHit( Int_t iRow, Int_t index, Double_t x, Double_t y, Double_t z,
- Double_t ErrY, Double_t ErrZ ) const {;}
void ReadHitRow( Int_t iRow, AliHLTTPCCAHit *Row, Int_t NHits );
Int_t *TrackCells(){ return fTrackCells; }
+ Double_t *Timers(){ return fTimers; }
+
AliHLTTPCCACell &GetTrackCell( AliHLTTPCCATrack &t, Int_t i ) const {
Int_t ind = fTrackCells[t.IFirstCell()+i];
AliHLTTPCCARow &row = fRows[ind%256];
Int_t fNHitsTotal;// total number of hits in event
AliHLTTPCCATrack *fTracks; // reconstructed tracks
Int_t fNTracks;// number of reconstructed tracks
+ Int_t *fCellHitPointers;// global array of cell->hit pointers
+
+ Double_t fTimers[10]; // running CPU time for different parts of the algorithm
ClassDef(AliHLTTPCCATracker,1);
};
#include "AliHLTTPCTrackArray.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCDefinitions.h"
+#include "TStopwatch.h"
#include "TMath.h"
-#include "AliTPC.h"
-#include "AliTPCParam.h"
-#include "AliRun.h"
-#include <stdlib.h>
-#include <iostream>
-#include <errno.h>
// this is a global object used for automatic component registration, do not use this
AliHLTUInt32_t& size,
vector<AliHLTComponentBlockData>& outputBlocks )
{
+
+ AliHLTUInt32_t MaxBufferSize = size;
+ size = 0; // output size
+
+ TStopwatch timer;
+
// Event reconstruction in one TPC slice with CA Tracker
Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "DoEvent", "DoEvent()" );
if ( iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType ) continue;
slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
+
Bool_t found = 0;
slCntIter = sliceCnts.begin();
for( slIter = slices.begin(); slIter!=slices.end(); slIter++, slCntIter++ ){
Double_t dalpha = 0.349066;
Double_t alpha = 0.174533 + dalpha*iSec;
- Bool_t zPlus = (iSec<18|| (iSec>=36&&iSec<54) );
- Bool_t rInner = (iSec<36);
+ Bool_t zPlus = (iSec<18 );
Double_t zMin = zPlus ?plusZmin :minusZmin;
Double_t zMax = zPlus ?plusZmax :minusZmax;
- Double_t rMin = rInner ?inRmin :outRmin;
- Double_t rMax = rInner ?inRmax :outRmax;
- Int_t inNRows = 63;
- Int_t outNRows = 96;
- Double_t inRowXFirst = 85.225;
- Double_t outRowXFirst =135.1;
- Double_t inRowXStep = 0.75;
- Double_t outRowXStep = 1.;
- Int_t nRows = rInner ?inNRows :outNRows;
- Double_t rowXFirst = rInner ?inRowXFirst :outRowXFirst;
- Double_t rowXStep = rInner ?inRowXStep :outRowXStep;
-
- Int_t nSectors = 72/2;
-
+ //TPCZmin = -249.645, ZMax = 249.778
+ Double_t rMin = inRmin;
+ Double_t rMax = outRmax;
+ Int_t NRows = AliHLTTPCTransform::GetNRows();
+
Double_t padPitch = 0.4;
Double_t sigmaZ = 0.228808;
- //TPCZmin = -249.645, ZMax = 249.778
+ Double_t rowX[NRows];
+ for( Int_t irow=0; irow<NRows; irow++){
+ rowX[irow] = AliHLTTPCTransform::Row2X( irow );
+ }
AliHLTTPCCAParam param;
- param.Initialize( iSec, inNRows+outNRows, inRowXFirst, inRowXStep,alpha, dalpha,
+ param.Initialize( iSec, NRows, rowX, alpha, dalpha,
inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, Bz );
-
- fTracker->Initialize( param );
+ param.YErrorCorrection() = 1;
+ param.ZErrorCorrection() = 2;
- // recalculate outer rows -> necessary for a moment
+ fTracker->Initialize( param );
- for( Int_t irow=0; irow<outNRows; irow++){
- fTracker->Rows()[inNRows+irow].X() = outRowXFirst + irow*outRowXStep;
- }
}
// min and max patch numbers and row numbers
Int_t row[2] = {0,0};
- Int_t minPatch=INT_MAX, maxPatch = 0;
+ Int_t minPatch=INT_MAX, maxPatch = -1;
// total n Hits
fTracker->StartEvent();
- AliHLTTPCCAHit * vHits = new AliHLTTPCCAHit[nHitsTotal]; // CA hit array
- Double_t * vHitStoreX = new Double_t[nHitsTotal]; // hit X coordinates
- Int_t * vHitStoreID = new Int_t[nHitsTotal]; // hit ID's
+ 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 );
+ Int_t nClusters=0;
+
for( std::vector<unsigned long>::iterator pIter = patchIndices.begin(); pIter!=patchIndices.end(); pIter++ ){
ndx = *pIter;
iter = blocks+ndx;
for (UInt_t i=0; i<inPtrSP->fSpacePointCnt; i++ ){
AliHLTTPCSpacePointData* pSP = &(inPtrSP->fSpacePoints[i]);
- //Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reading hits", "hit pad %d, xyz=%f,%f,%f, sy=%f, sz=%f,", pSP->fPadRow, pSP->fX, pSP->fY, pSP->fZ, TMath::Sqrt(pSP->fSigmaY2), TMath::Sqrt(pSP->fSigmaZ2) );
-
if( pSP->fPadRow != oldRow ){
if( oldRow>=0 ) fTracker->ReadHitRow( oldRow, vHits+firstRowHit, nRowHits );
oldRow = pSP->fPadRow;
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(pSP->fSigmaY2);
- h.ErrZ() = TMath::Sqrt(pSP->fSigmaZ2);
+ 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;
vHitStoreX[nHits] = pSP->fX;
vHitStoreID[nHits] = pSP->fID;
+ vHitRowID[nHits] = pSP->fPadRow;
nHits++;
nRowHits++;
+ nClusters++;
}
if( oldRow>=0 ) fTracker->ReadHitRow( oldRow, vHits+firstRowHit, nRowHits );
}
-
// reconstruct the event
+ TStopwatch timerReco;
+
fTracker->Reconstruct();
+ timerReco.Stop();
+
Int_t ret = 0;
Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
UInt_t dSize = sizeof(AliHLTTPCTrackSegmentData) + t.NHits()*sizeof(UInt_t);
- if( mySize + dSize >size ){
- Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "Wrtite output","Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", size, mySize, ntracks-itr+1);
+ 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;
}
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);
+ currOutTracklet->fPsi = TMath::ATan2(ey, ex);
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];
- currOutTracklet->fTgl = TMath::Abs(ex)>1.e-5 ? ez/ex :1.e5;
+ currOutTracklet->fTgl = TMath::Abs(et)>1.e-5 ? ez/et :1.e5;
- h3 = (TMath::Abs(ex) >1.e-5) ? -ez/ex/ex :0;
- h5 = (TMath::Abs(ex) >1.e-5) ? 1./ex :0;
- currOutTracklet->fTglerr = h3*h3*t.Param().Cov()[9] + h5*h5*t.Param().Cov()[20] + 2.*h3*h5*t.Param().Cov()[18];
-
+ 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->fLastY = t.Param().Par()[1];
currOutTracklet->fLastZ = t.Param().Par()[2];
+#ifdef INCLUDE_TPC_HOUGH
+#ifdef ROWHOUGHPARAMS
+ 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++ ){
mySize+=dSize;
outPtr->fTrackletCnt++;
}
-
- Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Tracks",
- "Input: Number of tracks: %d Slice/MinPatch/MaxPatch/RowMin/RowMax: %d/%d/%d/%d/%d.",
- ntracks, slice, minPatch, maxPatch, row[0], row[1] );
+
AliHLTComponentBlockData bd;
FillBlockData( bd );
outputBlocks.push_back( bd );
size = mySize;
-
- delete [] vHits;
- delete [] vHitStoreX;
- delete [] vHitStoreID;
+ timerReco.Stop();
+
+ // Set log level to "Warning" for on-line system monitoring
+
+ 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) );
+
return ret;
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff