A block of ITSOut tracks is produced in addition to the ITS tracks ( ITSOut tracks...
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 5 Nov 2009 23:16:07 +0000 (23:16 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 5 Nov 2009 23:16:07 +0000 (23:16 +0000)
- new AliHLTDataTypeOriginITSOut created

- GlobalESDConverter adds ITSOut parameters to the esd tracks

- now ITS tracks contain indixes of the associated ITS clusters (but these indices are not yet stored in the ESD tracks )

HLT/BASE/AliHLTDataTypes.cxx
HLT/BASE/AliHLTDataTypes.h
HLT/ITS/tracking/AliHLTITSTrackerComponent.cxx
HLT/ITS/tracking/AliHLTITSTrackerComponent.h
HLT/ITS/tracking/AliITStrackerHLT.cxx
HLT/ITS/tracking/AliITStrackerHLT.h
HLT/global/AliHLTGlobalEsdConverterComponent.cxx

index ab9c60d..fd5cbc2 100644 (file)
@@ -238,6 +238,9 @@ const char kAliHLTDataOriginTRD[kAliHLTComponentDataTypefOriginSize]     = {'T',
 /** ITS */
 const char kAliHLTDataOriginITS[kAliHLTComponentDataTypefOriginSize]     = {'I','T','S',' '};
 
+/** ITSOut */
+const char kAliHLTDataOriginITSOut[kAliHLTComponentDataTypefOriginSize]     = {'I','T','S','O'};
+
 /** ITS-SPD */
 const char kAliHLTDataOriginITSSPD[kAliHLTComponentDataTypefOriginSize]  = {'I','S','P','D'};
 
index ab6eb1d..220cfa6 100644 (file)
@@ -146,6 +146,11 @@ extern const char kAliHLTDataOriginTRD[kAliHLTComponentDataTypefOriginSize];
  */
 extern const char kAliHLTDataOriginITS[kAliHLTComponentDataTypefOriginSize];
 
+/** Data origin ITSOut 
+ * @ingroup alihlt_component_datatypes
+ */
+extern const char kAliHLTDataOriginITSOut[kAliHLTComponentDataTypefOriginSize];
+
 /** Data origin ITS SPD
  * @ingroup alihlt_component_datatypes
  */
index 7e7547c..6401f8b 100644 (file)
@@ -120,14 +120,23 @@ void AliHLTITSTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataTyp
 AliHLTComponentDataType AliHLTITSTrackerComponent::GetOutputDataType()
 {
   // see header file for class documentation  
-  return kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
+  return kAliHLTMultipleDataType;
+}
+
+int AliHLTITSTrackerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
+{
+  // see header file for class documentation  
+  tgtList.clear();
+  tgtList.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginITS);
+  tgtList.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut);
+  return tgtList.size();
 }
 
 void AliHLTITSTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 {
   // define guess for the output data size
   constBase = 200;       // minimum size
-  inputMultiplier = 0.5; // size relative to input
+  inputMultiplier = 1.; // size relative to input
 }
 
 AliHLTComponent* AliHLTITSTrackerComponent::Spawn()
@@ -417,64 +426,71 @@ int AliHLTITSTrackerComponent::DoEvent
   // Fill output tracks
   int nITSUpdated = 0;
   {
-    unsigned int mySize = 0;    
-     
-    AliHLTTracksData* outPtr = ( AliHLTTracksData* )( outputPtr );
-
-    AliHLTExternalTrackParam* currOutTrack = outPtr->fTracklets;
+    
+    for( int iOut=0; iOut<=1; iOut++ ){
 
-    mySize =   ( ( AliHLTUInt8_t * )currOutTrack ) -  ( ( AliHLTUInt8_t * )outputPtr );
+      unsigned int blockSize = 0;
 
-    outPtr->fCount = 0;
-    
-    int nTracks = fTracker->Tracks().size();
+      AliHLTTracksData* outPtr = ( AliHLTTracksData* )( outputPtr + size );
+      AliHLTExternalTrackParam* currOutTrack = outPtr->fTracklets;
 
-    for ( int itr = 0; itr < nTracks; itr++ ) {
+      blockSize =   ( ( AliHLTUInt8_t * )currOutTrack ) -  ( ( AliHLTUInt8_t * )outPtr );
 
-      const AliExternalTrackParam &tp = fTracker->Tracks()[itr];      
-      int id =  tracksTPCId[fTracker->Tracks()[itr].TPCtrackId()];
+      outPtr->fCount = 0;
       
-      int nClusters = 0;
-      if( fTracker->Tracks()[itr].GetNumberOfClusters()>0 ) nITSUpdated++;
-
-      unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + nClusters * sizeof( unsigned int );
+      std::vector< AliHLTITSTrack > &tracks = (iOut==0)?fTracker->Tracks() :fTracker->ITSOutTracks();
 
-      if ( mySize + dSize > maxBufferSize ) {
-        HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, mySize, nTracks - itr + 1 );
-        iResult = -ENOSPC;
-        break;
+      int nTracks = tracks.size();
+      
+      for ( int itr = 0; itr < nTracks; itr++ ) {
+       AliHLTITSTrack &t = tracks[itr];
+       int id =  tracksTPCId[t.TPCtrackId()];      
+       int nClusters = t.GetNumberOfClusters();
+       if( iOut==0 && nClusters>0 ) nITSUpdated++;
+       
+       unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + nClusters * sizeof( unsigned int );
+       
+       if ( size + blockSize + dSize > maxBufferSize ) {
+         HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, size + blockSize + dSize, nTracks - itr + 1 );
+         iResult = -ENOSPC;
+         break;
+       }
+       
+       currOutTrack->fAlpha = t.GetAlpha();
+       currOutTrack->fX = t.GetX();
+       currOutTrack->fY = t.GetY();
+       currOutTrack->fZ = t.GetZ();            
+       currOutTrack->fLastX = 0;
+       currOutTrack->fLastY = 0;
+       currOutTrack->fLastZ = 0;      
+       currOutTrack->fq1Pt = t.GetSigned1Pt();
+       currOutTrack->fSinPsi = t.GetSnp();
+       currOutTrack->fTgl = t.GetTgl();
+       for( int i=0; i<15; i++ ) currOutTrack->fC[i] = t.GetCovariance()[i];
+       currOutTrack->fTrackID = id;
+       currOutTrack->fFlags = 0;
+       currOutTrack->fNPoints = nClusters;    
+       for ( int i = 0; i < nClusters; i++ ) currOutTrack->fPointIDs[i] = t.GetClusterIndex( i );
+       currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
+       blockSize += dSize;
+       outPtr->fCount++;
       }
-
-      currOutTrack->fAlpha = tp.GetAlpha();
-      currOutTrack->fX = tp.GetX();
-      currOutTrack->fY = tp.GetY();
-      currOutTrack->fZ = tp.GetZ();            
-      currOutTrack->fLastX = 0;
-      currOutTrack->fLastY = 0;
-      currOutTrack->fLastZ = 0;      
-      currOutTrack->fq1Pt = tp.GetSigned1Pt();
-      currOutTrack->fSinPsi = tp.GetSnp();
-      currOutTrack->fTgl = tp.GetTgl();
-      for( int i=0; i<15; i++ ) currOutTrack->fC[i] = tp.GetCovariance()[i];
-      currOutTrack->fTrackID = id;
-      currOutTrack->fFlags = 0;
-      currOutTrack->fNPoints = nClusters;    
-      currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
-      mySize += dSize;
-      outPtr->fCount++;
-    }
   
 
-    AliHLTComponentBlockData resultData;
-    FillBlockData( resultData );
-    resultData.fOffset = 0;
-    resultData.fSize = mySize;
-    resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
-    outputBlocks.push_back( resultData );
-    size = resultData.fSize;  
-    
+      AliHLTComponentBlockData resultData;
+      FillBlockData( resultData );
+      resultData.fOffset = 0;
+      resultData.fSize = blockSize;
+      if( iOut==0 ){
+       resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
+      } else {
+       resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut;
+      }
+      outputBlocks.push_back( resultData );
+      size += resultData.fSize;       
+    }  
   }
