// $Id$
-//***************************************************************************
-// This file is property of and copyright by the ALICE HLT Project *
+// **************************************************************************
+// 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> *
// 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 "AliTPCtrackerCA.h"
-#include <TTree.h>
-#include <Riostream.h>
-#include "AliCluster.h"
+#include "TTree.h"
+#include "Riostream.h"
+//#include "AliCluster.h"
#include "AliTPCClustersRow.h"
#include "AliTPCParam.h"
+#include "AliTPCClusterParam.h"
+
#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliStack.h"
-#include "AliHLTTPCCATracker.h"
-#include "AliHLTTPCCAGBHit.h"
-#include "AliHLTTPCCAGBTracker.h"
-#include "AliHLTTPCCAGBTrack.h"
-#include "AliHLTTPCCAMCTrack.h"
-#include "AliHLTTPCCAOutTrack.h"
#include "AliHLTTPCCAPerformance.h"
#include "AliHLTTPCCAParam.h"
#include "AliHLTTPCCATrackConvertor.h"
+#include "AliHLTTPCCATracker.h"
+#include "AliHLTTPCCAStandaloneFramework.h"
#include "TMath.h"
#include "AliTPCLoader.h"
#include "AliTPCclusterMI.h"
#include "AliTPCTransform.h"
#include "AliTPCcalibDB.h"
-#include "AliTPCReconstructor.h"
#include "AliTPCtrack.h"
+#include "AliTPCseed.h"
#include "AliESDtrack.h"
#include "AliESDEvent.h"
#include "AliTrackReference.h"
+#include "TStopwatch.h"
+#include "AliTPCReconstructor.h"
+#include "AliHLTTPCCAMergerOutput.h"
//#include <fstream.h>
-ClassImp(AliTPCtrackerCA)
+ClassImp( AliTPCtrackerCA )
AliTPCtrackerCA::AliTPCtrackerCA()
- :AliTracker(),fParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fHLTPerformance(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+ : AliTracker(), fkParam( 0 ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
{
//* default constructor
}
-AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCtrackerCA &):
- AliTracker(),fParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fHLTPerformance(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+AliTPCtrackerCA::AliTPCtrackerCA( const AliTPCtrackerCA & ):
+ AliTracker(), fkParam( 0 ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
{
//* dummy
}
-AliTPCtrackerCA & AliTPCtrackerCA::operator=(const AliTPCtrackerCA& )
+const AliTPCtrackerCA & AliTPCtrackerCA::operator=( const AliTPCtrackerCA& ) const
{
- //* dummy
+ //* dummy
return *this;
}
-AliTPCtrackerCA::~AliTPCtrackerCA()
+AliTPCtrackerCA::~AliTPCtrackerCA()
{
//* destructor
- if( fClusters ) delete[] fClusters;
- if( fHLTTracker ) delete fHLTTracker;
- if( fHLTPerformance ) delete fHLTPerformance;
+ delete[] fClusters;
+ delete[] fClusterSliceRow;
}
-AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par):
- AliTracker(),fParam(par), fClusters(0), fNClusters(0), fHLTTracker(0), fHLTPerformance(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+//#include "AliHLTTPCCADisplay.h"
+
+AliTPCtrackerCA::AliTPCtrackerCA( const AliTPCParam *par ):
+ AliTracker(), fkParam( par ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
{
//* constructor
- DoHLTPerformance() = 1;
- DoHLTPerformanceClusters() = 1;
+ fDoHLTPerformance = 0;
+ fDoHLTPerformanceClusters = 0;
- fHLTTracker = new AliHLTTPCCAGBTracker;
- fHLTTracker->SetNSlices( fParam->GetNSector()/2 );
+ AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
- if( fDoHLTPerformance ){
- fHLTPerformance = new AliHLTTPCCAPerformance;
- fHLTPerformance->SetTracker( fHLTTracker );
- }
- for( int iSlice=0; iSlice<fHLTTracker->NSlices(); iSlice++ ){
-
- Float_t bz = AliTracker::GetBz();
-
- Float_t inRmin = fParam->GetInnerRadiusLow();
- //Float_t inRmax = fParam->GetInnerRadiusUp();
- //Float_t outRmin = fParam->GetOuterRadiusLow();
- Float_t outRmax = fParam->GetOuterRadiusUp();
- 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*iSlice;
-
- Bool_t zPlus = (iSlice<18 );
- Float_t zMin = zPlus ?plusZmin :minusZmin;
- Float_t zMax = zPlus ?plusZmax :minusZmax;
- //TPCZmin = -249.645, ZMax = 249.778
- //Float_t rMin = inRmin;
- //Float_t rMax = outRmax;
-
- Float_t padPitch = 0.4;
- Float_t sigmaZ = 0.228808;
-
- Int_t NRows = fParam->GetNRowLow()+fParam->GetNRowUp();
-
- Float_t rowX[200];
- for( Int_t irow=0; irow<fParam->GetNRowLow(); irow++){
- rowX[irow] = fParam->GetPadRowRadiiLow(irow);
- }
- for( Int_t irow=0; irow<fParam->GetNRowUp(); irow++){
- rowX[fParam->GetNRowLow()+irow] = fParam->GetPadRowRadiiUp(irow);
- }
+ for ( int iSlice = 0; iSlice < hlt.NSlices(); iSlice++ ) {
+
+ float bz = AliTracker::GetBz();
+
+ float inRmin = fkParam->GetInnerRadiusLow();
+ //float inRmax = fkParam->GetInnerRadiusUp();
+ //float outRmin = fkParam->GetOuterRadiusLow();
+ float outRmax = fkParam->GetOuterRadiusUp();
+ float plusZmin = 0.0529937;
+ float plusZmax = 249.778;
+ float minusZmin = -249.645;
+ float minusZmax = -0.0799937;
+ float dalpha = 0.349066;
+ float alpha = 0.174533 + dalpha * iSlice;
+
+ bool zPlus = ( iSlice < 18 );
+ float zMin = zPlus ? plusZmin : minusZmin;
+ float zMax = zPlus ? plusZmax : minusZmax;
+ //TPCZmin = -249.645, ZMax = 249.778
+ //float rMin = inRmin;
+ //float rMax = outRmax;
+
+ float padPitch = 0.4;
+ float sigmaZ = 0.228808;
+
+ int nRows = fkParam->GetNRowLow() + fkParam->GetNRowUp();
+ float rowX[200];
+ for ( int irow = 0; irow < fkParam->GetNRowLow(); irow++ ) {
+ rowX[irow] = fkParam->GetPadRowRadiiLow( irow );
+ }
+ for ( int irow = 0; irow < fkParam->GetNRowUp(); irow++ ) {
+ rowX[fkParam->GetNRowLow()+irow] = fkParam->GetPadRowRadiiUp( irow );
+ }
AliHLTTPCCAParam param;
- param.Initialize( iSlice, NRows, rowX, alpha, dalpha,
- inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, bz );
- param.YErrorCorrection() = 1.;//.33;
- param.ZErrorCorrection() = 1.;//.33;
- param.MaxTrackMatchDRow() = 5;
- param.TrackConnectionFactor() = 3.5;
- fHLTTracker->Slices()[iSlice].Initialize( param );
+ param.Initialize( iSlice, nRows, rowX, alpha, dalpha,
+ inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, bz );
+ param.SetHitPickUpFactor( 1. );
+ param.SetMaxTrackMatchDRow( 5 );
+ param.SetTrackConnectionFactor( 3.5 );
+
+ AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
+ for ( int iRow = 0; iRow < nRows; iRow++ ) {
+ int type = ( iRow < 63 ) ? 0 : ( ( iRow > 126 ) ? 1 : 2 );
+ for ( int iyz = 0; iyz < 2; iyz++ ) {
+ for ( int k = 0; k < 7; k++ ) {
+ //std::cout<<param.fParamS0Par[iyz][type][k]<<" "<<clparam->fParamS0Par[iyz][type][k] - param.fParamS0Par[iyz][type][k]<<std::endl;
+#ifndef HAVE_NOT_ALITPCCLUSTERPARAM_r40128
+ param.SetParamS0Par( iyz, type, k, clparam->ParamS0Par(iyz, type, k));
+#else
+ param.SetParamS0Par( iyz, type, k, clparam->fParamS0Par[iyz][type][k] );
+#endif //HAVE_NOT_ALITPCCLUSTERPARAM_r40128
+ }
+ }
+ }
+ //hlt.SliceTracker( iSlice ).Initialize( param );
+ hlt.InitializeSliceParam(iSlice, param);
}
}
-Int_t AliTPCtrackerCA::LoadClusters (TTree * tree)
-{
+int AliTPCtrackerCA::LoadClusters ( TTree * fromTree )
+{
+ // load clusters to the local arrays
fNClusters = 0;
- if( fClusters ) delete[] fClusters;
+ delete[] fClusters;
+ delete[] fClusterSliceRow;
- fHLTTracker->StartEvent();
- if( fDoHLTPerformance ) fHLTPerformance->StartEvent();
+ AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
- if( !fParam ) return 1;
+ if ( fDoHLTPerformance ) {
+ AliHLTTPCCAPerformance::Instance().StartEvent();
+ if ( fDoHLTPerformanceClusters ) AliHLTTPCCAPerformance::Instance().SetDoClusterPulls( 1 );
+ }
+
+ if ( !fkParam ) return 1;
// load mc tracks
- while( fDoHLTPerformance ){
- if( !gAlice ) break;
- AliRunLoader *rl = gAlice->GetRunLoader();
- if( !rl ) break;
+ while ( fDoHLTPerformance ) {
+ if ( !gAlice ) break;
+#ifndef HAVE_NOT_ALIRUNLOADER30859
+ AliRunLoader *rl = AliRunLoader::Instance();//gAlice->GetRunLoader();
+#else
+ // the old way before rev 30859
+ AliRunLoader *rl = AliRunLoader::GetRunLoader();
+#endif
+ if ( !rl ) break;
rl->LoadKinematics();
AliStack *stack = rl->Stack();
- if( !stack ) break;
+ if ( !stack ) break;
+
+ AliHLTTPCCAPerformance::Instance().SetNMCTracks( stack->GetNtrack() );
- fHLTPerformance->SetNMCTracks( stack->GetNtrack() );
-
- for( Int_t itr=0; itr<stack->GetNtrack(); itr++ ){
- TParticle *part = stack->Particle(itr);
- fHLTPerformance->ReadMCTrack( itr, part );
+ for ( int itr = 0; itr < stack->GetNtrack(); itr++ ) {
+ TParticle *part = stack->Particle( itr );
+ AliHLTTPCCAPerformance::Instance().ReadMCTrack( itr, part );
}
{ // check for MC tracks at the TPC entrance
- Bool_t *isTPC = 0;
- isTPC = new Bool_t [stack->GetNtrack()];
- for( Int_t i=0; i<stack->GetNtrack(); i++ ) isTPC[i] = 0;
+
+ bool *isTPC = 0;
+ isTPC = new bool [stack->GetNtrack()];
+ for ( int i = 0; i < stack->GetNtrack(); i++ ) isTPC[i] = 0;
rl->LoadTrackRefs();
- TTree *TR = rl->TreeTR();
- if( !TR ) break;
- TBranch *branch=TR->GetBranch("TrackReferences");
- if (!branch ) break;
- TClonesArray tpcdummy("AliTrackReference",1000), *tpcRefs=&tpcdummy;
- branch->SetAddress(&tpcRefs);
- Int_t nr=(Int_t)TR->GetEntries();
- for (Int_t r=0; r<nr; r++) {
- TR->GetEvent(r);
- Int_t nref = tpcRefs->GetEntriesFast();
- if (!nref) continue;
- AliTrackReference *tpcRef= 0x0;
- for (Int_t iref=0; iref<nref; ++iref) {
- tpcRef = (AliTrackReference*)tpcRefs->UncheckedAt(iref);
- if (tpcRef->DetectorId() == AliTrackReference::kTPC) break;
- tpcRef = 0x0;
- }
- if (!tpcRef) continue;
-
- if( isTPC[tpcRef->Label()] ) continue;
-
- fHLTPerformance->ReadMCTPCTrack(tpcRef->Label(),
- tpcRef->X(),tpcRef->Y(),tpcRef->Z(),
- tpcRef->Px(),tpcRef->Py(),tpcRef->Pz() );
- isTPC[tpcRef->Label()] = 1;
- tpcRefs->Clear();
- }
- if( isTPC ) delete[] isTPC;
+ TTree *mcTree = rl->TreeTR();
+ if ( !mcTree ) break;
+ TBranch *branch = mcTree->GetBranch( "TrackReferences" );
+ if ( !branch ) break;
+ TClonesArray tpcdummy( "AliTrackReference", 1000 ), *tpcRefs = &tpcdummy;
+ branch->SetAddress( &tpcRefs );
+ int nr = ( int )mcTree->GetEntries();
+ for ( int r = 0; r < nr; r++ ) {
+ mcTree->GetEvent( r );
+ int nref = tpcRefs->GetEntriesFast();
+ if ( !nref ) continue;
+ AliTrackReference *tpcRef = 0x0;
+ for ( int iref = 0; iref < nref; ++iref ) {
+ tpcRef = ( AliTrackReference* )tpcRefs->UncheckedAt( iref );
+ if ( tpcRef->DetectorId() == AliTrackReference::kTPC ) break;
+ tpcRef = 0x0;
+ }
+ if ( !tpcRef ) continue;
+
+ if ( isTPC[tpcRef->Label()] ) continue;
+
+ AliHLTTPCCAPerformance::Instance().ReadMCTPCTrack( tpcRef->Label(),
+ tpcRef->X(), tpcRef->Y(), tpcRef->Z(),
+ tpcRef->Px(), tpcRef->Py(), tpcRef->Pz() );
+ isTPC[tpcRef->Label()] = 1;
+ tpcRefs->Clear();
+ }
+ if ( isTPC ) delete[] isTPC;
}
- while( fDoHLTPerformanceClusters ){
- AliTPCLoader *tpcl = (AliTPCLoader*) rl->GetDetectorLoader("TPC");
- if( !tpcl ) break;
- if( tpcl->TreeH() == 0x0 ){
- if( tpcl->LoadHits() ) break;
+ while ( fDoHLTPerformanceClusters ) {
+ AliTPCLoader *tpcl = ( AliTPCLoader* ) rl->GetDetectorLoader( "TPC" );
+ if ( !tpcl ) break;
+ if ( tpcl->TreeH() == 0x0 ) {
+ if ( tpcl->LoadHits() ) break;
}
- if( tpcl->TreeH() == 0x0 ) break;
-
- AliTPC *tpc = (AliTPC*) gAlice->GetDetector("TPC");
- Int_t nEnt=(Int_t)tpcl->TreeH()->GetEntries();
- Int_t nPoints = 0;
- for (Int_t iEnt=0; iEnt<nEnt; iEnt++) {
- tpc->ResetHits();
- tpcl->TreeH()->GetEvent(iEnt);
- AliTPChit *phit = (AliTPChit*)tpc->FirstHit(-1);
- for ( ; phit; phit=(AliTPChit*)tpc->NextHit() ) nPoints++;
+ if ( tpcl->TreeH() == 0x0 ) break;
+
+ AliTPC *tpc = ( AliTPC* ) gAlice->GetDetector( "TPC" );
+ int nEnt = ( int )tpcl->TreeH()->GetEntries();
+ int nPoints = 0;
+ for ( int iEnt = 0; iEnt < nEnt; iEnt++ ) {
+ tpc->ResetHits();
+ tpcl->TreeH()->GetEvent( iEnt );
+ AliTPChit *phit = ( AliTPChit* )tpc->FirstHit( -1 );
+ for ( ; phit; phit = ( AliTPChit* )tpc->NextHit() ) nPoints++;
}
- fHLTPerformance->SetNMCPoints( nPoints );
-
- for (Int_t iEnt=0; iEnt<nEnt; iEnt++) {
- tpc->ResetHits();
- tpcl->TreeH()->GetEvent(iEnt);
- AliTPChit *phit = (AliTPChit*)tpc->FirstHit(-1);
- for ( ; phit; phit=(AliTPChit*)tpc->NextHit() ){
- fHLTPerformance->ReadMCPoint( phit->GetTrack(),phit->X(), phit->Y(),phit->Z(),phit->Time(), phit->fSector%36);
- }
+ AliHLTTPCCAPerformance::Instance().SetNMCPoints( nPoints );
+
+ for ( int iEnt = 0; iEnt < nEnt; iEnt++ ) {
+ tpc->ResetHits();
+ tpcl->TreeH()->GetEvent( iEnt );
+ AliTPChit *phit = ( AliTPChit* )tpc->FirstHit( -1 );
+ for ( ; phit; phit = ( AliTPChit* )tpc->NextHit() ) {
+ AliHLTTPCCAPerformance::Instance().ReadMCPoint( phit->GetTrack(), phit->X(), phit->Y(), phit->Z(), phit->Time(), phit->fSector % 36 );
+ }
}
break;
}
break;
}
-
- TBranch * br = tree->GetBranch("Segment");
- if( !br ) return 1;
+
+ TBranch * br = fromTree->GetBranch( "Segment" );
+ if ( !br ) return 1;
AliTPCClustersRow *clrow = new AliTPCClustersRow;
- clrow->SetClass("AliTPCclusterMI");
- clrow->SetArray(0);
- clrow->GetArray()->ExpandCreateFast(10000);
-
- br->SetAddress(&clrow);
-
+ clrow->SetClass( "AliTPCclusterMI" );
+ clrow->SetArray( 0 );
+ clrow->GetArray()->ExpandCreateFast( 10000 );
+
+ br->SetAddress( &clrow );
+
//
- Int_t NEnt=Int_t(tree->GetEntries());
+ int nEnt = int( fromTree->GetEntries() );
fNClusters = 0;
- for (Int_t i=0; i<NEnt; i++) {
- br->GetEntry(i);
- Int_t sec,row;
- fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+ for ( int i = 0; i < nEnt; i++ ) {
+ br->GetEntry( i );
+ int sec, row;
+ fkParam->AdjustSectorRow( clrow->GetID(), sec, row );
fNClusters += clrow->GetArray()->GetEntriesFast();
}
fClusters = new AliTPCclusterMI [fNClusters];
- fHLTTracker->SetNHits( fNClusters );
- if( fDoHLTPerformance ) fHLTPerformance->SetNHits( fNClusters );
- int ind=0;
- for (Int_t i=0; i<NEnt; i++) {
- br->GetEntry(i);
- Int_t sec,row;
- fParam->AdjustSectorRow(clrow->GetID(),sec,row);
- int NClu = clrow->GetArray()->GetEntriesFast();
- Float_t x = fParam->GetPadRowRadii(sec,row);
- for (Int_t icl=0; icl<NClu; icl++){
- Int_t lab0 = -1;
- Int_t lab1 = -1;
- Int_t lab2 = -1;
- AliTPCclusterMI* cluster = (AliTPCclusterMI*)(clrow->GetArray()->At(icl));
- if( !cluster ) continue;
- lab0 = cluster->GetLabel(0);
- lab1 = cluster->GetLabel(1);
- lab2 = cluster->GetLabel(2);
+ fClusterSliceRow = new unsigned int [fNClusters];
+
+ hlt.StartDataReading( fNClusters );
+
+ if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().SetNHits( fNClusters );
+
+ int ind = 0;
+ for ( int i = 0; i < nEnt; i++ ) {
+ br->GetEntry( i );
+ int sec, row;
+ fkParam->AdjustSectorRow( clrow->GetID(), sec, row );
+ int nClu = clrow->GetArray()->GetEntriesFast();
+ float x = fkParam->GetPadRowRadii( sec, row );
+
+ if ( sec >= 36 ) {
+ sec = sec - 36;
+ row = row + fkParam->GetNRowLow();
+ }
+
+ unsigned int sliceRow = ( sec << 8 ) + row;
+
+ for ( int icl = 0; icl < nClu; icl++ ) {
+ int lab0 = -1;
+ int lab1 = -1;
+ int lab2 = -1;
+ AliTPCclusterMI* cluster = ( AliTPCclusterMI* )( clrow->GetArray()->At( icl ) );
+ if ( !cluster ) continue;
+ lab0 = cluster->GetLabel( 0 );
+ lab1 = cluster->GetLabel( 1 );
+ lab2 = cluster->GetLabel( 2 );
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
- if (!transform) {
- AliFatal("Tranformations not in calibDB");
- }
- Double_t xx[3]={cluster->GetRow(),cluster->GetPad(),cluster->GetTimeBin()};
- Int_t id[1]={cluster->GetDetector()};
- transform->Transform(xx,id,0,1);
- //if (!AliTPCReconstructor::GetRecoParam()->GetBYMirror()){
- if (cluster->GetDetector()%36>17){
- xx[1]*=-1;
+ transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam());
+
+ if ( !transform ) {
+ AliFatal( "Tranformations not in calibDB" );
}
- //}
-
- cluster->SetX(xx[0]);
- cluster->SetY(xx[1]);
- cluster->SetZ(xx[2]);
-
- TGeoHMatrix *mat = fParam->GetClusterMatrix(cluster->GetDetector());
- Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
- Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
- if (mat) mat->LocalToMaster(pos,posC);
- else{
- // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
+ double xx[3] = {cluster->GetRow(), cluster->GetPad(), cluster->GetTimeBin()};
+ int id[1] = {cluster->GetDetector()};
+ transform->Transform( xx, id, 0, 1 );
+
+ cluster->SetX( xx[0] );
+ cluster->SetY( xx[1] );
+ cluster->SetZ( xx[2] );
+
+ TGeoHMatrix *mat = fkParam->GetClusterMatrix( cluster->GetDetector() );
+ double pos[3] = {cluster->GetX(), cluster->GetY(), cluster->GetZ()};
+ double posC[3] = {cluster->GetX(), cluster->GetY(), cluster->GetZ()};
+ if ( mat ) mat->LocalToMaster( pos, posC );
+ else {
+ // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
}
- cluster->SetX(posC[0]);
- cluster->SetY(posC[1]);
- cluster->SetZ(posC[2]);
+ cluster->SetX( posC[0] );
+ cluster->SetY( posC[1] );
+ cluster->SetZ( posC[2] );
- Float_t y = cluster->GetY();
- Float_t z = cluster->GetZ();
+ x = cluster->GetX();
+ float y = cluster->GetY();
+ float z = cluster->GetZ();
- if( sec>=36 ){
- sec = sec - 36;
- row = row + fParam->GetNRowLow();
- }
-
- Int_t index = ind++;
+
+ int index = ind++;
fClusters[index] = *cluster;
- fHLTTracker->ReadHit( x, y, z,
- TMath::Sqrt(cluster->GetSigmaY2()), TMath::Sqrt(cluster->GetSigmaZ2()),
- cluster->GetMax(), index, sec, row );
- if( fDoHLTPerformance ) fHLTPerformance->ReadHitLabel(index, lab0, lab1, lab2 );
+
+ fClusterSliceRow[index] = sliceRow;
+
+ hlt.ReadCluster( index, sec, row, x, y, z, cluster->GetQ() );
+
+ if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().ReadHitLabel( index, lab0, lab1, lab2 );
}
}
delete clrow;
+
+ hlt.FinishDataReading();
+
+ //AliHLTTPCCAPerformance::Instance().SmearClustersMC();
+
return 0;
}
-AliCluster * AliTPCtrackerCA::GetCluster(Int_t index) const
+AliCluster * AliTPCtrackerCA::GetCluster( int index ) const
{
- return &(fClusters[index]);
+ return &( fClusters[index] );
}
-Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
+int AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
{
+ // reconstruction
//cout<<"Start of AliTPCtrackerCA"<<endl;
+ TStopwatch timer;
+
+ AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
+
+ hlt.ProcessEvent();
+
+ if ( event ) {
+
+ const AliHLTTPCCAMergerOutput &hltOut = *( hlt.Merger().Output() );
+
+ for ( int itr = 0; itr < hltOut.NTracks(); itr++ ) {
+
+ AliTPCseed tTPC;
- fHLTTracker->FindTracks();
- if( fDoHLTPerformance ) fHLTPerformance->Performance();
+ const AliHLTTPCCAMergedTrack &tCA = hltOut.Track( itr );
- if( 0 ) {// Write Event
- if( fStatNEvents == 0 ){
+ AliHLTTPCCATrackParam par = tCA.InnerParam();
+ AliHLTTPCCATrackConvertor::GetExtParam( par, tTPC, tCA.InnerAlpha() );
+ tTPC.SetMass( 0.13957 );
+ if ( TMath::Abs( tTPC.GetSigned1Pt() ) > 1. / 0.02 ) continue;
+ int nhits = tCA.NClusters();
+ int firstHit = 0;
+ if ( nhits > 160 ) {
+ firstHit = nhits - 160;
+ nhits = 160;
+ }
+ tTPC.SetNumberOfClusters( nhits );
+ float alpha = tCA.InnerAlpha();
+ AliHLTTPCCATrackParam t0 = par;
+ for ( int ih = 0; ih < nhits; ih++ ) {
+ int index = hltOut.ClusterId( tCA.FirstClusterRef() + firstHit + ih );
+ tTPC.SetClusterIndex( ih, index );
+ AliTPCclusterMI *c = &( fClusters[index] );
+ int iSlice = fClusterSliceRow[index] >> 8;
+ int row = fClusterSliceRow[index] & 0xff;
+
+ tTPC.SetClusterPointer( row, c );
+ AliTPCTrackerPoint &point = *( tTPC.GetTrackPoint( row ) );
+ {
+ //AliHLTTPCCATracker &slice = hlt.SliceTracker( iSlice );
+ if ( hlt.Param(iSlice).Alpha() != alpha ) {
+ if ( ! t0.Rotate( hlt.Param(iSlice).Alpha() - alpha, .999 ) ) continue;
+ alpha = hlt.Param(iSlice).Alpha();
+ }
+ float x = hlt.Row(iSlice, row).X();
+ if ( !t0.TransportToX( x, hlt.Param(iSlice).GetBz( t0 ), .999 ) ) continue;
+ float sy2, sz2;
+ //slice.GetErrors2( row, t0, sy2, sz2 );
+ hlt.Param(iSlice).GetClusterErrors2( row, t0.GetZ(), t0.SinPhi(), t0.GetCosPhi(), t0.DzDs(), sy2, sz2 );
+ point.SetSigmaY( c->GetSigmaY2() / sy2 );
+ point.SetSigmaZ( c->GetSigmaZ2() / sz2 );
+ point.SetAngleY( TMath::Abs( t0.GetSinPhi() / t0.GetCosPhi() ) );
+ point.SetAngleZ( TMath::Abs( t0.GetDzDs() ) );
+ }
+ }
+ tTPC.CookdEdx( 0.02, 0.6 );
+
+ CookLabel( &tTPC, 0.1 );
+
+ if ( 1 ) { // correction like in off-line --- Adding systematic error
+
+ const double *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError();
+ double covar[15];
+ for ( int i = 0; i < 15; i++ ) covar[i] = 0;
+ covar[0] = param[0] * param[0];
+ covar[2] = param[1] * param[1];
+ covar[5] = param[2] * param[2];
+ covar[9] = param[3] * param[3];
+ double facC = AliTracker::GetBz() * kB2C;
+ covar[14] = param[4] * param[4] * facC * facC;
+ tTPC.AddCovariance( covar );
+ }
+
+ AliESDtrack tESD;
+ tESD.UpdateTrackParams( &( tTPC ), AliESDtrack::kTPCin );
+ //tESD.SetStatus( AliESDtrack::kTPCrefit );
+ //tESD.SetTPCPoints(tTPC.GetPoints());
+ int ndedx = tTPC.GetNCDEDX( 0 );
+ float sdedx = tTPC.GetSDEDX( 0 );
+ float dedx = tTPC.GetdEdx();
+ tESD.SetTPCsignal( dedx, sdedx, ndedx );
+ //tESD.myTPC = tTPC;
+
+ event->AddTrack( &tESD );
+ }
+ }
+
+
+ timer.Stop();
+
+ fStatCPUTime += timer.CpuTime();
+ fStatRealTime += timer.RealTime();
+
+ //cout << "\n\nCA tracker speed: cpu = " << fStatCPUTime / ( fStatNEvents + 1 )*1.e3 << " [ms/ev], real = " << fStatRealTime / ( fStatNEvents + 1 )*1.e3 << " [ms/ev], n calls = " << ( fStatNEvents + 1 ) << endl << endl;
+
+
+ //cout<<"Do performance.."<<endl;
+
+ if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().Performance();
+
+ if ( 0 ) {// Write Event
+ if ( fStatNEvents == 0 ) {
fstream geo;
- geo.open("CAEvents/settings.dat", ios::out);
- if( geo.is_open() ){
- fHLTTracker->WriteSettings(geo);
+ geo.open( "CAEvents/settings.dat", ios::out );
+ if ( geo.is_open() ) {
+ hlt.WriteSettings( geo );
}
geo.close();
}
- fstream event;
+ fstream hits;
char name[255];
- sprintf( name,"CAEvents/%i.event.dat",fStatNEvents );
- event.open(name, ios::out);
- if( event.is_open() ){
- fHLTTracker->WriteEvent(event);
+ sprintf( name, "CAEvents/%i.event.dat", fStatNEvents );
+ hits.open( name, ios::out );
+ if ( hits.is_open() ) {
+ hlt.WriteEvent( hits );
fstream tracks;
- sprintf( name,"CAEvents/%i.tracks.dat",fStatNEvents );
- tracks.open(name, ios::out);
- fHLTTracker->WriteTracks(tracks);
+ sprintf( name, "CAEvents/%i.tracks.dat", fStatNEvents );
+ tracks.open( name, ios::out );
+ hlt.WriteTracks( tracks );
}
- event.close();
- if( fDoHLTPerformance ){
+ hits.close();
+ if ( fDoHLTPerformance ) {
fstream mcevent, mcpoints;
char mcname[255];
- sprintf( mcname,"CAEvents/%i.mcevent.dat",fStatNEvents );
- mcevent.open(mcname, ios::out);
- if( mcevent.is_open() ){
- fHLTPerformance->WriteMCEvent(mcevent);
+ sprintf( mcname, "CAEvents/%i.mcevent.dat", fStatNEvents );
+ mcevent.open( mcname, ios::out );
+ if ( mcevent.is_open() ) {
+ AliHLTTPCCAPerformance::Instance().WriteMCEvent( mcevent );
}
- if(fDoHLTPerformanceClusters ){
- sprintf( mcname,"CAEvents/%i.mcpoints.dat",fStatNEvents );
- mcpoints.open(mcname, ios::out);
- if( mcpoints.is_open() ){
- fHLTPerformance->WriteMCPoints(mcpoints);
- }
- mcpoints.close();
+ if ( 1 && fDoHLTPerformanceClusters ) {
+ sprintf( mcname, "CAEvents/%i.mcpoints.dat", fStatNEvents );
+ mcpoints.open( mcname, ios::out );
+ if ( mcpoints.is_open() ) {
+ AliHLTTPCCAPerformance::Instance().WriteMCPoints( mcpoints );
+ }
+ mcpoints.close();
}
- mcevent.close();
+ mcevent.close();
}
}
- fStatNEvents++;
- if( event ){
-
- Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
-
- for( Int_t itr=0; itr<fHLTTracker->NTracks(); itr++ ){
- AliTPCtrack tTPC;
- AliHLTTPCCAGBTrack &tCA = fHLTTracker->Tracks()[itr];
- AliHLTTPCCATrackParam &par = tCA.Param();
- AliHLTTPCCATrackConvertor::GetExtParam( par, tTPC, tCA.Alpha(), bz );
- tTPC.SetMass(0.13957);
- tTPC.SetdEdx( tCA.DeDx() );
- if( TMath::Abs(tTPC.GetSigned1Pt())>1./0.1 ) continue;
- int nhits = tCA.NHits();
- if( nhits>kMaxRow ) nhits = kMaxRow;
- tTPC.SetNumberOfClusters(nhits);
- for( Int_t ih=0; ih<nhits; ih++ ){
- Int_t index = fHLTTracker->TrackHits()[tCA.FirstHitRef()+ih];
- Int_t ext_index = fHLTTracker->Hits()[index].ID();
- tTPC.SetClusterIndex(ih, ext_index);
- }
- CookLabel(&tTPC,0.1);
- {
- Double_t xTPC=fParam->GetInnerRadiusLow();
- Double_t dAlpha = fParam->GetInnerAngle()/180.*TMath::Pi();
- if (tTPC.AliExternalTrackParam::PropagateTo(xTPC,bz)) {
- Double_t y=tTPC.GetY();
- Double_t ymax=xTPC*TMath::Tan(dAlpha/2.);
- if (y > ymax) {
- if (tTPC.Rotate(dAlpha)) tTPC.AliExternalTrackParam::PropagateTo(xTPC,bz);
- } else if (y <-ymax) {
- if (tTPC.Rotate(-dAlpha)) tTPC.AliExternalTrackParam::PropagateTo(xTPC,bz);
- }
- }
- }
+ fStatNEvents++;
- AliESDtrack tESD;
- tESD.UpdateTrackParams( &(tTPC),AliESDtrack::kTPCin);
- //tESD.SetStatus( AliESDtrack::kTPCrefit );
- //tESD.SetTPCPoints(tTPC.GetPoints());
- //tESD.myTPC = tTPC;
- event->AddTrack(&tESD);
- }
- }
//cout<<"End of AliTPCtrackerCA"<<endl;
return 0;
}
-Int_t AliTPCtrackerCA::RefitInward (AliESDEvent *event)
-{
- //* back propagation of ESD tracks (not fully functional)
+int AliTPCtrackerCA::RefitInward ( AliESDEvent *event )
+{
+ //* forward propagation of ESD tracks
+
+ float xTPC = fkParam->GetInnerRadiusLow();
+ float dAlpha = fkParam->GetInnerAngle() / 180.*TMath::Pi();
+ float yMax = xTPC * TMath::Tan( dAlpha / 2. );
- Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
- Float_t xTPC = fParam->GetInnerRadiusLow();
- Float_t dAlpha = fParam->GetInnerAngle()/180.*TMath::Pi();
- Float_t yMax = xTPC*TMath::Tan(dAlpha/2.);
+ AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
- Int_t nentr=event->GetNumberOfTracks();
-
- for (Int_t i=0; i<nentr; i++) {
- AliESDtrack *esd=event->GetTrack(i);
- ULong_t status=esd->GetStatus();
- if (!(status&AliESDtrack::kTPCin)) continue;
+ int nentr = event->GetNumberOfTracks();
+
+ for ( int itr = 0; itr < nentr; itr++ ) {
+ AliESDtrack *esd = event->GetTrack( itr );
+ ULong_t status = esd->GetStatus();
+ if ( !( status&AliESDtrack::kTPCin ) ) continue;
AliHLTTPCCATrackParam t0;
- AliHLTTPCCATrackConvertor::SetExtParam(t0,*esd, bz );
- Float_t alpha = esd->GetAlpha();
- if( t0.TransportToXWithMaterial( xTPC, bz) ){
- if (t0.GetY() > yMax) {
- if (t0.Rotate(dAlpha)){
- alpha+=dAlpha;
- t0.TransportToXWithMaterial( xTPC, bz);
- }
- } else if (t0.GetY() <-yMax) {
- if (t0.Rotate(-dAlpha)){
- alpha+=-dAlpha;
- t0.TransportToXWithMaterial( xTPC, bz);
- }
- }
+ AliHLTTPCCATrackConvertor::SetExtParam( t0, *esd );
+ AliHLTTPCCATrackParam t = t0;
+ float alpha = esd->GetAlpha();
+ //float dEdX=0;
+ AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo infos[500];
+ int hits[500], hits1[500];
+ int nHits = esd->GetTPCclusters( hits );
+ for ( int i = 0; i < nHits; i++ ) {
+ hits1[i] = i;
+ int index = hits[i];
+ infos[i].SetISlice( fClusterSliceRow[index] >> 8 );
+ infos[i].SetIRow( fClusterSliceRow[index] & 0xff );
+ infos[i].SetId( index );
+ infos[i].SetX( fClusters[index].GetX() );
+ infos[i].SetY( fClusters[index].GetY() );
+ infos[i].SetZ( fClusters[index].GetZ() );
+ }
+
+ bool ok = hlt.Merger().FitTrack( t, alpha, t0, alpha, hits1, nHits, 0, 1,infos );
+
+ if ( ok && nHits > 15 ) {
+ if ( t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) ) ) {
+ if ( t.GetY() > yMax ) {
+ if ( t.Rotate( dAlpha ) ) {
+ alpha += dAlpha;
+ t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) );
+ }
+ } else if ( t.GetY() < -yMax ) {
+ if ( t.Rotate( -dAlpha ) ) {
+ alpha += -dAlpha;
+ t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) );
+ }
+ }
+ }
+
+ AliTPCtrack tt( *esd );
+ if ( AliHLTTPCCATrackConvertor::GetExtParam( t, tt, alpha ) ) {
+ if ( t.X() > 50 ) esd->UpdateTrackParams( &tt, AliESDtrack::kTPCrefit );
+ }
}
- AliTPCtrack tt(*esd);
- AliHLTTPCCATrackConvertor::GetExtParam(t0,tt,alpha,bz);
- esd->UpdateTrackParams( &tt,AliESDtrack::kTPCrefit);
}
return 0;
}
-Int_t AliTPCtrackerCA::PropagateBack(AliESDEvent *)
-{
- //* not implemented yet
- return 0;
+int AliTPCtrackerCA::PropagateBack( AliESDEvent *event )
+{
+
+ //* backward propagation of ESD tracks
+
+ AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
+
+ int nentr = event->GetNumberOfTracks();
+
+ for ( int itr = 0; itr < nentr; itr++ ) {
+
+ AliESDtrack *esd = event->GetTrack( itr );
+ ULong_t status = esd->GetStatus();
+ if ( !( status&AliESDtrack::kTPCin ) ) continue;
+
+ AliHLTTPCCATrackParam t0;
+ AliHLTTPCCATrackConvertor::SetExtParam( t0, *esd );
+ AliHLTTPCCATrackParam t = t0;
+ float alpha = esd->GetAlpha();
+ //float dEdX=0;
+ AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo infos[500];
+ int hits[500], hits1[500];
+ int nHits = esd->GetTPCclusters( hits );
+ for ( int i = 0; i < nHits; i++ ) {
+ hits1[i] = i;
+ int index = hits[i];
+ infos[i].SetISlice( fClusterSliceRow[index] >> 8 );
+ infos[i].SetIRow( fClusterSliceRow[index] & 0xff );
+ infos[i].SetId( index );
+ infos[i].SetX( fClusters[index].GetX() );
+ infos[i].SetY( fClusters[index].GetY() );
+ infos[i].SetZ( fClusters[index].GetZ() );
+ }
+
+ bool ok = hlt.Merger().FitTrack( t, alpha, t0, alpha, hits1, nHits, 1, 1, infos );
+
+ if ( ok && nHits > 15 ) {
+ AliTPCtrack tt( *esd );
+ if ( AliHLTTPCCATrackConvertor::GetExtParam( t, tt, alpha ) ) {
+ if ( t.X() > 50 ) esd->UpdateTrackParams( &tt, AliESDtrack::kTPCout );
+ }
+ }
+ }
+ return 0;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff