HLT/PHOS/AliHLTPHOSClusterizerComponent.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Authors: Ã\98ystein Djuvsland <oysteind@ift.uib.no>                       *
   5  *                                                                        *
   6  * Permission to use, copy, modify and distribute this software and its   *
   7  * documentation strictly for non-commercial purposes is hereby granted   *
   8  * without fee, provided that the above copyright notice appears in all   *
   9  * copies and that both the copyright notice and this permission notice   *
  10  * appear in the supporting documentation. The authors make no claims     *
  11  * about the suitability of this software for any purpose. It is          *
  12  * provided "as is" without express or implied warranty.                  *
  13  **************************************************************************/
  14
  15
  16
  17
  18 #include "AliHLTPHOSClusterizerComponent.h"
  19 #include "AliHLTPHOSClusterizer.h"
  20 //#include "AliHLTPHOSPhysicsDefinitions.h"
  21 //#include "AliHLTPHOSDefinitions.h"
  22 #include "AliHLTPHOSRecPointDataStruct.h"
  23 #include "AliHLTPHOSClusterDataStruct.h"
  24 #include "AliHLTPHOSRecPointListDataStruct.h"
  25
  26 using namespace std;
  27
  28
  29 const AliHLTComponentDataType AliHLTPHOSClusterizerComponent::fgkInputDataTypes[]={kAliHLTVoidDataType,{0,"",""}};
  30
  31 AliHLTPHOSClusterizerComponent gAliHLTPHOSClusterizerComponent;
  32
  33 //AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent(): AliHLTPHOSBase(), AliHLTProcessor(), fClusterizerPtr(0), fOutPtr(0),
  34 //                                                               fRecPointStructArrayPtr(0), fRecPointListPtr(0)
  35 AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent(): AliHLTPHOSProcessor(), fClusterizerPtr(0), fOutPtr(0),
  36                                                                   fRecPointStructArrayPtr(0), fRecPointListPtr(0)
  37 {
  38   //Constructor
  39 }
  40
  41 AliHLTPHOSClusterizerComponent::~AliHLTPHOSClusterizerComponent()
  42 {
  43   //Destructor
  44
  45   if(fClusterizerPtr)
  46     {
  47       delete fClusterizerPtr;
  48       fClusterizerPtr = 0;
  49     }
  50
  51   if(fRecPointListPtr)
  52     {
  53       delete fRecPointListPtr;
  54       fRecPointListPtr = 0;
  55     }
  56
  57   if(fRecPointStructArrayPtr)
  58     {
  59       for(int i = 0; i < 1000; i++)
  60         {
  61           fRecPointStructArrayPtr[i].Del();
  62         }
  63       delete fRecPointStructArrayPtr;
  64       fRecPointStructArrayPtr = 0;
  65     }
  66
  67 }
  68
  69 /*
  70 int
  71 AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent::Deinit()
  72 {
  73   ////////// PTH WARNING you should Define a class AliHLTPHOSModuleProcessor
  74 }
  75 */
  76
  77 // PTH AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent(const AliHLTPHOSClusterizerComponent &):AliHLTProcessor(),
  78 //                                                                                                     fClusterizerPtr(0),
  79 //                                                                                                     fOutPtr(0),
  80 //                                                                                                     fRecPointStructArrayPtr(0),
  81 //                                                                                                     fRecPointListPtr(0)
  82 //{
  83   //Copy constructor, not implemented
  84 //}
  85
  86 int
  87 AliHLTPHOSClusterizerComponent::Deinit()
  88 {
  89   //Deinitialization
  90
  91   if(fClusterizerPtr)
  92     {
  93       delete fClusterizerPtr;
  94       fClusterizerPtr = 0;
  95     }
  96
  97   if(fRecPointListPtr)
  98     {
  99       delete fRecPointListPtr;
 100       fRecPointListPtr = 0;
 101     }
 102
 103   for(int i = 0; i < 1000; i++)
 104     {
 105       fRecPointStructArrayPtr[i].Del();
 106     }
 107
 108   if(fRecPointStructArrayPtr)
 109     {
 110       for(int i = 0; i < 1000; i++)
 111         {
 112           fRecPointStructArrayPtr[i].Del();
 113         }
 114       delete fRecPointStructArrayPtr;
 115       fRecPointStructArrayPtr = 0;
 116     }
 117
 118
 119
 120
 121
 122   return 0;
 123 }
 124
 125 int
 126 AliHLTPHOSClusterizerComponent::DoDeinit()
 127 {
 128   //Do deinitialization
 129   Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSClusterizerComponent DoDeinit");
 130
 131   return 0;
 132 }
 133
 134
 135 const Char_t*
 136 AliHLTPHOSClusterizerComponent::GetComponentID()
 137 {
 138   return "AliHltPhosClusterizer";
 139 }
 140
 141 void
 142 AliHLTPHOSClusterizerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
 143 {
 144   //Get datatypes for input
 145   const AliHLTComponentDataType* pType=fgkInputDataTypes;
 146   while (pType->fID!=0) {
 147     list.push_back(*pType);
 148     pType++;
 149   }
 150 }
 151
 152 AliHLTComponentDataType
 153 AliHLTPHOSClusterizerComponent::GetOutputDataType()
 154 {
 155   //  return AliHLTPHOSPhysicsDefinitions::fgkAliHLTClusterDataType;
 156   return AliHLTPHOSDefinitions::fgkAliHLTClusterDataType;
 157 }
 158
 159 void
 160 AliHLTPHOSClusterizerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
 161
 162 {
 163   constBase = 30;
 164   inputMultiplier = 0.2;
 165 }
 166
 167 int
 168 AliHLTPHOSClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 169                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
 170                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
 171 {
 172   //Do event
 173
 174   UInt_t tSize            = 0;
 175   UInt_t offset           = 0;
 176   UInt_t mysize           = 0;
 177   Int_t nRecPoints        = 0;
 178   Int_t index             = 0;
 179
 180   AliHLTUInt8_t* outBPtr;
 181   outBPtr = outputPtr;
 182   const AliHLTComponentBlockData* iter = 0;
 183   unsigned long ndx;
 184
 185   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 186     {
 187       iter = blocks+ndx;
 188
 189       if(iter->fDataType != AliHLTPHOSDefinitions::fgkCellEnergyDataType)
 190         {
 191           cout << "Warning: data type is not fgkCellEnergyDataType " << endl;
 192           continue;
 193         }
 194       index = fClusterizerPtr->BuildCellEnergyArray( reinterpret_cast<AliHLTPHOSRcuCellEnergyDataStruct*>(iter->fPtr),
 195                                                      fRecPointListPtr);
 196
 197     }
 198
 199   nRecPoints = fClusterizerPtr->CreateRecPointStructArray(fRecPointStructArrayPtr, fRecPointListPtr, index);
 200
 201   cout << "Number of clusters found: " << nRecPoints << endl;
 202
 203   for(Int_t i = 0; i < nRecPoints; i++)
 204     {
 205       mysize = 0;
 206       offset = tSize;
 207
 208       fOutPtr =  (AliHLTPHOSClusterDataStruct*)outBPtr;
 209       fClusterizerPtr->CalculateCenterOfGravity(&fRecPointStructArrayPtr[i]);
 210       //      fClusterizerPtr->CalculateMoments(&fRecPointStructArrayPtr[i], 0);
 211       //     fClusterizerPtr->ClusterizeStruct(&fRecPointStructArrayPtr[i], fOutPtr);
 212
 213       mysize += sizeof(AliHLTPHOSClusterDataStruct);
 214
 215       AliHLTComponentBlockData bd;
 216       FillBlockData( bd );
 217       bd.fOffset = offset;
 218       bd.fSize = mysize;
 219       // PTH      bd.fDataType = AliHLTPHOSPhysicsDefinitions::fgkAliHLTClusterDataType;
 220       bd.fDataType = AliHLTPHOSDefinitions::fgkAliHLTClusterDataType;
 221       bd.fSpecification = 0xFFFFFFFF;
 222       outputBlocks.push_back( bd );
 223
 224       tSize += mysize;
 225       outBPtr += mysize;
 226
 227       if( tSize > size )
 228         {
 229           Logging( kHLTLogFatal, "HLT::AliHLTPHOSClusterizerComponent::DoEvent", "Too much data",
 230                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
 231                    , tSize, size );
 232           return EMSGSIZE;
 233         }
 234     }
 235
 236   size = tSize;
 237   fClusterizerPtr->ResetCellEnergyArray();
 238
 239   return 0;
 240
 241 }
 242
 243 int
 244 AliHLTPHOSClusterizerComponent::DoInit(int argc, const char** argv )
 245 {
 246   //Do initialization
 247   fClusterizerPtr = new AliHLTPHOSClusterizer();
 248   for(int i = 0; i < argc; i++)
 249     {
 250       if(!strcmp("-threshold", argv[i]))
 251         fClusterizerPtr->SetThreshold(atof(argv[i+1]));
 252       if(!strcmp("-clusterthreshold", argv[i]))
 253         fClusterizerPtr->SetClusterThreshold(atof(argv[i+1]));
 254       if(!strcmp("-highgain", argv[i]))
 255         fClusterizerPtr->SetHighGainFactor(atof(argv[i+1]));
 256       if(!strcmp("-lowgain", argv[i]))
 257         fClusterizerPtr->SetLowGainFactor(atof(argv[i+1]));
 258       if(!strcmp("-arraysize", argv[i]))
 259         fClusterizerPtr->SetArraySize(atoi(argv[i+1]));
 260     }
 261   fClusterizerPtr->ResetCellEnergyArray();
 262   fRecPointListPtr = new AliHLTPHOSRecPointListDataStruct[N_ZROWS_MOD*N_XCOLUMNS_MOD];
 263   fRecPointStructArrayPtr = new AliHLTPHOSRecPointDataStruct[1000];
 264   for(int i = 0; i < 1000; i++)
 265     {
 266       fRecPointStructArrayPtr[i].fMultiplicity = atoi(argv[4])* atoi(argv[4]);
 267       fRecPointStructArrayPtr[i].New();
 268     }
 269   printf("Clusterizer component started with:\n");
 270   printf(" Cell threshold:     %f\n", fClusterizerPtr->GetThreshold());
 271   printf(" Cluster threshold:  %f\n", fClusterizerPtr->GetClusterThreshold());
 272   printf(" High gain factor:   %f\n", fClusterizerPtr->GetHighGainFactor());
 273   printf(" Low gain factor:    %f\n", fClusterizerPtr->GetLowGainFactor());
 274   printf(" Cluster array size: %d\n\n", fClusterizerPtr->GetArraySize());
 275
 276   return 0;
 277 }
 278
 279 AliHLTComponent*
 280 AliHLTPHOSClusterizerComponent::Spawn()
 281 {
 282   //Spawn a new AliHLTPHOSClusterizerComponent, for HLT framework
 283   return new AliHLTPHOSClusterizerComponent();
 284 }