-
+  
   timer.Stop();
   fFullTime += timer.RealTime();
   fRecoTime += timerReco.RealTime();
index 8a894cc..5b67a7a 100644 (file)
@@ -91,6 +91,9 @@ class AliHLTITSTrackerComponent : public AliHLTProcessor
     /** @see component interface @ref AliHLTComponent::GetOutputDataType */
     AliHLTComponentDataType GetOutputDataType() ;
 
+    /** @see component interface @ref AliHLTComponent::GetOutputDataType */
+    int  GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
+
     /** @see component interface @ref AliHLTComponent::GetOutputDataSize */
     virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) ;
 
index c43adc0..ce9b18b 100644 (file)
@@ -86,6 +86,7 @@ AliITStrackerHLT::AliITStrackerHLT()
    fDebugStreamer(0),
    fITSChannelStatus(0),
    fTracks(),
+   fITSOutTracks(),
    fLoadTime(0),
    fRecoTime(0),
    fNEvents(0),
@@ -109,6 +110,7 @@ AliITStrackerHLT::AliITStrackerHLT(const Char_t *geom)
   fDebugStreamer(0),
   fITSChannelStatus(0),
   fTracks(),
+  fITSOutTracks(),
   fLoadTime(0),
    fRecoTime(0),
   fNEvents(0),
