HLT/TPCLib/AliHLTTPCClusterFinderComponent.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  *          Jochen Thaeder <thaeder@kip.uni-heidelberg.de>                *
   9  *          for The ALICE Off-line 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 ///////////////////////////////////////////////////////////////////////////////
  21 //                                                                           //
  22 // a TPC cluster finder processing component for the HLT                     //
  23 // useable for packed data or unpacked data                                  //
  24 //                                                                           //
  25 ///////////////////////////////////////////////////////////////////////////////
  26
  27
  28 #if __GNUC__== 3
  29 using namespace std;
  30 #endif
  31
  32 #include "AliHLTTPCClusterFinderComponent.h"
  33 #include "AliHLTTPCDigitReaderPacked.h"
  34 #include "AliHLTTPCDigitReaderUnpacked.h"
  35 #include "AliHLTTPCClusterFinder.h"
  36 #include "AliHLTTPCSpacePointData.h"
  37 #include "AliHLTTPCRawDataFormat.h"
  38 #include "AliHLTTPCClusterDataFormat.h"
  39 #include "AliHLTTPCTransform.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 AliHLTTPCClusterFinderComponent gAliHLTTPCClusterFinderComponentPacked(true);
  45 AliHLTTPCClusterFinderComponent gAliHLTTPCClusterFinderComponentUnpacked(false);
  46
  47 ClassImp(AliHLTTPCClusterFinderComponent)
  48
  49 AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(bool packed)
  50   :
  51   // use fPackedSwitch = true for packed inputtype "gkDDLPackedRawDataType"
  52   // use fPackedSwitch = false for unpacked inputtype "gkUnpackedRawDataType"
  53   fPackedSwitch(packed),
  54
  55   fClusterFinder(NULL),
  56   fReader(NULL),
  57   fClusterDeconv(true),
  58   fXYClusterError(-1),
  59   fZClusterError(-1)
  60 {
  61 }
  62
  63 AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(const AliHLTTPCClusterFinderComponent&)
  64   :
  65   fPackedSwitch(0),
  66   fClusterFinder(NULL),
  67   fReader(NULL),
  68   fClusterDeconv(true),
  69   fXYClusterError(-1),
  70   fZClusterError(-1)
  71 {
  72   HLTFatal("copy constructor untested");
  73 }
  74
  75 AliHLTTPCClusterFinderComponent& AliHLTTPCClusterFinderComponent::operator=(const AliHLTTPCClusterFinderComponent&)
  76 {
  77   HLTFatal("assignment operator untested");
  78   return *this;
  79 }
  80
  81 AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
  82     {
  83     }
  84
  85 // Public functions to implement AliHLTComponent's interface.
  86 // These functions are required for the registration process
  87
  88 const char* AliHLTTPCClusterFinderComponent::GetComponentID()
  89     {
  90       if (fPackedSwitch) return "TPCClusterFinderPacked";
  91       else return "TPCClusterFinderUnpacked";
  92     }
  93
  94 void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
  95     {
  96     list.clear();
  97     if (fPackedSwitch) list.push_back( AliHLTTPCDefinitions::gkDDLPackedRawDataType );
  98     else list.push_back( AliHLTTPCDefinitions::gkUnpackedRawDataType );
  99
 100     }
 101
 102 AliHLTComponent_DataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
 103     {
 104     return AliHLTTPCDefinitions::gkClustersDataType;
 105     }
 106
 107 void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 108     {
 109     // XXX TODO: Find more realistic values.
 110     constBase = 0;
 111     if (fPackedSwitch)  inputMultiplier = (6 * 0.4);
 112     else  inputMultiplier = 0.4;
 113     }
 114
 115 AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
 116     {
 117     return new AliHLTTPCClusterFinderComponent(fPackedSwitch);
 118     }
 119
 120 int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
 121     {
 122     if ( fClusterFinder )
 123         return EINPROGRESS;
 124
 125     fClusterFinder = new AliHLTTPCClusterFinder();
 126
 127     if (fPackedSwitch) {
 128 #if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
 129       fReader = new AliHLTTPCDigitReaderPacked();
 130       fClusterFinder->SetReader(fReader);
 131 #else // ! defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
 132       HLTFatal("DigitReaderPacked not available - check your build");
 133       return -ENODEV;
 134 #endif //  defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
 135     }
 136     else {
 137       fReader = new AliHLTTPCDigitReaderUnpacked();
 138       fClusterFinder->SetReader(fReader);
 139     }
 140
 141     // Variables to setup the Clusterfinder
 142     fClusterDeconv = true;
 143     fXYClusterError = -1;
 144     fZClusterError = -1;
 145
 146     int i = 0;
 147     while ( i < argc )
 148         {
 149           if ( !strcmp( argv[i], "pp-run" ) ){
 150             fClusterDeconv = false;
 151             i++;
 152             continue;
 153           }
 154
 155         Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
 156         return EINVAL;
 157         }
 158
 159
 160     fClusterFinder->SetDeconv( fClusterDeconv );
 161     fClusterFinder->SetXYError( fXYClusterError );
 162     fClusterFinder->SetZError( fZClusterError );
 163     if ( (fXYClusterError>0) && (fZClusterError>0) )
 164       fClusterFinder->SetCalcErr( false );
 165
 166     return 0;
 167     }
 168
 169 int AliHLTTPCClusterFinderComponent::DoDeinit()
 170     {
 171
 172     if ( fClusterFinder )
 173         delete fClusterFinder;
 174     fClusterFinder = NULL;
 175
 176     if ( fReader )
 177         delete fReader;
 178     fReader = NULL;
 179
 180     return 0;
 181     }
 182
 183 int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponent_EventData& evtData,
 184                                               const AliHLTComponent_BlockData* blocks,
 185                                               AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
 186                                               AliHLTUInt32_t& size,
 187                                               vector<AliHLTComponent_BlockData>& outputBlocks )
 188     {
 189     //  == init iter (pointer to datablock)
 190     const AliHLTComponent_BlockData* iter = NULL;
 191     unsigned long ndx;
 192
 193     //  == OUTdatatype pointer
 194     AliHLTTPCClusterData* outPtr;
 195
 196     AliHLTUInt8_t* outBPtr;
 197     UInt_t offset, mysize, nSize, tSize = 0;
 198
 199     outBPtr = outputPtr;
 200     outPtr = (AliHLTTPCClusterData*)outBPtr;
 201
 202     Int_t slice, patch, row[2];
 203     unsigned long maxPoints, realPoints = 0;
 204
 205     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 206         {
 207         iter = blocks+ndx;
 208         mysize = 0;
 209         offset = tSize;
 210
 211
 212         if (fPackedSwitch) {
 213           char tmp1[14], tmp2[14];
 214           DataType2Text( iter->fDataType, tmp1 );
 215           DataType2Text( AliHLTTPCDefinitions::gkDDLPackedRawDataType, tmp2 );
 216           Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
 217                    "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 218                    evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
 219
 220           if ( iter->fDataType != AliHLTTPCDefinitions::gkDDLPackedRawDataType ) continue;
 221
 222         }
 223         else {
 224           char tmp1[14], tmp2[14];
 225           DataType2Text( iter->fDataType, tmp1 );
 226           DataType2Text( AliHLTTPCDefinitions::gkUnpackedRawDataType, tmp2 );
 227           Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
 228                    "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 229                    evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
 230
 231           if ( iter->fDataType != AliHLTTPCDefinitions::gkUnpackedRawDataType ) continue;
 232
 233         }
 234
 235         slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 236         patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 237         row[0] = AliHLTTPCTransform::GetFirstRow( patch );
 238         row[1] = AliHLTTPCTransform::GetLastRow( patch );
 239
 240         Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Input Spacepoints",
 241                  "Input: Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
 242                  realPoints, slice, patch, row[0], row[1] );
 243
 244         outPtr = (AliHLTTPCClusterData*)outBPtr;
 245
 246         maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
 247
 248         fClusterFinder->InitSlice( slice, patch, row[0], row[1], maxPoints );
 249         fClusterFinder->SetOutputArray( outPtr->fSpacePoints );
 250         fClusterFinder->Read(iter->fPtr, iter->fSize );
 251         fClusterFinder->ProcessDigits();
 252         realPoints = fClusterFinder->GetNumberOfClusters();
 253
 254         Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints",
 255                  "Number of spacepoints found: %lu.", realPoints );
 256
 257         outPtr->fSpacePointCnt = realPoints;
 258         nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
 259         mysize += nSize+sizeof(AliHLTTPCClusterData);
 260
 261         Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Input Spacepoints",
 262                  "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
 263                  realPoints, slice, patch, row[0], row[1] );
 264
 265
 266         AliHLTComponent_BlockData bd;
 267         FillBlockData( bd );
 268         bd.fOffset = offset;
 269         bd.fSize = mysize;
 270         bd.fSpecification = iter->fSpecification;
 271         //AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
 272         outputBlocks.push_back( bd );
 273
 274         tSize += mysize;
 275         outBPtr += mysize;
 276         outPtr = (AliHLTTPCClusterData*)outBPtr;
 277
 278         if ( tSize > size )
 279             {
 280             Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data",
 281                      "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
 282                      tSize, size );
 283             return EMSGSIZE;
 284             }
 285         }
 286
 287     size = tSize;
 288     return 0;
 289     }
 290
 291