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     fReaderPacked = NULL;
  57     fReaderUnpacked = NULL;
  58     fClusterDeconv = true;
  59     fXYClusterError = -1;
  60     fZClusterError = -1;
  61     }
  62
  63 AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
  64     {
  65     }
  66
  67 // Public functions to implement AliHLTComponent's interface.
  68 // These functions are required for the registration process
  69
  70 const char* AliHLTTPCClusterFinderComponent::GetComponentID()
  71     {
  72       if (fPackedSwitch) return "TPCClusterFinderPacked";
  73       else return "TPCClusterFinderUnpacked";
  74     }
  75
  76 void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
  77     {
  78     list.clear();
  79     if (fPackedSwitch) list.push_back( AliHLTTPCDefinitions::gkDDLPackedRawDataType );
  80     else list.push_back( AliHLTTPCDefinitions::gkUnpackedRawDataType );
  81
  82     }
  83
  84 AliHLTComponent_DataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
  85     {
  86     return AliHLTTPCDefinitions::gkClustersDataType;
  87     }
  88
  89 void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  90     {
  91     // XXX TODO: Find more realistic values.
  92     constBase = 0;
  93     if (fPackedSwitch)  inputMultiplier = (6 * 0.4);
  94     else  inputMultiplier = 0.4;
  95     }
  96
  97 AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
  98     {
  99     return new AliHLTTPCClusterFinderComponent(fPackedSwitch);
 100     }
 101
 102 int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
 103     {
 104     if ( fClusterFinder )
 105         return EINPROGRESS;
 106
 107     fClusterFinder = new AliHLTTPCClusterFinder();
 108
 109     if (fPackedSwitch) {
 110       fReaderPacked = new AliHLTTPCDigitReaderPacked();
 111       fClusterFinder->SetReader(fReaderPacked);
 112     }
 113     else {
 114       fReaderUnpacked = new AliHLTTPCDigitReaderUnpacked();
 115       fClusterFinder->SetReader(fReaderUnpacked);
 116     }
 117
 118     // Variables to setup the Clusterfinder
 119     fClusterDeconv = true;
 120     fXYClusterError = -1;
 121     fZClusterError = -1;
 122
 123     int i = 0;
 124     while ( i < argc )
 125         {
 126           if ( !strcmp( argv[i], "pp-run" ) ){
 127             fClusterDeconv = false;
 128             i++;
 129             continue;
 130           }
 131
 132         Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
 133         return EINVAL;
 134         }
 135
 136
 137     fClusterFinder->SetDeconv( fClusterDeconv );
 138     fClusterFinder->SetXYError( fXYClusterError );
 139     fClusterFinder->SetZError( fZClusterError );
 140     if ( (fXYClusterError>0) && (fZClusterError>0) )
 141       fClusterFinder->SetCalcErr( false );
 142
 143     return 0;
 144     }
 145
 146 int AliHLTTPCClusterFinderComponent::DoDeinit()
 147     {
 148
 149     if ( fClusterFinder )
 150         delete fClusterFinder;
 151     fClusterFinder = NULL;
 152
 153     if ( fReaderUnpacked )
 154         delete fReaderUnpacked;
 155     fReaderUnpacked = NULL;
 156
 157     if ( fReaderPacked )
 158         delete fReaderPacked;
 159     fReaderPacked = NULL;
 160
 161     return 0;
 162     }
 163
 164 int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponent_EventData& evtData,
 165                                               const AliHLTComponent_BlockData* blocks,
 166                                               AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
 167                                               AliHLTUInt32_t& size,
 168                                               vector<AliHLTComponent_BlockData>& outputBlocks )
 169     {
 170     //  == init iter (pointer to datablock)
 171     const AliHLTComponent_BlockData* iter = NULL;
 172     unsigned long ndx;
 173
 174     //  == OUTdatatype pointer
 175     AliHLTTPCClusterData* outPtr;
 176
 177     AliHLTUInt8_t* outBPtr;
 178     UInt_t offset, mysize, nSize, tSize = 0;
 179
 180     outBPtr = outputPtr;
 181     outPtr = (AliHLTTPCClusterData*)outBPtr;
 182
 183     Int_t slice, patch, row[2];
 184     unsigned long maxPoints, realPoints = 0;
 185
 186     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 187         {
 188         iter = blocks+ndx;
 189         mysize = 0;
 190         offset = tSize;
 191
 192
 193         if (fPackedSwitch) {
 194           char tmp1[14], tmp2[14];
 195           DataType2Text( iter->fDataType, tmp1 );
 196           DataType2Text( AliHLTTPCDefinitions::gkDDLPackedRawDataType, tmp2 );
 197           Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
 198                    "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 199                    evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
 200
 201           if ( iter->fDataType != AliHLTTPCDefinitions::gkDDLPackedRawDataType ) continue;
 202
 203         }
 204         else {
 205           char tmp1[14], tmp2[14];
 206           DataType2Text( iter->fDataType, tmp1 );
 207           DataType2Text( AliHLTTPCDefinitions::gkUnpackedRawDataType, tmp2 );
 208           Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
 209                    "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 210                    evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
 211
 212           if ( iter->fDataType != AliHLTTPCDefinitions::gkUnpackedRawDataType ) continue;
 213
 214         }
 215
 216         slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 217         patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 218         row[0] = AliHLTTPCTransform::GetFirstRow( patch );
 219         row[1] = AliHLTTPCTransform::GetLastRow( patch );
 220
 221         Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Input Spacepoints",
 222                  "Input: Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
 223                  realPoints, slice, patch, row[0], row[1] );
 224
 225         outPtr = (AliHLTTPCClusterData*)outBPtr;
 226
 227         maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
 228
 229         fClusterFinder->InitSlice( slice, patch, row[0], row[1], maxPoints );
 230         fClusterFinder->SetOutputArray( outPtr->fSpacePoints );
 231         fClusterFinder->Read(iter->fPtr, iter->fSize );
 232         fClusterFinder->ProcessDigits();
 233         realPoints = fClusterFinder->GetNumberOfClusters();
 234
 235         Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints",
 236                  "Number of spacepoints found: %lu.", realPoints );
 237
 238         outPtr->fSpacePointCnt = realPoints;
 239         nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
 240         mysize += nSize+sizeof(AliHLTTPCClusterData);
 241
 242         Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Input Spacepoints",
 243                  "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
 244                  realPoints, slice, patch, row[0], row[1] );
 245
 246
 247         AliHLTComponent_BlockData bd;
 248         FillBlockData( bd );
 249         bd.fOffset = offset;
 250         bd.fSize = mysize;
 251         bd.fSpecification = iter->fSpecification;
 252         //AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
 253         outputBlocks.push_back( bd );
 254
 255         tSize += mysize;
 256         outBPtr += mysize;
 257         outPtr = (AliHLTTPCClusterData*)outBPtr;
 258
 259         if ( tSize > size )
 260             {
 261             Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data",
 262                      "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
 263                      tSize, size );
 264             return EMSGSIZE;
 265             }
 266         }
 267
 268     size = tSize;
 269     return 0;
 270     }
 271
 272