@@ -225,6 +227,7 @@ AliITStrackerHLT::AliITStrackerHLT(const AliITStrackerHLT &tracker)
  fDebugStreamer(tracker.fDebugStreamer),
  fITSChannelStatus(tracker.fITSChannelStatus),
  fTracks(),
+ fITSOutTracks(),
   fLoadTime(0),
    fRecoTime(0),
  fNEvents(0),
@@ -371,6 +374,7 @@ void AliITStrackerHLT::Reconstruct( std::vector<AliExternalTrackParam> tracksTPC
 
   Double_t pimass = TDatabasePDG::Instance()->GetParticle(211)->Mass();
   fTracks.clear();
+  fITSOutTracks.clear();
 
   for( unsigned int itr=0; itr<tracksTPC.size(); itr++ ){
 
@@ -402,6 +406,12 @@ void AliITStrackerHLT::Reconstruct( std::vector<AliExternalTrackParam> tracksTPC
    
     TransportToX(t, 0 );
     fTracks.push_back( *t );  
+    if(  nclu>0 ){ // construct ITSOut track
+      AliHLTITSTrack tOut(*t);
+      if( FitOutward( &tOut ) ){
+       fITSOutTracks.push_back( *t );          
+      }
+    }
   }
 
   timer.Stop();
@@ -576,6 +586,41 @@ void AliITStrackerHLT::FollowProlongationTree(AliHLTITSTrack * track )
 }
 
 
+
+Int_t AliITStrackerHLT::FitOutward(AliHLTITSTrack * track ) 
+{
+
+  track->ResetCovariance(100);
+
+  for (Int_t iTrCl=track->GetNumberOfClusters()-1; iTrCl>=0; iTrCl--) {
+    
+    Int_t index = track->GetClusterIndex(iTrCl);
+    Int_t ilayer=(index & 0xf0000000) >> 28;
+    Int_t ic=(index & 0x0fffffff) >> 00;
+    const AliHLTITSLayer &layer=fLayers[ilayer];
+    AliITSRecPoint *cl = layer.GetCluster(ic); 
+    int idet = cl->GetDetectorIndex();
+    const AliHLTITSDetector &det=layer.GetDetector( idet );
+    // material between SSD and SDD, SDD and SPD
+    //if (ilayer==4 && !CorrectForShieldMaterial(track,1)) continue;
+    //if (ilayer==2 && !CorrectForShieldMaterial(track,0)) continue;
+    
+
+    // propagate to the intersection with the detector plane     
+    {
+      if (!TransportToPhiX( track, det.GetPhi(), det.GetR()+ cl->GetX() ) ) return 0;
+      CorrectForLayerMaterial(track,ilayer);
+    }
+
+    Double_t par[2]={ cl->GetY(), cl->GetZ()};
+    Double_t cov[3]={ cl->GetSigmaY2(), 0., cl->GetSigmaZ2()};
+    if( !track->AliExternalTrackParam::Update(par,cov) ) return 0;    
+  }
+  return 1;
+}
+
+
 //------------------------------------------------------------------------
 AliHLTITSLayer & AliITStrackerHLT::GetLayer(Int_t layer) const
 {
index 4d0d058..6069911 100644 (file)
@@ -33,6 +33,7 @@ public:
   void Reconstruct( std::vector<AliExternalTrackParam> tracksTPC );
 
   std::vector< AliHLTITSTrack > &Tracks(){ return fTracks;}
+  std::vector< AliHLTITSTrack > &ITSOutTracks(){ return fITSOutTracks;}
 
   Bool_t TransportToX( AliExternalTrackParam *t, double x ) const;
   Bool_t TransportToPhiX( AliExternalTrackParam *t, double phi, double x ) const;
@@ -64,6 +65,7 @@ public:
   AliHLTITSDetector & GetDetector(Int_t layer, Int_t n) const {return GetLayer(layer).GetDetector(n); }
  
   void FollowProlongationTree(AliHLTITSTrack * otrack);
+  Int_t FitOutward(AliHLTITSTrack * track );
 
   void Init();
 
@@ -111,7 +113,8 @@ protected:
 
   TTreeSRedirector *fDebugStreamer;      //!debug streamer
   AliITSChannelStatus *fITSChannelStatus;//! bitmaps with channel status for SPD and SDD
-  std::vector< AliHLTITSTrack > fTracks;
+  std::vector< AliHLTITSTrack > fTracks; // array of its-updated tracks
+  std::vector< AliHLTITSTrack > fITSOutTracks; // array of tracks, fitted outward with ITS only
 
   double fLoadTime;
   double fRecoTime;
index e8c453f..b0718ce 100644 (file)
@@ -393,17 +393,36 @@ int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent*
          ncl++;
        }
        //tITS.SetNumberOfClusters( ncl );
+       element->SetNumberOfClusters(0);
        int tpcID=element->TrackID();
        // the ITS tracker assigns the TPC track used as seed for a certain track to
        // the trackID
        if( tpcID<0 || tpcID>=pESD->GetNumberOfTracks()) continue;
-
        AliESDtrack *tESD = pESD->GetTrack( tpcID );
        if( tESD ) tESD->UpdateTrackParams( &(*element), AliESDtrack::kITSin );
       }
     }
   }
 
+  // now update ESD tracks with the ITSOut info
+  for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut);
+       pBlock!=NULL; pBlock=GetNextInputBlock()) {
+    vector<AliHLTGlobalBarrelTrack> tracks;
+    if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) {
+      for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin();
+          element!=tracks.end(); element++) {
+       element->SetNumberOfClusters(0);
+       int tpcID=element->TrackID();
+       // the ITS tracker assigns the TPC track used as seed for a certain track to
+       // the trackID
+       if( tpcID<0 || tpcID>=pESD->GetNumberOfTracks()) continue;
+       AliESDtrack *tESD = pESD->GetTrack( tpcID );
+       if( tESD ) tESD->UpdateTrackParams( &(*element), AliESDtrack::kITSout );
+      }
+    }
+  }
+
+
   // convert the HLT TRD tracks to ESD tracks                        
   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack | kAliHLTDataOriginTRD);
        pBlock!=NULL; pBlock=GetNextInputBlock()) {