outBlock.fOffset = size;
outBlock.fSize = flatEsd->GetSize();
outBlock.fDataType = kAliHLTDataTypeFlatESD|kAliHLTDataOriginOut;
- outBlock.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( 0, 35, 0, 5 );
-
outputBlocks.push_back( outBlock );
-
- fBenchmark.AddOutput(outBlock.fSize);
-
+ fBenchmark.AddOutput(outBlock.fSize);
size += outBlock.fSize;
}
- if(benchmark){
+
+
+ // ---------------------------------------------
+ //
+ // Fill the flat ESD friend structure
+ //
+
+ while( !err && fProduceFriend ){ // single loop for easy break in case of output buffer overflow
+
+ // ---------- Access to clusters --------------------
+
+ const AliHLTTPCClusterData *partitionClusters[fkNPartition]; //! arrays of cluster data for each TPC partition
+ Int_t partitionNClusters[fkNPartition]; //! number of clusters for each TPC partition
+
+ {
+ for(Int_t i=0; i<fkNPartition; i++){
+ partitionClusters[i] = 0;
+ partitionNClusters[i] = 0;
+ }
+ for(const AliHLTComponentBlockData *iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock()){
+ if(iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType) continue;
+ Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
+ Int_t partition = AliHLTTPCDefinitions::GetMinPatchNr(iter->fSpecification);
+ Int_t slicepartition = slice*6+partition;
+ if(slicepartition<0 || slicepartition > fkNPartition){
+ HLTWarning("Wrong header of TPC cluster data, slice %d, partition %d", slice, partition );
+ continue;
+ }
+ const AliHLTTPCClusterData * clusterData = ( AliHLTTPCClusterData* )( iter->fPtr );
+ if( clusterData ) {
+ partitionClusters[slicepartition] = clusterData;
+ partitionNClusters[slicepartition] = clusterData->fSpacePointCnt;
+ }
+ } // end of loop over blocks of clusters
+ }
+
+
+ AliFlatESDFriend *flatFriend = reinterpret_cast<AliFlatESDFriend*>(outputPtr + size);
+
+ size_t freeSpaceTotal = maxOutputSize - size;
+ size_t freeSpace = freeSpaceTotal;
+
+ err = ( freeSpace < sizeof( AliFlatESDEvent ) );
+ if( err ) break;
+
+ new (flatFriend) AliFlatESDFriend;
+
+ freeSpace = freeSpaceTotal - flatFriend->GetSize();
+
+ // fill event info
+ {
+ //flatFriend->SetSkipBit( 0 ); // SG!!
+ for( Int_t iSlice=0; iSlice<36; iSlice++ ){
+ int iSector = iSlice;
+ int nclu = 0;
+ for( Int_t iPartition=0; iPartition<3; iPartition++){
+ int slicepartition = iSlice*6+iPartition;
+ nclu+= partitionNClusters[slicepartition];
+ }
+ flatFriend->SetNclustersTPC( iSector, nclu );
+ iSector = 36+iSlice;
+ nclu = 0;
+ for( Int_t iPartition=3; iPartition<6; iPartition++){
+ int slicepartition = iSlice*6+iPartition;
+ nclu+= partitionNClusters[slicepartition];
+ }
+ flatFriend->SetNclustersTPC( iSector, nclu );
+ //SG!!!flatFriend->SetNclustersTPCused( iSector, esdFriend->GetNclustersTPCused(iSector) );
+ }
+ }
+
+ { // Fill track friends information to the flat ESD friend structure
+
+ size_t trackSize = 0;
+ int nTracks = 0;
+ int nTrackEntries = 0;
+ Long64_t *table = NULL;
+ AliFlatESDFriendTrack *flatTrack = NULL;
+ err = flatFriend->SetTracksStart( flatTrack, table, tracksTPC.size(), freeSpace );
+ if( err ) break;
+ freeSpace = freeSpaceTotal - flatFriend->GetSize();
+
+ for( UInt_t tpcIter=0, itsIter = 0, itsOutIter = 0; tpcIter < tracksTPC.size(); tpcIter++) {
+ // TPC track parameters
- Double_t statistics[10];
- TString names[10];
- fBenchmark.GetStatisticsData(statistics, names);
- fBenchmark.Reset();
-
- AliSysInfo::AddStamp("AliHLTGlobalFlatEsdConverterComponent::DoEvent.Stop", (int)(statistics[1]), (int)(statistics[2]),flatEsd->GetNumberOfV0s(),flatEsd->GetNumberOfTracks() );
+ AliHLTGlobalBarrelTrack *tpcTrack = &(tracksTPC[tpcIter]);
+ AliHLTGlobalBarrelTrack *tpcOutTrack = &(tracksTPCOut[tpcIter]);
+
+ // ITS track parameters
+
+ AliHLTGlobalBarrelTrack *itsRefit=0;
+ AliHLTGlobalBarrelTrack *itsOut=0;
+
+ // ITS Refit track
+
+ for(; itsIter< tracksITS.size() && tracksITS[itsIter].TrackID()<(int) tpcIter; itsIter++ );
+
+ if( itsIter< tracksITS.size() && tracksITS[itsIter].TrackID() == (int) tpcIter ){
+ itsRefit = &(tracksITS[itsIter]);
+ itsIter++;
+ }
+
+ // ITS Out track
+
+ for(; itsOutIter< tracksITSOut.size() && tracksITSOut[itsOutIter].TrackID()<(int) tpcIter; itsOutIter++ );
+
+ if( itsOutIter< tracksITSOut.size() && tracksITSOut[itsOutIter].TrackID() == (int) tpcIter ){
+ itsOut = &(tracksITSOut[itsOutIter]);
+ itsOutIter++;
+ }
+
+ // fill track parameters
+
+ table[tpcIter] = trackSize;
+ err = ( freeSpace < flatTrack->EstimateSize() );
+ if( err ) break;
+ new (flatTrack) AliFlatESDFriendTrack;
+
+ freeSpace = freeSpaceTotal - flatFriend->GetSize();
+
+ flatTrack->SetSkipBit( 0 );
+ flatTrack->SetTrackParamTPCOut( tpcOutTrack );
+ flatTrack->SetTrackParamITSOut( itsOut );
+ // flatTrack->SetTrackParamTRDIn( track->GetTRDIn() );
+
+ // fill TPC seed
+
+ AliFlatTPCseed* seed = flatTrack->SetTPCseedStart();
+ new( seed ) AliFlatTPCseed;
+
+ seed->SetLabel( tpcTrack->GetLabel() );
+ seed->SetExternalTrackParam( tpcTrack );
+
+ // clusters
+
+ UInt_t nClusters = tpcTrack->GetNumberOfPoints();
+ const UInt_t*clusterIDs = tpcTrack->GetPoints();
+ for(UInt_t ic=0; ic<nClusters; ic++){
+ UInt_t id = clusterIDs[ic];
+ int iSlice = AliHLTTPCSpacePointData::GetSlice(id);
+ int iPartition = AliHLTTPCSpacePointData::GetPatch(id);
+ int iCluster = AliHLTTPCSpacePointData::GetNumber(id);
+
+ if(iSlice<0 || iSlice>36 || iPartition<0 || iPartition>5){
+ HLTError("Corrupted TPC cluster Id: slice %d, partition %d, cluster %d", iSlice, iPartition, iCluster);
+ continue;
+ }
+
+ const AliHLTTPCClusterData * clusterData = partitionClusters[iSlice*6 + iPartition];
+ if(!clusterData ){
+ HLTError("Clusters are missed for slice %d, partition %d", iSlice, iPartition );
+ continue;
+ }
+
+ if(iCluster >= partitionNClusters[iSlice*6 + iPartition]){
+ HLTError("TPC slice %d, partition %d: ClusterID==%d >= N Cluaters==%d ", iSlice, iPartition,iCluster, partitionNClusters[iSlice*6 + iPartition] );
+ continue;
+ }
+
+
+ const AliHLTTPCSpacePointData *chlt = &( clusterData->fSpacePoints[iCluster] );
+ AliTPCclusterMI cl;
+ cl.SetX(chlt->fX);
+ cl.SetY(chlt->fY);
+ cl.SetZ(chlt->fZ);
+ cl.SetSigmaY2(chlt->fSigmaY2);
+ cl.SetSigmaYZ( 0 );
+ cl.SetSigmaZ2(chlt->fSigmaZ2);
+ cl.SetQ( chlt->fCharge );
+ cl.SetMax( chlt->fQMax );
+ Int_t sector, row;
+ AliHLTTPCTransform::Slice2Sector(iSlice,chlt->fPadRow, sector, row);
+ cl.SetDetector( sector );
+ cl.SetRow( row );
+ //Float_t padtime[3] = {0,chlt->fY,chlt->fZ};
+ //AliHLTTPCTransform::Local2Raw( padtime, sector, row);
+ //cl.SetPad( (Int_t) padtime[1] );
+ //cl.SetTimeBin( (Int_t) padtime[2] );
+
+
+ tpcTrack->Propagate( TMath::DegToRad()*(sector%18*20.+10.), cl.GetX(), GetBz() );
+ Double_t angle2 = tpcTrack->GetSnp()*tpcTrack->GetSnp();
+ angle2 = (angle2<1) ?TMath::Sqrt(angle2/(1-angle2)) :10.;
+ AliTPCTrackerPoint point;
+ point.SetAngleY( angle2 );
+ point.SetAngleZ( tpcTrack->GetTgl() );
+
+ seed->AddCluster(&cl, &point );
+ } // end of associated cluster loop
+
+
+ flatTrack->SetTPCseedEnd( seed->GetSize() );
+
+ trackSize += flatTrack->GetSize();
+ freeSpace -= flatTrack->GetSize();
+ nTrackEntries++;
+ nTracks++;
+ flatTrack = flatTrack->GetNextTrackNonConst();
+
+ } // fill tracks
+
+
+ flatFriend->SetTracksEnd( nTracks, nTrackEntries, trackSize );
+
+ }
+
+ if( err ) break;
+
+ { // set up the output block description
+
+ AliHLTComponentBlockData outBlock;
+ FillBlockData( outBlock );
+ outBlock.fOffset = size;
+ outBlock.fSize = flatFriend->GetSize();
+ outBlock.fDataType = kAliHLTDataTypeFlatESDFriend|kAliHLTDataOriginOut;
+ outputBlocks.push_back( outBlock );
+ fBenchmark.AddOutput(outBlock.fSize);
+ size += outBlock.fSize;
+ }
+
+ break;
}
+
++ fBenchmark.Stop(0);
++ //HLTWarning( fBenchmark.GetStatistics() );
+
+ if( err ){
+ HLTWarning( "Output buffer size %d exceeded, flat ESD friend event is not stored", maxOutputSize );
+ return -ENOSPC;
+ }
-
- fBenchmark.Stop(0);
- HLTWarning( fBenchmark.GetStatistics() );
- fBenchmark.Stop(0);
- HLTWarning( fBenchmark.GetStatistics() );
- if( err ){
- HLTWarning( "Output buffer size %d exceeded, flat ESD event is not stored", maxOutputSize );
- return -ENOSPC;
- }
++ if(benchmark){
++ Double_t statistics[10];
++ TString names[10];
++ fBenchmark.GetStatisticsData(statistics, names);
++ fBenchmark.Reset();
++ AliSysInfo::AddStamp("AliHLTGlobalFlatEsdConverterComponent::DoEvent.Stop", (int)(statistics[1]), (int)(statistics[2]),flatEsd->GetNumberOfV0s(),flatEsd->GetNumberOfTracks() );
++ }
+
return 0;
}