MC labels added for ITS tracks ?\127 ?\127?\127
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 May 2010 00:40:38 +0000 (00:40 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 May 2010 00:40:38 +0000 (00:40 +0000)
HLT/ITS/AliHLTITSAgent.cxx
HLT/ITS/AliHLTITSVertexerSPDComponent.cxx
HLT/ITS/tracking/AliHLTITSTrackerComponent.cxx
HLT/ITS/tracking/AliITStrackerHLT.cxx
HLT/ITS/tracking/AliITStrackerHLT.h
HLT/global/AliHLTGlobalEsdConverterComponent.cxx

index 19d4dd2..0914eaa 100644 (file)
@@ -160,6 +160,10 @@ int AliHLTITSAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
       // add the TPC tracking if available
       trackerInput+=" TPC-globalmerger";
     }
+    if (handler->FindConfiguration("TPC-mcTrackMarker")) {
+      // add the TPC tracking if available
+      trackerInput+=" TPC-mcTrackMarker";
+    }
     handler->CreateConfiguration("ITS-tracker","ITSTracker",trackerInput.Data(),"");
   }
 
index 86959f4..424894e 100644 (file)
@@ -611,7 +611,7 @@ int AliHLTITSVertexerSPDComponent::DoEvent
        maxW = fSumN[i];
       }
     }
-    if( bestBin<0 || fSumN[bestBin] < 5 ){
+    if( bestBin<0 || fSumN[bestBin] < 3 ){
       bestBin = -1;
       break;
     }
index 781daef..47a9438 100644 (file)
@@ -50,7 +50,7 @@ using namespace std;
 #include "AliHLTExternalTrackParam.h"
 #include "AliHLTGlobalBarrelTrack.h"
 #include "AliGeomManager.h"
-
+#include "AliHLTTrackMCLabel.h"
 
 
 /** ROOT macro for the implementation of ROOT specific class methods */
@@ -108,6 +108,7 @@ void AliHLTITSTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataTyp
   // see header file for class documentation
   list.clear();
   list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
+  list.push_back( kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC );
   list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
   list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD );
   list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD );
@@ -126,6 +127,7 @@ int AliHLTITSTrackerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& t
   tgtList.clear();
   tgtList.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginITS);
   tgtList.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut);
+  tgtList.push_back( kAliHLTDataTypeTrackMC|kAliHLTDataOriginITS );
   return tgtList.size();
 }
 
@@ -355,6 +357,7 @@ int AliHLTITSTrackerComponent::DoEvent
 
   
   vector< AliExternalTrackParam > tracksTPC;
+  vector< int > tracksTPCLab;
   vector< int > tracksTPCId;
 
   int nClustersTotal = 0;
@@ -376,10 +379,34 @@ int AliHLTITSTrackerComponent::DoEvent
 
   fTracker->StartLoadClusters(nClustersTotal);
 
+  // first read MC information (if present)
+  
+  std::map<int,int> mcLabels;
+
+  for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC);
+       pBlock!=NULL; pBlock=GetNextInputBlock()) {
+    
+    fBenchmark.AddInput(pBlock->fSize);
+    
+    AliHLTTrackMCData* dataPtr = reinterpret_cast<AliHLTTrackMCData*>( pBlock->fPtr );
+    if (sizeof(AliHLTTrackMCData)+dataPtr->fCount*sizeof(AliHLTTrackMCLabel)==pBlock->fSize) {
+      for( unsigned int il=0; il<dataPtr->fCount; il++ ){
+       AliHLTTrackMCLabel &lab = dataPtr->fLabels[il];
+       mcLabels[lab.fTrackID] = lab.fMCLabel;
+      }
+    } else {
+      HLTWarning("data mismatch in block %s (0x%08x): count %d, size %d -> ignoring track MC information", 
+                DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, 
+                dataPtr->fCount, pBlock->fSize);
+    }
+  }
+  
+  
+  
   for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
 
     const AliHLTComponentBlockData* iter = blocks+ndx;
