HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * This file is property of and copyright by the ALICE HLT Project        *
   5  * ALICE Experiment at CERN, All rights reserved.                         *
   6  *                                                                        *
   7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   8  *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
   9  *                  for The ALICE HLT Project.                            *
  10  *                                                                        *
  11  * Permission to use, copy, modify and distribute this software and its   *
  12  * documentation strictly for non-commercial purposes is hereby granted   *
  13  * without fee, provided that the above copyright notice appears in all   *
  14  * copies and that both the copyright notice and this permission notice   *
  15  * appear in the supporting documentation. The authors make no claims     *
  16  * about the suitability of this software for any purpose. It is          *
  17  * provided "as is" without express or implied warranty.                  *
  18  **************************************************************************/
  19
  20 /** @file   AliHLTTPCGlobalMergerComponent.cxx
  21     @author Timm Steinbeck, Matthias Richter
  22     @date
  23     @brief  HLT TPC global merger component.
  24 */
  25
  26 // see header file for class documentation                                   //
  27 // or                                                                        //
  28 // refer to README to build package                                          //
  29 // or                                                                        //
  30 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt                          //
  31
  32 #if __GNUC__>= 3
  33 using namespace std;
  34 #endif
  35
  36 #include "AliHLTTPCGlobalMergerComponent.h"
  37 //#include "AliHLTTPCTransform.h"
  38 #include "AliHLTTPCGlobalMerger.h"
  39 #include "AliHLTTPCVertex.h"
  40 #include "AliHLTTPCVertexData.h"
  41 #include "AliHLTTPCTrackSegmentData.h"
  42 #include "AliHLTTPCTrackArray.h"
  43 #include "AliHLTTPCTrackletDataFormat.h"
  44 //#include "AliHLTTPCSpacePointData.h"
  45 //#include "AliHLTTPCClusterDataFormat.h"
  46 #include "AliHLTTPCDefinitions.h"
  47 #include <cstdlib>
  48 #include <cerrno>
  49
  50 /** ROOT macro for the implementation of ROOT specific class methods */
  51 ClassImp(AliHLTTPCGlobalMergerComponent);
  52
  53 AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent()
  54   :
  55   fGlobalMerger(NULL),
  56   fVertex(NULL)
  57 {
  58   // see header file for class documentation
  59   // or
  60   // refer to README to build package
  61   // or
  62   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  63 }
  64
  65 AliHLTTPCGlobalMergerComponent::~AliHLTTPCGlobalMergerComponent()
  66 {
  67   // see header file for class documentation
  68 }
  69
  70 // Public functions to implement AliHLTComponent's interface.
  71 // These functions are required for the registration process
  72
  73 const char* AliHLTTPCGlobalMergerComponent::GetComponentID()
  74 {
  75   // see header file for class documentation
  76   return "TPCGlobalMerger";
  77 }
  78
  79 void AliHLTTPCGlobalMergerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
  80 {
  81   // see header file for class documentation
  82   list.clear();
  83   list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
  84   list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
  85 }
  86
  87 AliHLTComponentDataType AliHLTTPCGlobalMergerComponent::GetOutputDataType()
  88 {
  89   // see header file for class documentation
  90   return AliHLTTPCDefinitions::fgkTracksDataType;
  91 }
  92
  93 void AliHLTTPCGlobalMergerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  94 {
  95   // see header file for class documentation
  96   // XXX TODO: Find more realistic values.
  97   constBase = 0;
  98   inputMultiplier = 1.0;
  99 }
 100
 101 AliHLTComponent* AliHLTTPCGlobalMergerComponent::Spawn()
 102 {
 103   // see header file for class documentation
 104   return new AliHLTTPCGlobalMergerComponent;
 105 }
 106
 107 void AliHLTTPCGlobalMergerComponent::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
 108 {
 109   // see header file for class documentation
 110   fGlobalMerger->SetParameter( maxy, maxz, maxkappa, maxpsi, maxtgl );
 111 }
 112
 113 int AliHLTTPCGlobalMergerComponent::DoInit( int /*argc*/, const char** /*argv*/ )
 114 {
 115   // see header file for class documentation
 116   if ( fGlobalMerger || fVertex )
 117     return EINPROGRESS;
 118   fGlobalMerger = new AliHLTTPCGlobalMerger();
 119   fVertex = new AliHLTTPCVertex();
 120   SetMergerParameters();
 121   return 0;
 122 }
 123
 124 int AliHLTTPCGlobalMergerComponent::DoDeinit()
 125 {
 126   // see header file for class documentation
 127   if ( fGlobalMerger )
 128     delete fGlobalMerger;
 129   fGlobalMerger = NULL;
 130   if ( fVertex )
 131     delete fVertex;
 132   fVertex = NULL;
 133   return 0;
 134 }
 135
 136 int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 137                                               AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
 138                                               AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks )
 139 {
 140   // see header file for class documentation
 141   const AliHLTComponentBlockData* iter = NULL;
 142   const AliHLTComponentBlockData* lastVertexBlock = NULL;
 143   unsigned long ndx;
 144
 145   std::vector<SliceData> slices;
 146   std::vector<SliceData>::iterator sdIter, sdEnd;
 147   int minSlice = INT_MAX, maxSlice = 0;
 148   bool found;
 149   AliHLTTPCTrackletData* inPtr;
 150   AliHLTTPCTrackletData* outPtr;
 151   UInt_t tSize = 0;
 152   Int_t slice=0;
 153
 154   // Create sorted (by slice number) list of data (tracks and vertex) for each slice present.
 155   // also note the min and max slice numbers
 156   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 157     {
 158       iter = blocks+ndx;
 159       slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 160       found=false;
 161       sdIter = slices.begin();
 162       sdEnd = slices.end();
 163       while ( sdIter != sdEnd )
 164         {
 165           if ( sdIter->fSlice > slice || sdIter->fSlice == slice )
 166             break;
 167           sdIter++;
 168         }
 169       if ( sdIter==sdEnd || sdIter->fSlice>slice )
 170         {
 171           if ( sdIter == sdEnd )
 172             maxSlice = slice;
 173           if ( sdIter==slices.begin() )
 174             minSlice = slice;
 175           SliceData sd;
 176           sd.fSlice = slice;
 177           sd.fVertexBlock = NULL;
 178           sd.fVertexBlockIndex = 0;
 179           sd.fTrackletBlock = NULL;
 180           sd.fTrackletBlockIndex = 0;
 181           sdIter = slices.insert( sdIter, sd );
 182         }
 183       if ( sdIter->fSlice == slice )
 184         {
 185           if ( iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType )
 186             {
 187               if ( !sdIter->fTrackletBlock )
 188                 {
 189                   sdIter->fTrackletBlock = iter;
 190                   sdIter->fTrackletBlockIndex = ndx;
 191                 }
 192               else
 193                 {
 194                   Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate track data block",
 195                            "Duplicate track data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
 196                            slice, evtData.fEventID, evtData.fEventID, sdIter->fTrackletBlockIndex, ndx );
 197                 }
 198             }
 199           if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
 200             {
 201               lastVertexBlock = iter;
 202               if ( !sdIter->fVertexBlock )
 203                 {
 204                   sdIter->fVertexBlock = iter;
 205                   sdIter->fVertexBlockIndex = ndx;
 206                 }
 207               else
 208                 {
 209                   Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate vertex data block",
 210                            "Duplicate vertex data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
 211                            slice, evtData.fEventID, evtData.fEventID, sdIter->fVertexBlockIndex, ndx );
 212                 }
 213             }
 214         }
 215     }
 216
 217   //fGlobalMerger->Setup( minSlice, maxSlice );
 218   fGlobalMerger->Setup( 0, 35 );
 219
 220   if ( !lastVertexBlock )
 221     {
 222       Logging( kHLTLogInfo, "HLT::GlobalMerger::DoEvent", "No vertex data block",
 223                "No vertex data block found  for event  0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
 224       fVertex->SetZero();
 225     }
 226   else
 227     fVertex->Read( (AliHLTTPCVertexData*)( lastVertexBlock->fPtr ) );
 228
 229   // Add all tracks into the merger
 230   sdIter = slices.begin();
 231   sdEnd = slices.end();
 232   int lastSlice = -1;
 233   while ( sdIter != sdEnd )
 234     {
 235       if ( sdIter->fVertexBlock )
 236         {
 237           fVertex->Read( (AliHLTTPCVertexData*)( sdIter->fVertexBlock->fPtr ) );
 238           fGlobalMerger->SetVertex( fVertex );
 239         }
 240       for ( int slNr=lastSlice+1; slNr<=sdIter->fSlice; slNr++ )
 241         fGlobalMerger->InitSlice( slNr );
 242       if ( sdIter->fTrackletBlock )
 243         {
 244           inPtr = (AliHLTTPCTrackletData*)( sdIter->fTrackletBlock->fPtr );
 245           if ( !inPtr )
 246             {
 247               Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "No track data block",
 248                        "No track data block found  for event  0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
 249             }
 250           else
 251             {
 252               //fGlobalMerger->InitSlice( sdIter->fSlice );
 253               fGlobalMerger->FillTracks( inPtr->fTrackletCnt, inPtr->fTracklets );
 254             }
 255         }
 256       lastSlice = sdIter->fSlice;
 257       sdIter++;
 258     }
 259   for ( int slNr=lastSlice+1; slNr<=35; slNr++ )
 260     fGlobalMerger->InitSlice( slNr );
 261
 262
 263   // Now we can really merge
 264   fGlobalMerger->Merge();
 265   fGlobalMerger->AddAllTracks();
 266
 267   UInt_t ntracks0=0;
 268   outPtr = (AliHLTTPCTrackletData*)(outputPtr);
 269
 270   tSize = fGlobalMerger->GetOutTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
 271   outPtr->fTrackletCnt = ntracks0;
 272
 273   tSize += sizeof(AliHLTTPCTrackletData);
 274
 275   AliHLTComponentBlockData bd;
 276   FillBlockData( bd );
 277   bd.fOffset = 0;
 278   bd.fSize = tSize;
 279   bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, 0, 5 );
 280   outputBlocks.push_back( bd );
 281
 282   size = tSize;
 283   return 0;
 284 }
 285
 286