HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx

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