+    
     // Read TPC tracks
     
     if( iter->fDataType == ( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC ) ){      
@@ -389,7 +416,12 @@ int AliHLTITSTrackerComponent::DoEvent
       AliHLTExternalTrackParam* currOutTrack = dataPtr->fTracklets;
       for( int itr=0; itr<nTracks; itr++ ){
        AliHLTGlobalBarrelTrack t(*currOutTrack);
+       Int_t mcLabel = -1;
+       if( mcLabels.find(currOutTrack->fTrackID)!=mcLabels.end() )
+         mcLabel = mcLabels[currOutTrack->fTrackID];
+       
        tracksTPC.push_back( t );
+       tracksTPCLab.push_back(mcLabel);
        tracksTPCId.push_back( currOutTrack->fTrackID );
        unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + currOutTrack->fNPoints * sizeof( unsigned int );
        currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
@@ -417,6 +449,7 @@ int AliHLTITSTrackerComponent::DoEvent
        Float_t hit[6] = { d.fY, d.fZ, d.fSigmaY2, d.fSigmaZ2, d.fQ, d.fSigmaYZ };
        if( d.fLayer==4 ) hit[5] = -hit[5];
        fTracker->LoadCluster( AliITSRecPoint( lab, hit, info ) );
+       //cout<<"SG "<<d.fLayer<<" "<<d.fTracks[0]<<endl;
       }   
     }
     
@@ -425,7 +458,7 @@ int AliHLTITSTrackerComponent::DoEvent
   // Reconstruct the event
 
     fBenchmark.Start(1);
-    fTracker->Reconstruct( &(tracksTPC[0]), tracksTPC.size() );
+    fTracker->Reconstruct( &(tracksTPC[0]), &(tracksTPCLab[0]), tracksTPC.size() );
     fBenchmark.Stop(1);
 
   
@@ -496,7 +529,7 @@ int AliHLTITSTrackerComponent::DoEvent
 
       AliHLTComponentBlockData resultData;
       FillBlockData( resultData );
-      resultData.fOffset = 0;
+      resultData.fOffset = size;
       resultData.fSize = blockSize;
       if( iOut==0 ){
        resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
@@ -506,10 +539,51 @@ int AliHLTITSTrackerComponent::DoEvent
       fBenchmark.AddOutput(resultData.fSize);
       outputBlocks.push_back( resultData );
       size += resultData.fSize;       
-    }  
+    }
+  }  
+
+  {// fill MC labels
+
+    unsigned int blockSize = 0;
+      
+    AliHLTTrackMCData* outPtr = ( AliHLTTrackMCData* )( outputPtr +size );
+    AliHLTTrackMCLabel* currOutLabel = outPtr->fLabels;
+    
+    blockSize =   ( ( AliHLTUInt8_t * )currOutLabel ) -  ( ( AliHLTUInt8_t * )outPtr );
+    
+    outPtr->fCount = 0;
+    
+    AliHLTITSTrack *tracks= fTracker->Tracks();
+    int nTracks = fTracker->NTracks();
+    
+    for ( int itr = 0; itr < nTracks; itr++ ) {
+      AliHLTITSTrack &t = tracks[itr];
+      //cout<<"SG out:"<<tracksTPCId[t.TPCtrackId()]<<" "<<t.GetLabel()<<endl;
+      if( t.GetLabel()<0 ) continue;
+      int id =  tracksTPCId[t.TPCtrackId()];
+      
+      if ( blockSize + sizeof(AliHLTTrackMCLabel) > maxBufferSize ) {
+       HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d mc labels are not stored", maxBufferSize, blockSize, nTracks - itr + 1 );
+       iResult = -ENOSPC;
+       break;
+      }
+      currOutLabel->fTrackID = id;
+      currOutLabel->fMCLabel = t.GetLabel();
+      blockSize += sizeof(AliHLTTrackMCLabel);
+      currOutLabel++;
+      outPtr->fCount++;
+    }        
+    
+    AliHLTComponentBlockData resultData;
+    FillBlockData( resultData );
+    resultData.fOffset = size;
+    resultData.fSize = blockSize;
+    resultData.fDataType = kAliHLTDataTypeTrackMC|kAliHLTDataOriginITS;
+    outputBlocks.push_back( resultData );
+    size+= resultData.fSize;
   }
   
