X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTPCLib%2Ftracking-ca%2FAliTPCtrackerCA.cxx;h=82590d040e0bbb465f6bfeafada99f985b648662;hb=13627b46d87baee0f017612d506f798de4a7f2cf;hp=c7b33594f4f14cd2673c28d338dd37ab89432ef6;hpb=81c309edc44962da5282cac2919c09a40b8fe3b1;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx b/HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx index c7b33594f4f..82590d040e0 100644 --- a/HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx +++ b/HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx @@ -1,6 +1,6 @@ // $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 * @@ -14,28 +14,27 @@ // 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 -#include -#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" @@ -43,432 +42,588 @@ #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 -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; iSliceNSlices(); 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; irowGetNRowLow(); irow++){ - rowX[irow] = fParam->GetPadRowRadiiLow(irow); - } - for( Int_t irow=0; irowGetNRowUp(); 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<fParamS0Par[iyz][type][k] - param.fParamS0Par[iyz][type][k]<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; itrGetNtrack(); 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; iGetNtrack(); 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; rGetEvent(r); - Int_t nref = tpcRefs->GetEntriesFast(); - if (!nref) continue; - AliTrackReference *tpcRef= 0x0; - for (Int_t iref=0; irefUncheckedAt(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; iEntResetHits(); - 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; iEntResetHits(); - 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; iGetEntry(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; iGetEntry(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; iclGetArray()->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"<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.."<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; itrNTracks(); 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; ihTrackHits()[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"<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; iGetTrack(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; }