HLT/TPCLib/AliHLTTPCCATrackerComponent.cxx

   1
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors: Ivan Kisel <kisel@kip.uni-heidelberg.de>                      *
   7  *          Jochen Thaeder <thaeder@kip.uni-heidelberg.de>                *
   8  *          Matthias Richter <Matthias.Richter@ift.uib.no>                *
   9  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
  10  *          for The ALICE Off-line Project.                               *
  11  *                                                                        *
  12  * Permission to use, copy, modify and distribute this software and its   *
  13  * documentation strictly for non-commercial purposes is hereby granted   *
  14  * without fee, provided that the above copyright notice appears in all   *
  15  * copies and that both the copyright notice and this permission notice   *
  16  * appear in the supporting documentation. The authors make no claims     *
  17  * about the suitability of this software for any purpose. It is          *
  18  * provided "as is" without express or implied warranty.                  *
  19  **************************************************************************/
  20
  21 ///////////////////////////////////////////////////////////////////////////////
  22 //                                                                           //
  23 // a TPC tracker processing component for the HLT based on CA by Ivan Kisel  //
  24 //                                                                           //
  25 ///////////////////////////////////////////////////////////////////////////////
  26
  27 #if __GNUC__>= 3
  28 using namespace std;
  29 #endif
  30
  31 #include "AliHLTTPCCATrackerComponent.h"
  32 #include "AliHLTTPCTransform.h"
  33 #include "AliHLTTPCCATracker.h"
  34 #include "AliHLTTPCVertex.h"
  35 #include "AliHLTTPCSpacePointData.h"
  36 #include "AliHLTTPCVertexData.h"
  37 #include "AliHLTTPCClusterDataFormat.h"
  38 #include "AliHLTTPCTransform.h"
  39 #include "AliHLTTPCTrackSegmentData.h"
  40 #include "AliHLTTPCTrackArray.h"
  41 #include "AliHLTTPCTrackletDataFormat.h"
  42 //#include "AliHLTTPC.h"
  43 #include <stdlib.h>
  44 #include <iostream>
  45 #include <errno.h>
  46
  47 //static bool ask = true;
  48 static bool ask = false;
  49
  50 // this is a global object used for automatic component registration, do not use this
  51 AliHLTTPCCATrackerComponent gAliHLTTPCCATrackerComponent;
  52
  53 ClassImp(AliHLTTPCCATrackerComponent)
  54
  55 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
  56     {
  57     fTracker = NULL;
  58     fVertex = NULL;
  59     }
  60
  61 AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
  62     {
  63     }
  64
  65 // Public functions to implement AliHLTComponent's interface.
  66 // These functions are required for the registration process
  67
  68 const char* AliHLTTPCCATrackerComponent::GetComponentID()
  69     {
  70     return "TPCCATracker";
  71     }
  72
  73 void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
  74     {
  75     list.clear();
  76     list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
  77     list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
  78     }
  79
  80 AliHLTComponent_DataType AliHLTTPCCATrackerComponent::GetOutputDataType()
  81     {
  82     return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
  83     }
  84
  85 void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  86     {
  87     // XXX TODO: Find more realistic values.
  88     constBase = 0;
  89     inputMultiplier = 0.2;
  90     }
  91
  92 AliHLTComponent* AliHLTTPCCATrackerComponent::Spawn()
  93     {
  94     return new AliHLTTPCCATrackerComponent;
  95     }
  96
  97 int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
  98     {
  99     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
 100
 101     if ( fTracker || fVertex )
 102         return EINPROGRESS;
 103
 104     fTracker = new AliHLTTPCCATracker();
 105     fTracker->CACreateHistos();
 106
 107     fVertex = new AliHLTTPCVertex();
 108
 109
 110 /* ---------------------------------------------------------------------------------
 111  * cmdline arguments not needed so far
 112
 113     int i = 0;
 114     char* cpErr;
 115
 116     while ( i < argc )
 117         {
 118         if ( !strcmp( argv[i], "bfield" ) )
 119             {
 120             if ( argc <= i+1 )
 121                 {
 122                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing B-field", "Missing B-field specifier." );
 123                 return ENOTSUP;
 124                 }
 125             fBField = strtod( argv[i+1], &cpErr );
 126             if ( *cpErr )
 127                 {
 128                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] );
 129                 return EINVAL;
 130                 }
 131             i += 2;
 132             continue;
 133             }
 134
 135         Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
 136         return EINVAL;
 137         }
 138 --------------------------------------------------------------------------------- */
 139
 140     return 0;
 141     }
 142
 143 int AliHLTTPCCATrackerComponent::DoDeinit()
 144     {
 145     if ( fTracker )
 146         delete fTracker;
 147     fTracker = NULL;
 148     if ( fVertex )
 149         delete fVertex;
 150     fVertex = NULL;
 151     return 0;
 152     }
 153
 154 int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
 155                                               AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
 156                                               AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
 157     {
 158     Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "DoEvent", "DoEvent()" );
 159     if ( evtData.fBlockCnt<=0 )
 160       {
 161         Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "no blocks in event" );
 162         return 0;
 163       }
 164
 165     const AliHLTComponent_BlockData* iter = NULL;
 166     unsigned long ndx;
 167     AliHLTTPCClusterData* inPtrSP;
 168     AliHLTTPCVertexData* inPtrV = NULL;
 169     const AliHLTComponent_BlockData* vertexIter=NULL;
 170     AliHLTTPCTrackletData* outPtr;
 171     AliHLTUInt8_t* outBPtr;
 172
 173     AliHLTUInt32_t vSize = 0;
 174     UInt_t offset=0, mysize, tSize = 0;
 175     outBPtr = outputPtr;
 176
 177     outPtr = (AliHLTTPCTrackletData*)(outBPtr);
 178     fTracker->SetOutPtr( outPtr->fTracklets );
 179
 180     // ------------------------------------------
 181
 182     Int_t slice=-1, patch=-1, row[2];
 183     Int_t minPatch=INT_MAX, maxPatch = 0;
 184     offset = 0;
 185     std::vector<Int_t> slices;
 186     std::vector<Int_t>::iterator slIter, slEnd;
 187     std::vector<unsigned> sliceCnts;
 188     std::vector<unsigned>::iterator slCntIter;
 189     Int_t vertexSlice=-1;
 190
 191     // Find min/max rows used in total and find and read out vertex if it is present
 192     // also determine correct slice number, if multiple slice numbers are present in event
 193     // (which should not happen in the first place) we use the one that occurs the most times
 194     row[0] = 0;
 195     row[1] = 0;
 196     bool found;
 197
 198     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 199         {
 200         iter = blocks+ndx;
 201
 202
 203         slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 204         found = false;
 205         slIter = slices.begin();
 206         slEnd = slices.end();
 207         slCntIter = sliceCnts.begin();
 208         while ( slIter != slEnd )
 209             {
 210             if ( *slIter == slice )
 211                 {
 212                 found = true;
 213                 break;
 214                 }
 215             slIter++;
 216             slCntIter++;
 217             }
 218         if ( !found )
 219             {
 220             slices.insert( slices.end(), slice );
 221             sliceCnts.insert( sliceCnts.end(), 1 );
 222             }
 223         else
 224             *slCntIter++;
 225
 226         if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
 227             {
 228             inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
 229             vertexIter = iter;
 230             vSize = iter->fSize;
 231             fVertex->Read( inPtrV );
 232             vertexSlice = slice;
 233             }
 234         if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
 235             {
 236             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 237             if ( minPatch>patch )
 238                 {
 239                 minPatch = patch;
 240                 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
 241                 }
 242             if ( maxPatch<patch )
 243                 {
 244                 maxPatch = patch;
 245                 row[1] = AliHLTTPCTransform::GetLastRow( patch );
 246                 }
 247             }
 248         }
 249
 250     // Determine slice number to really use.
 251     if ( slices.size()>1 )
 252         {
 253         Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
 254                  "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
 255                  evtData.fEventID, evtData.fEventID );
 256         unsigned maxCntSlice=0;
 257         slIter = slices.begin();
 258         slEnd = slices.end();
 259         slCntIter = sliceCnts.begin();
 260         while ( slIter != slEnd )
 261             {
 262             Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
 263                      "Slice %lu found %lu times.", *slIter, *slCntIter );
 264             if ( maxCntSlice<*slCntIter )
 265                 {
 266                 maxCntSlice = *slCntIter;
 267                 slice = *slIter;
 268                 }
 269             slIter++;
 270             slCntIter++;
 271             }
 272         Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
 273                  "Using slice %lu.", slice );
 274         }
 275     else if ( slices.size()>0 )
 276       {
 277         slice = *(slices.begin());
 278       }
 279     else
 280       {
 281         slice = -1;
 282       }
 283
 284     if ( vertexSlice != slice )
 285         {
 286         // multiple vertex blocks in event and we used the wrong one...
 287         found = false;
 288         for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 289             {
 290             iter = blocks+ndx;
 291             if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
 292                 {
 293                 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
 294                 vertexIter = iter;
 295                 vSize = iter->fSize;
 296                 fVertex->Read( inPtrV );
 297                 break;
 298                 }
 299             }
 300         }
 301
 302     //    fTracker->InitSector( slice, row, fEta );
 303     //    fTracker->SetVertex(fVertex);
 304
 305     mysize = 0;
 306     // read in all hits
 307     std::vector<unsigned long> patchIndices;
 308     std::vector<unsigned long>::iterator pIter, pEnd;
 309     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 310         {
 311         iter = blocks+ndx;
 312
 313         if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
 314             {
 315             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 316             pIter = patchIndices.begin();
 317             pEnd = patchIndices.end();
 318             while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
 319                 pIter++;
 320             patchIndices.insert( pIter, ndx );
 321             }
 322         }
 323
 324     fTracker->CAInitialize();
 325
 326     pIter = patchIndices.begin();
 327     pEnd = patchIndices.end();
 328     while ( pIter!=pEnd )
 329         {
 330         ndx = *pIter;
 331         iter = blocks+ndx;
 332
 333         patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 334         inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
 335
 336         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits",
 337                  "Reading hits for slice %d - patch %d", slice, patch );
 338
 339         fTracker->CAReadPatchHits( patch, inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
 340         fTracker->CAFindPatchTracks( patch );
 341
 342         pIter++;
 343         }
 344
 345     fTracker->CAFindSliceTracks();
 346
 347     //#ifdef XXX
 348     char symbol;
 349     if (ask){
 350       do{
 351         std::cin.get(symbol);
 352         if (symbol == 'r')
 353           ask = false;
 354       } while (symbol != '\n');
 355     }
 356     //#endif //XXX
 357
 358
 359     UInt_t ntracks0=0;
 360
 361     mysize = fTracker->GetOutputSize();
 362     ntracks0 = fTracker->GetOutputNTracks();
 363     outPtr->fTrackletCnt = fTracker->GetOutputNTracks();
 364
 365     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
 366              "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.",
 367              ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
 368
 369     tSize += mysize+sizeof(AliHLTTPCTrackletData);
 370     outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
 371
 372     AliHLTComponent_BlockData bd;
 373     FillBlockData( bd );
 374     bd.fOffset = offset;
 375     bd.fSize = tSize;
 376     bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
 377     outputBlocks.push_back( bd );
 378
 379 #ifdef FORWARD_VERTEX_BLOCK
 380     if ( vertexIter )
 381         {
 382         // Copy the descriptor block for the vertex information.
 383         bd = *vertexIter;
 384         outputBlocks.push_back( bd );
 385         }
 386 #endif // FORWARD_VERTEX_BLOCK
 387
 388     size = tSize;
 389
 390     fTracker->CAWriteHistos();
 391
 392     return 0;
 393     }
 394
 395