-   fBenchmark.Stop(0);
+  fBenchmark.Stop(0);
 
   // Set log level to "Warning" for on-line system monitoring
   HLTInfo( "ITS Tracker: output %d tracks;  input %d clusters, %d tracks",
index 01dce20..b6196b1 100644 (file)
@@ -355,7 +355,7 @@ void AliITStrackerHLT::UnloadClusters() {
 
 
 
-void AliITStrackerHLT::Reconstruct( AliExternalTrackParam *tracksTPC, int nTPCTracks )
+void AliITStrackerHLT::Reconstruct( AliExternalTrackParam *tracksTPC, int *tracksTPCLab, int nTPCTracks )
 {
 
   //--------------------------------------------------------------------
@@ -395,18 +395,19 @@ void AliITStrackerHLT::Reconstruct( AliExternalTrackParam *tracksTPC, int nTPCTr
   fITSOutTracks = new AliHLTITSTrack[nTPCTracks];
   fNTracks = 0;
   fNITSOutTracks = 0;
-  for( int itr=0; itr<nTPCTracks; itr++ ){
+  for( int itr=0; itr<nTPCTracks; itr++ ){    
 
     AliHLTITSTrack tMI( tracksTPC[itr] );
     AliHLTITSTrack *t = &tMI;
     t->SetTPCtrackId( itr );
     t->SetMass(pimass); 
     t->SetExpQ(0);
+    t->SetLabel(tracksTPCLab[itr]);
 
     //if (!CorrectForTPCtoITSDeadZoneMaterial(t))  continue;
       
-    //Int_t tpcLabel=t->GetLabel(); //save the TPC track label       
-      
+    Int_t tpcLabel=t->GetLabel(); //save the TPC track label       
+    
     FollowProlongationTree(t); 
     int nclu=0;
     for(Int_t i=0; i<6; i++) {
@@ -415,16 +416,18 @@ void AliITStrackerHLT::Reconstruct( AliExternalTrackParam *tracksTPC, int nTPCTr
     //cout<<"N assigned ITS clusters = "<<nclu<<std::endl;
     t->SetLabel(-1);
     if( nclu>0 ){
-      t->SetLabel(-1);//tpcLabel);
+      t->SetLabel(tpcLabel);
       t->SetFakeRatio(1.);
       CookLabel(t,.99); //For comparison only
-      //cout<<"label = "<<t->GetLabel()<<" / "<<tpcLabel<<endl;
+      //cout<<"SG: label = "<<t->GetLabel()<<" / "<<tpcLabel<<endl;
     }
 
-    //CorrectForPipeMaterial(t);
+    CorrectForPipeMaterial(t);
    
     TransportToX(t, 0 );
     fTracks[fNTracks++] = *t;  
+    //cout<<"SG: ITS: Bz = "<<t->GetBz()<<endl;
+
     if(  nclu>0 ){ // construct ITSOut track
       AliHLTITSTrack tOut(*t);
       if( FitOutward( &tOut ) ){
@@ -448,6 +451,7 @@ Int_t AliITStrackerHLT::Clusters2Tracks(AliESDEvent *event) {
   
   
   std::vector<AliExternalTrackParam> tracksTPC;
+  std::vector<int> tracksTPCLab;
   tracksTPC.reserve(event->GetNumberOfTracks());
 
   for( int itr=0; itr<event->GetNumberOfTracks(); itr++ ){
@@ -462,9 +466,10 @@ Int_t AliITStrackerHLT::Clusters2Tracks(AliESDEvent *event) {
     AliHLTITSTrack t(*esdTrack);
     t.SetTPCtrackId( itr );
     tracksTPC.push_back( t );
+    tracksTPCLab.push_back(esdTrack->GetLabel());
   }
   //for( int iter=0; iter<100; iter++){
-  Reconstruct( &(tracksTPC[0]), tracksTPC.size() );
+  Reconstruct( &(tracksTPC[0]), &(tracksTPCLab[0]), tracksTPC.size() );
   //}
 
   for( int itr=0; itr<fNTracks; itr++ ){
@@ -478,12 +483,12 @@ Int_t AliITStrackerHLT::Clusters2Tracks(AliESDEvent *event) {
   int hz1 = ( int ) ( fRecoTime > 1.e-4 ? fNEvents / fRecoTime : 0 );
   int hz2 = ( int ) ( fLoadTime > 1.e-4 ? fNEvents / fLoadTime : 0 );
 
-  std::cout<<"\n\n ITS tracker time = "<<hz2<<" Hz load / "<<hz1<<" Hz reco ="
-          <<hz<<
-    " Hz ("
-          <<fLoadTime/fNEvents*1000<<"+"<<fRecoTime/fNEvents*1000.
-          <<" = "<<(fLoadTime + fRecoTime)/fNEvents*1000.
-          <<" ms/ev), "<<fNEvents<<" events processed\n\n "<<std::endl;
+  //std::cout<<"\n\nSG: ITS tracker time = "<<hz2<<" Hz load / "<<hz1<<" Hz reco ="
+  //<<hz<<
+  //" Hz ("
+  //<<fLoadTime/fNEvents*1000<<"+"<<fRecoTime/fNEvents*1000.
+  //<<" = "<<(fLoadTime + fRecoTime)/fNEvents*1000.
+  //<<" ms/ev), "<<fNEvents<<" events processed\n\n "<<std::endl;
   return 0;
 }
 
@@ -659,18 +664,20 @@ void AliITStrackerHLT::CookLabel(AliHLTITSTrack *track,Float_t wrong) const
   
   vector<int> labels;
   Int_t nClusters = track->GetNumberOfClusters();
-
+  Int_t nClustersEff = 0;
   for (Int_t i=0; i<nClusters; i++){
     Int_t cindex = track->GetClusterIndex(i);
     //Int_t l=(cindex & 0xf0000000) >> 28;
     AliITSRecPoint *cl = (AliITSRecPoint*)GetCluster(cindex);    
-    if ( cl->GetLabel(0) >= 0 ) labels.push_back(cl->GetLabel(0)) ;
+    if ( cl->GetLabel(0) >= 0 ){ labels.push_back(cl->GetLabel(0)) ; nClustersEff++; }
     if ( cl->GetLabel(1) >= 0 ) labels.push_back(cl->GetLabel(1)) ;
     if ( cl->GetLabel(2) >= 0 ) labels.push_back(cl->GetLabel(2)) ;
   }
-  std::sort( labels.begin(), labels.end() );     
+  std::sort( labels.begin(), labels.end() );
+
   labels.push_back( -1 ); // put -1 to the end   
   int labelMax = -1, labelCur = -1, nLabelsMax = 0, nLabelsCurr = 0;
+
   for ( unsigned int iLab = 0; iLab < labels.size(); iLab++ ) {
     if ( labels[iLab] != labelCur ) {        
       if ( labelCur >= 0 && nLabelsMax< nLabelsCurr ) {
@@ -682,8 +689,8 @@ void AliITStrackerHLT::CookLabel(AliHLTITSTrack *track,Float_t wrong) const
     }
     nLabelsCurr++;
   }
-         
-  if( labelMax>=0 && nLabelsMax < wrong * nClusters ) labelMax = -labelMax;
+
+  if( labelMax>=0 && nLabelsMax < wrong * nClustersEff ) labelMax = -labelMax;
   
   mcLabel = labelMax;
                
index 664175e..9875ee3 100644 (file)
@@ -29,7 +29,7 @@ public:
   
   void StartLoadClusters( Int_t NClusters );
   void LoadCluster( const AliITSRecPoint &cluster);
-  void Reconstruct( AliExternalTrackParam *tracksTPC, int nTPCTracks );
+  void Reconstruct( AliExternalTrackParam *tracksTPC, int *tracksTPCLab, int nTPCTracks );
 
   AliHLTITSTrack *Tracks() const { return fTracks;}
   Int_t NTracks() const { return fNTracks;}
index 781161b..7b2d391 100644 (file)
@@ -360,6 +360,7 @@ int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent*
 
   // first read MC information (if present)
   std::map<int,int> mcLabels;
+  std::map<int,int> mcLabelsITS;
 
   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC);
        pBlock!=NULL; pBlock=GetNextInputBlock()) {
@@ -378,6 +379,25 @@ int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent*
                 dataPtr->fCount, pBlock->fSize);
     }
   }
+  for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrackMC|kAliHLTDataOriginITS);
+       pBlock!=NULL; pBlock=GetNextInputBlock()) {
+
+    fBenchmark.AddInput(pBlock->fSize);
+
+    AliHLTTrackMCData* dataPtr = reinterpret_cast<AliHLTTrackMCData*>( pBlock->fPtr );
+    if (sizeof(AliHLTTrackMCData)+dataPtr->fCount*sizeof(AliHLTTrackMCLabel)==pBlock->fSize) {
+      for( unsigned int il=0; il<dataPtr->fCount; il++ ){
+       AliHLTTrackMCLabel &lab = dataPtr->fLabels[il];
+       mcLabelsITS[lab.fTrackID] = lab.fMCLabel;
+      }
+    } else {
+      HLTWarning("data mismatch in block %s (0x%08x): count %d, size %d -> ignoring track MC information", 
+                DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, 
+                dataPtr->fCount, pBlock->fSize);
+    }
+  }
+
 
   // read dEdx information (if present)
 
@@ -493,6 +513,10 @@ int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent*
        // the ITS tracker assigns the TPC track used as seed for a certain track to
        // the trackID
        if( tpcID<0 || tpcID>=pESD->GetNumberOfTracks()) continue;
+       Int_t mcLabel = -1;
+       if( mcLabelsITS.find(element->TrackID())!=mcLabelsITS.end() )
+         mcLabel = mcLabelsITS[element->TrackID()];
+       element->SetLabel( mcLabel );
        AliESDtrack *tESD = pESD->GetTrack( tpcID );
        if( tESD ) tESD->UpdateTrackParams( &(*element), AliESDtrack::kITSin );
       }