HLT/TPCLib/AliHLTTPCKryptonClusterFinderComponent.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * This file is property of and copyright by the ALICE HLT Project        *
   5  * ALICE Experiment at CERN, All rights reserved.                         *
   6  *                                                                        *
   7  * Primary Authors: Kenneth Aamodt                                        *
   8  *                  Kalliopi Kanaki                                       *
   9  *                  for The ALICE HLT 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 /** @file   AliHLTTPCKryptonClusterFinderComponent.cxx
  21     @author Kenneth Aamodt, Kalliopi Kanaki
  22     @date
  23     @brief  The TPC krypton cluster finder processing component
  24 */
  25
  26 // see header file for class documentation                                   //
  27 // or                                                                        //
  28 // refer to README to build package                                          //
  29 // or                                                                        //
  30 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt                          //
  31
  32 #if __GNUC__>= 3
  33 using namespace std;
  34 #endif
  35 #include "AliHLTTPCKryptonClusterFinderComponent.h"
  36 #include "AliHLTTPCDigitReaderDecoder.h"
  37 #include "AliHLTTPCKryptonClusterFinder.h"
  38 #include "AliHLTTPCSpacePointData.h"
  39 #include "AliHLTTPCClusterDataFormat.h"
  40 #include "AliHLTTPCTransform.h"
  41 #include "AliHLTTPCClusters.h"
  42 #include "AliHLTTPCDefinitions.h"
  43 #include "AliCDBEntry.h"
  44 #include "AliCDBManager.h"
  45 #include "TH1F.h"
  46
  47 #include <cstdlib>
  48 #include <cerrno>
  49 #include "TString.h"
  50 #include "TObjString.h"
  51 #include <sys/time.h>
  52
  53 AliHLTTPCKryptonClusterFinderComponent gAliHLTTPCKryptonClusterFinderComponent;
  54
  55 /** ROOT macro for the implementation of ROOT specific class methods */
  56 ClassImp(AliHLTTPCKryptonClusterFinderComponent)
  57
  58 AliHLTTPCKryptonClusterFinderComponent::AliHLTTPCKryptonClusterFinderComponent()
  59   :
  60   fKryptonClusterFinder(NULL),
  61   fReader(NULL),
  62   fSpecification(0)
  63 {
  64   // see header file for class documentation
  65   // or
  66   // refer to README to build package
  67   // or
  68   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  69 }
  70
  71 AliHLTTPCKryptonClusterFinderComponent::~AliHLTTPCKryptonClusterFinderComponent()
  72 {
  73   // see header file for class documentation
  74 }
  75
  76 // Public functions to implement AliHLTComponent's interface.
  77 // These functions are required for the registration process
  78
  79 const char* AliHLTTPCKryptonClusterFinderComponent::GetComponentID()
  80 {
  81   // see header file for class documentation
  82     return "TPCKryptonClusterFinder";
  83 }
  84
  85 void AliHLTTPCKryptonClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  86 {
  87   // see header file for class documentation
  88   list.clear();
  89   list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
  90 }
  91
  92 AliHLTComponentDataType AliHLTTPCKryptonClusterFinderComponent::GetOutputDataType()
  93 {
  94   // see header file for class documentation
  95  return kAliHLTMultipleDataType;
  96  //  return kAliHLTDataTypeHistogram;
  97 }
  98
  99 int AliHLTTPCKryptonClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
 100
 101 {
 102   // see header file for class documentation
 103   tgtList.clear();
 104   tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
 105   tgtList.push_back(kAliHLTDataTypeHwAddr16);
 106   return tgtList.size();
 107 }
 108
 109 void AliHLTTPCKryptonClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 110 {
 111   // see header file for class documentation
 112   // XXX TODO: Find more realistic values.
 113   constBase = 0;
 114   inputMultiplier = (100 * 0.4);
 115 }
 116
 117 AliHLTComponent* AliHLTTPCKryptonClusterFinderComponent::Spawn()
 118 {
 119   // see header file for class documentation
 120   return new AliHLTTPCKryptonClusterFinderComponent();
 121 }
 122
 123 int AliHLTTPCKryptonClusterFinderComponent::DoInit( int argc, const char** argv )
 124 {
 125   // see header file for class documentation
 126
 127   //  HLTFatal("Initializing the kryptonclusterfindercomponent");
 128
 129   if ( fKryptonClusterFinder )
 130     return EINPROGRESS;
 131
 132   fKryptonClusterFinder = new AliHLTTPCKryptonClusterFinder();
 133
 134   Int_t i = 0;
 135
 136   while ( i < argc ) {
 137
 138     //No arguments so far
 139
 140     Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
 141     return EINVAL;
 142
 143   }
 144
 145   fReader = new AliHLTTPCDigitReaderDecoder();
 146   fKryptonClusterFinder->SetReader(fReader);
 147
 148   return 0;
 149 }
 150
 151 int AliHLTTPCKryptonClusterFinderComponent::DoDeinit()
 152 {
 153   // see header file for class documentation
 154
 155   if ( fKryptonClusterFinder )
 156     delete fKryptonClusterFinder;
 157   fKryptonClusterFinder = NULL;
 158
 159   if ( fReader )
 160     delete fReader;
 161   fReader = NULL;
 162
 163   return 0;
 164 }
 165
 166 int AliHLTTPCKryptonClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData,
 167                                                      const AliHLTComponentBlockData* /*blocks*/,
 168                                               AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
 169                                               AliHLTUInt32_t& size,
 170                                               vector<AliHLTComponentBlockData>& outputBlocks )
 171 {
 172   // see header file for class documentation
 173
 174   if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
 175     size=0;
 176     return 0;
 177   }
 178
 179   //  == init iter (pointer to datablock)
 180   const AliHLTComponentBlockData* iter = NULL;
 181
 182   Int_t slice, patch;
 183
 184   unsigned long maxPoints = 0;
 185
 186   AliHLTTPCClusterData* outPtr;
 187
 188   outPtr = (AliHLTTPCClusterData*)outputPtr;
 189
 190   for (iter = GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
 191
 192     HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 193             evtData.fEventID, evtData.fEventID,
 194             DataType2Text(iter->fDataType).c_str(),
 195             DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
 196
 197     if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType && GetEventCount()<2){
 198       HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
 199                  DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
 200                  DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
 201     }
 202
 203     if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) &&
 204          iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;
 205
 206     fSpecification = iter->fSpecification;
 207
 208     slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 209     patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 210
 211
 212     fKryptonClusterFinder->SetPatch(patch);
 213
 214     fKryptonClusterFinder->InitSlice( slice, patch, maxPoints );
 215
 216     fKryptonClusterFinder->SetOutputArray((AliHLTTPCSpacePointData*)outPtr->fSpacePoints);
 217
 218     fKryptonClusterFinder->SetMaxOutputSize(size-sizeof(AliHLTUInt32_t));
 219
 220     fKryptonClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize);
 221
 222     fKryptonClusterFinder->FindRowClusters();
 223
 224     fKryptonClusterFinder->FindKryptonClusters();
 225
 226     //    if(fKryptonClusterFinder->GetNKryptonClusters()>0){
 227
 228     //    HLTFatal("Number of kryptonClusters: %d",(Int_t)fKryptonClusterFinder->GetNKryptonClusters());
 229
 230       if (sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData)>=size) {
 231         HLTFatal("Buffer too small too add more spacepoints: %d of %d byte(s) already used",sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData) ,size);
 232         return -ENOSPC;
 233       }
 234
 235       outPtr->fSpacePointCnt=fKryptonClusterFinder->GetNKryptonClusters();
 236
 237       AliHLTComponentBlockData bd;
 238       FillBlockData( bd );
 239       bd.fOffset = 0;
 240       bd.fSize = sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData);
 241       bd.fSpecification = iter->fSpecification;
 242       bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
 243       outputBlocks.push_back( bd );
 244
 245       //adding the list of hardware addresses to the outpot buffer
 246
 247       AliHLTUInt32_t dataOffsetBeforeHW=sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData);
 248       AliHLTUInt32_t sizeOfHWArray=fKryptonClusterFinder->fHWAddressVector.size()*sizeof(AliHLTUInt16_t);
 249       //      cout<<"size of array: "<<sizeOfHWArray<<"     number of entries"<<fKryptonClusterFinder->fHWAddressVector.size()<<endl;
 250
 251       if (dataOffsetBeforeHW+sizeOfHWArray>=size){
 252         HLTFatal("Buffer too small too add the HW address list: %d of %d byte(s) already used",dataOffsetBeforeHW+sizeOfHWArray ,size);
 253         return -ENOSPC;
 254       }
 255
 256       AliHLTUInt16_t *outputHWPtr=(AliHLTUInt16_t*)(outputPtr+dataOffsetBeforeHW);
 257       for(UInt_t hw=0;hw<fKryptonClusterFinder->fHWAddressVector.size();hw++){
 258         *outputHWPtr = fKryptonClusterFinder->fHWAddressVector[hw];
 259         outputHWPtr++;
 260       }
 261
 262       AliHLTComponentBlockData bdHW;
 263       FillBlockData( bdHW );
 264       bdHW.fOffset =  dataOffsetBeforeHW;
 265       bdHW.fSize = sizeOfHWArray;
 266       bdHW.fSpecification = iter->fSpecification;
 267       bdHW.fDataType = kAliHLTDataTypeHwAddr16;
 268       outputBlocks.push_back( bdHW );
 269
 270       size=dataOffsetBeforeHW+sizeOfHWArray;
 271
 272       /*    }
 273             else{
 274             size=0;
 275       }*/
 276       fReader->Reset();
 277   }
 278   return 0;
 279 }
 280
 281 int AliHLTTPCKryptonClusterFinderComponent::Configure(const char* arguments) {
 282 // see header file for class documentation
 283
 284   int iResult=0;
 285   if (!arguments) return iResult;
 286   HLTInfo("parsing configuration string \'%s\'", arguments);
 287   /*
 288   TString allArgs=arguments;
 289   TString argument;
 290   int bMissingParam=0;
 291
 292   TObjArray* pTokens=allArgs.Tokenize(" ");
 293   if (pTokens) {
 294     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
 295       argument=((TObjString*)pTokens->At(i))->GetString();
 296       if (argument.IsNull()) continue;
 297
 298       if (argument.CompareTo("-apply-noisemap")==0) {
 299         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 300         HLTInfo("got \'-apply-noisemap\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 301
 302       }
 303       else if (argument.CompareTo("-plot-side-c")==0) {
 304         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 305         HLTInfo("got \'-plot-side-c\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 306
 307       }
 308       else if (argument.CompareTo("-plot-side-a")==0) {
 309         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 310         HLTInfo("got \'-plot-side-a\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 311
 312       }
 313       else {
 314         HLTError("unknown argument %s", argument.Data());
 315         iResult=-EINVAL;
 316         break;
 317       }
 318     } // end for
 319
 320     delete pTokens;
 321
 322   } // end if pTokens
 323
 324   if (bMissingParam) {
 325     HLTError("missing parameter for argument %s", argument.Data());
 326     iResult=-EINVAL;
 327   }
 328   */
 329   return iResult;
 330 }
 331
 332 int AliHLTTPCKryptonClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
 333 {
 334   // see header file for class documentation
 335   const char* path="HLT/ConfigTPC";
 336   if (cdbEntry) path=cdbEntry;
 337   if (path) {
 338     HLTInfo("reconfigure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
 339     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 340     if (pEntry) {
 341       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
 342       if (pString) {
 343         HLTInfo("received configuration object: %s", pString->GetString().Data());
 344       } else {
 345         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
 346       }
 347     } else {
 348       HLTError("can not fetch object \"%s\" from CDB", path);
 349     }
 350   }
 351   return 0;
 352 }