HLT/CALO/AliHLTCaloClusterizerComponent.cxx

   1 // $Id: AliHLTCaloClusterizerComponent.cxx 36709 2009-11-12 16:57:55Z odjuvsla $
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors: Oystein Djuvsland <oysteind@ift.uib.no>                       *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 #include <iostream>
  18
  19 #include "AliHLTCaloClusterizerComponent.h"
  20 #include "AliHLTCaloClusterizer.h"
  21 #include "AliHLTCaloRecPointDataStruct.h"
  22 #include "AliHLTCaloRecPointHeaderStruct.h"
  23 #include "AliHLTCaloDigitDataStruct.h"
  24 #include "AliHLTCaloDigitContainerDataStruct.h"
  25 #include "AliHLTCaloDefinitions.h"
  26 #include "TString.h"
  27
  28 /** @file   AliHLTCaloClusterizerComponent.cxx
  29     @author Oystein Djuvsland
  30     @date
  31     @brief  A clusterizer component for PHOS HLT
  32 */
  33
  34 // see header file for class documentation
  35 // or
  36 // refer to README to build package
  37 // or
  38 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  39
  40
  41 AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det):
  42   AliHLTCaloProcessor(),
  43   AliHLTCaloConstantsHandler(det),
  44   fDigitsPointerArray(0),
  45   fClusterizerPtr(0),
  46   fDigitCount(0)
  47
  48 {
  49   //See headerfile for documentation
  50
  51   fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSRCU()*fCaloConstants->GetNZROWSRCU()];
  52
  53   fClusterizerPtr = new AliHLTCaloClusterizer(det);
  54
  55   fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
  56
  57 }
  58
  59 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
  60 {
  61   //See headerfile for documentation
  62
  63   if(fClusterizerPtr)
  64     {
  65       delete fClusterizerPtr;
  66       fClusterizerPtr = 0;
  67     }
  68 }
  69
  70
  71 int
  72 AliHLTCaloClusterizerComponent::Deinit()
  73 {
  74   //See headerfile for documentation
  75
  76   if (fClusterizerPtr)
  77     {
  78       delete fClusterizerPtr;
  79       fClusterizerPtr = 0;
  80     }
  81
  82   return 0;
  83 }
  84
  85 // void
  86 // AliHLTCaloClusterizerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  87 // {
  88 //   //See headerfile for documentation
  89 //   list.clear();
  90 //   list.push_back(AliHLTCaloDefinitions::fgkDigitDataType|kAliHLTDataOriginPHOS);
  91 // }
  92
  93 // AliHLTComponentDataType
  94 // AliHLTCaloClusterizerComponent::GetOutputDataType()
  95 // {
  96 //   //See headerfile for documentation
  97 //   return AliHLTCaloDefinitions::fgkRecPointDataType|kAliHLTDataOriginPHOS;
  98 // }
  99
 100 // void
 101 // AliHLTCaloClusterizerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
 102
 103 // {
 104 //   //See headerfile for documentation
 105 //   constBase = sizeof(AliHLTCaloRecPointHeaderStruct) + sizeof(AliHLTCaloRecPointDataStruct) + (sizeof(AliHLTCaloDigitDataStruct) << 7); //Reasonable estimate... ;
 106 //   inputMultiplier = 1.5;
 107 // }
 108
 109 int
 110 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 111                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
 112                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
 113 {
 114   //See headerfile for documentation
 115
 116   if(blocks == 0) return 0;
 117
 118   UInt_t offset           = 0;
 119   UInt_t mysize           = 0;
 120   Int_t nRecPoints        = 0;
 121   Int_t nDigits           = 0;
 122   Int_t digCount          = 0;
 123
 124   //UInt_t availableSize = size;
 125   AliHLTUInt8_t* outBPtr;
 126   outBPtr = outputPtr;
 127   const AliHLTComponentBlockData* iter = 0;
 128   unsigned long ndx;
 129
 130   UInt_t specification = 0;
 131
 132   AliHLTCaloDigitDataStruct *digitDataPtr = 0;
 133
 134   // Adding together all the digits, should be put in standalone method
 135   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 136     {
 137       iter = blocks+ndx;
 138       //            HLTError("Got block");
 139       if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|kAliHLTDataOriginPHOS))
 140         {
 141           // Get the digit header
 142
 143           // Update the number of digits
 144           nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);;
 145           //      HLTError("Got %d digits", nDigits);
 146
 147           specification = specification|iter->fSpecification;
 148
 149           digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
 150           for (Int_t i = 0; i < nDigits; i++)
 151             {
 152               fDigitsPointerArray[digCount] = digitDataPtr;
 153               digCount++;
 154               digitDataPtr++;
 155             }
 156
 157         }
 158     }
 159
 160   if(digCount > 0)
 161     {
 162
 163       // Sort the digit pointers
 164       qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
 165
 166       // Copy the digits to the output
 167       for(Int_t n = 0; n < digCount; n++)
 168         {
 169           memcpy(outBPtr, fDigitsPointerArray[n], sizeof(AliHLTCaloDigitDataStruct));
 170           outBPtr = outBPtr + sizeof(AliHLTCaloDigitDataStruct);
 171         }
 172
 173       mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
 174
 175       AliHLTComponentBlockData bdDigits;
 176       FillBlockData( bdDigits );
 177       bdDigits.fOffset = offset;
 178       bdDigits.fSize = mysize;
 179       bdDigits.fDataType = iter->fDataType;
 180       bdDigits.fSpecification = specification;
 181       outputBlocks.push_back( bdDigits );
 182
 183
 184       AliHLTCaloRecPointHeaderStruct* recPointHeaderPtr = reinterpret_cast<AliHLTCaloRecPointHeaderStruct*>(outBPtr);
 185
 186       fClusterizerPtr->SetRecPointDataPtr(reinterpret_cast<AliHLTCaloRecPointDataStruct*>(outBPtr+sizeof(AliHLTCaloRecPointHeaderStruct)));
 187
 188       //  HLTError("Total number of digits: %d", digCount );
 189
 190       printf("Total number of digits: %d\n", digCount);
 191
 192       nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount, size, mysize);
 193
 194       if(nRecPoints == -1)
 195         {
 196           //      HLTError("Running out of buffer, exiting for safety.");
 197           return -ENOBUFS;
 198         }
 199
 200       recPointHeaderPtr->fNRecPoints = nRecPoints;
 201       mysize += sizeof(AliHLTCaloRecPointHeaderStruct);
 202
 203       //  HLTError("Number of clusters: %d", nRecPoints);
 204
 205       AliHLTComponentBlockData bd;
 206       FillBlockData( bd );
 207       bd.fOffset = offset;
 208       bd.fSize = mysize;
 209       bd.fDataType = AliHLTCaloDefinitions::fgkClusterDataType;
 210       bd.fSpecification = specification;
 211       outputBlocks.push_back( bd );
 212     }
 213
 214   size = mysize;
 215
 216   return 0;
 217 }
 218
 219 int
 220 AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
 221 {
 222   // see header file for class documentation
 223
 224   const char* path="HLT/ConfigPHOS/ClusterizerComponent";
 225
 226   if (cdbEntry) path = cdbEntry;
 227
 228   return ConfigureFromCDBTObjString(cdbEntry);
 229 }
 230
 231 int
 232 AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
 233 {
 234   //See header file for documentation
 235
 236   if(argc <= 0) return 0;
 237
 238   int i=0;
 239
 240   TString argument=argv[i];
 241
 242   if (argument.CompareTo("-digitthreshold") == 0)
 243     {
 244       if (++i >= argc) return -EPROTO;
 245       argument = argv[i];
 246       fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
 247       return 1;
 248     }
 249
 250   if (argument.CompareTo("-recpointthreshold") == 0)
 251     {
 252       if (++i >= argc) return -EPROTO;
 253       argument = argv[i];
 254       fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
 255       return 1;
 256     }
 257   return 0;
 258 }
 259
 260 int
 261 AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
 262 {
 263   //See headerfile for documentation
 264
 265
 266   //
 267
 268   //  const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
 269
 270   //  ConfigureFromCDBTObjString(path);
 271
 272   for (int i = 0; i < argc; i++)
 273     {
 274       ScanConfigurationArgument(i, argv);
 275     }
 276
 277   return 0;
 278 }
 279
 280 Int_t
 281 AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
 282 {
 283   // See header file for documentation
 284   return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
 285 }