HLT/TPCLib/AliHLTTPCClusterConverterComponent.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: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *
   8  *                  for The ALICE HLT Project.                            *
   9  *                                                                        *
  10  * Permission to use, copy, modify and distribute this software and its   *
  11  * documentation strictly for non-commercial purposes is hereby granted   *
  12  * without fee, provided that the above copyright notice appears in all   *
  13  * copies and that both the copyright notice and this permission notice   *
  14  * appear in the supporting documentation. The authors make no claims     *
  15  * about the suitability of this software for any purpose. It is          *
  16  * provided "as is" without express or implied warranty.                  *
  17  **************************************************************************/
  18
  19 /** @file   AliHLTTPCClusterConverterComponent.cxx
  20     @author Kalliopi Kanaki
  21     @date
  22     @brief  The TPC cluster format conversion component.
  23 */
  24
  25 // see header file for class documentation
  26 // or
  27 // refer to README to build package
  28 // or
  29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  30
  31 #if __GNUC__>= 3
  32 using namespace std;
  33 #endif
  34
  35 #include "AliHLTTPCClusterConverterComponent.h"
  36 #include "AliHLTTPCOfflineCluster.h"
  37 #include "AliTPCclusterMI.h"
  38
  39 #include "AliHLTTPCClusterDataFormat.h"
  40
  41 #include "AliHLTTPCTrackSegmentData.h"
  42 #include "AliHLTTPCTrackletDataFormat.h"
  43
  44 #include "AliCDBEntry.h"
  45 #include "AliCDBManager.h"
  46
  47 #include "AliHLTTPCMemHandler.h"
  48 #include "AliHLTTPCDefinitions.h"
  49
  50 #include "TString.h"
  51 #include "TObjString.h"
  52 #include "TObjArray.h"
  53 //#include "AliHLTTPC.h"
  54 //#include <stdlib.h>
  55 //#include <cerrno>
  56
  57 /** ROOT macro for the implementation of ROOT specific class methods */
  58 ClassImp(AliHLTTPCClusterConverterComponent)
  59
  60 AliHLTTPCClusterConverterComponent::AliHLTTPCClusterConverterComponent()
  61 :
  62 fClusters(0),
  63 fTracks(0),
  64 fOffArray(0)
  65 {  // see header file for class documentation
  66   // or
  67   // refer to README to build package
  68   // or
  69   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  70 }
  71
  72 AliHLTTPCClusterConverterComponent::~AliHLTTPCClusterConverterComponent(){
  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* AliHLTTPCClusterConverterComponent::GetComponentID(){
  80 // see header file for class documentation
  81   return "TPCClusterConverter";
  82 }
  83
  84 void AliHLTTPCClusterConverterComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list){
  85 // see header file for class documentation
  86
  87   list.clear();
  88   list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
  89 }
  90
  91 AliHLTComponentDataType AliHLTTPCClusterConverterComponent::GetOutputDataType(){
  92 // see header file for class documentation
  93   return kAliHLTDataTypeTObject;
  94 }
  95
  96 int AliHLTTPCClusterConverterComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList){
  97 // see header file for class documentation
  98
  99   tgtList.clear();
 100   tgtList.push_back(kAliHLTDataTypeTObject);
 101   return tgtList.size();
 102 }
 103
 104 void AliHLTTPCClusterConverterComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ){
 105 // see header file for class documentation
 106
 107   constBase = 0;
 108   inputMultiplier = 1;
 109 }
 110
 111 AliHLTComponent* AliHLTTPCClusterConverterComponent::Spawn(){
 112 // see header file for class documentation
 113   return new AliHLTTPCClusterConverterComponent;
 114 }
 115
 116
 117 int AliHLTTPCClusterConverterComponent::DoInit( int argc, const char** argv ){
 118 // see header file for class documentation
 119
 120   //Int_t i = 0;
 121   //Char_t* cpErr;
 122   int iResult = 0;
 123
 124   TString configuration = "";
 125   TString argument = "";
 126
 127   for (int i=0; i<argc && iResult>=0; i++) {
 128     argument=argv[i];
 129     if (!configuration.IsNull()) configuration+=" ";
 130     configuration+=argument;
 131   }
 132
 133   if (!configuration.IsNull()) {
 134     iResult=Configure(configuration.Data());
 135   } else {
 136     iResult=Reconfigure(NULL, NULL);
 137   }
 138
 139
 140 //   while ( i < argc ) {
 141 //     if (!strcmp( argv[i], "-apply-noisemap")) {
 142 //         fApplyNoiseMap = strtoul( argv[i+1], &cpErr ,0);
 143 //
 144 //     if ( *cpErr ) {
 145 //         HLTError("Cannot convert apply-noisemap specifier '%s'.", argv[i+1]);
 146 //         return EINVAL;
 147 //     }
 148 //       i+=2;
 149 //       continue;
 150 //     }
 151 //
 152 //     if (!strcmp( argv[i], "-plot-side-a")) {
 153 //         fPlotSideA = strtoul( argv[i+1], &cpErr ,0);
 154 //
 155 //     if ( *cpErr ) {
 156 //         HLTError("Cannot convert plot-side-a specifier '%s'.", argv[i+1]);
 157 //         return EINVAL;
 158 //     }
 159 //       i+=2;
 160 //       continue;
 161 //     }
 162 //
 163 //     if (!strcmp( argv[i], "-plot-side-c")) {
 164 //         fPlotSideC = strtoul( argv[i+1], &cpErr ,0);
 165 //
 166 //     if ( *cpErr ) {
 167 //         HLTError("Cannot convert plot-side-c specifier '%s'.", argv[i+1]);
 168 //         return EINVAL;
 169 //     }
 170 //       i+=2;
 171 //       continue;
 172 //     }
 173 //
 174 //     if (!strcmp( argv[i], "-reset-histograms")) {
 175 //         fResetHistograms = strtoul( argv[i+1], &cpErr ,0);
 176 //
 177 //     if ( *cpErr ) {
 178 //         HLTError("Cannot convert reset-histograms specifier '%s'.", argv[i+1]);
 179 //         return EINVAL;
 180 //     }
 181 //       i+=2;
 182 //       continue;
 183 //     }
 184 //
 185 //     Logging(kHLTLogError, "HLT::TPCNoiseMap::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
 186 //     return EINVAL;
 187 //
 188 //   } // end while
 189
 190   return 0;
 191 } // end DoInit()
 192
 193 int AliHLTTPCClusterConverterComponent::DoDeinit(){
 194 // see header file for class documentation
 195   return 0;
 196 }
 197
 198 int AliHLTTPCClusterConverterComponent::DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& /*trigData*/){
 199 // see header file for class documentation
 200
 201   //Logging(kHLTLogDebug, "HLT::TPCClusterConverter::DoEvent", "DoEvent", "DoEvent()");
 202   HLTInfo("--- Entering DoEvent() in TPCClusterConverter ---");
 203
 204   if(GetFirstInputBlock(kAliHLTDataTypeSOR) || GetFirstInputBlock(kAliHLTDataTypeEOR)) return 0;
 205
 206   Int_t numOfTotalTracks = 0;
 207   Int_t numOfTotalSpacePoints = 0 ;
 208   const AliHLTComponentBlockData *iter = NULL;
 209
 210
 211   // ========== LOOP OVER CLUSTER DATA =====================//
 212
 213   for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock()){
 214       //AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 215       //AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 216
 217       const AliHLTTPCClusterData *clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
 218       numOfTotalSpacePoints+= (Int_t)clusterData->fSpacePointCnt;
 219
 220       AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*)clusterData->fSpacePoints;
 221
 222       for(Int_t i=0; i<(Int_t)clusterData->fSpacePointCnt; i++){ fClusters.push_back(clusters[i]); }
 223   }
 224
 225
 226
 227
 228 //   // ========== LOOP OVER TRACKS =====================//
 229 //
 230 //   for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTracksDataType); iter != NULL; iter = GetNextInputBlock()){
 231 //       AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 232 //       AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 233 //
 234 //       const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*)iter->fPtr;
 235 //       numOfTotalTracks += (Int_t)trackData->fTrackletCnt;
 236 //
 237 //       AliHLTTPCTrackSegmentData *tracks = (AliHLTTPCTrackSegmentData*)trackData->fTracklets;
 238 //
 239 //       for(int i=0;i<(Int_t)trackData->fTrackletCnt;i++){ fTracks.push_back(tracks[i]); }
 240 //   }
 241
 242
 243
 244   // ========== LOOP OVER TRACK SEGMENTS =====================//
 245
 246   for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTrackSegmentsDataType); iter != NULL; iter = GetNextInputBlock()){
 247
 248       HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 249                evtData.fEventID, evtData.fEventID,
 250                DataType2Text(iter->fDataType).c_str(),
 251                DataType2Text(AliHLTTPCDefinitions::fgkTrackSegmentsDataType | kAliHLTDataOriginTPC).c_str());
 252
 253       if(iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType && GetEventCount()<2){
 254          HLTWarning("data type %s is depricated, use %s (fgkTrackSegmentsDataType)!",
 255          DataType2Text(AliHLTTPCDefinitions::fgkTrackSegmentsDataType).c_str(),
 256          DataType2Text(AliHLTTPCDefinitions::fgkTrackSegmentsDataType | kAliHLTDataOriginTPC).c_str());
 257       }
 258
 259       if(iter->fDataType != (AliHLTTPCDefinitions::fgkTrackSegmentsDataType | kAliHLTDataOriginTPC)) continue;
 260
 261       if(iter->fDataType!=AliHLTTPCDefinitions::fgkTrackSegmentsDataType){
 262          HLTDebug("Data block type is not of type AliHLTTPCDefinitions::fgkTrackSegmentsDataType"); continue;
 263       } // endif
 264
 265       const AliHLTTPCTrackletData *trackData = (const AliHLTTPCTrackletData*)iter->fPtr;
 266       numOfTotalTracks += (Int_t)trackData->fTrackletCnt;
 267
 268       AliHLTTPCTrackSegmentData *tracks = (AliHLTTPCTrackSegmentData*)trackData->fTracklets;
 269       for(Int_t i=0; i<(Int_t)trackData->fTrackletCnt; i++){ fTracks.push_back(tracks[i]); }
 270
 271   } // end of loop over track segments
 272
 273
 274
 275   // ========== TRIPLE LOOP FOR SETTING THE fUsed CLUSTERS =====================//
 276
 277       Int_t nClustersUsed = 0;
 278       for(Int_t tr=0; tr<numOfTotalTracks; tr++){
 279          Int_t nHits = fTracks[tr].fNPoints;
 280          UInt_t *hitnum = fTracks[tr].fPointIDs;
 281          //HLTInfo("Hits %d ", nHits);
 282
 283            for(Int_t h=0; h<nHits; h++){
 284                UInt_t  idTrack        = hitnum[h];
 285                Int_t   sliceTrack     = AliHLTTPCSpacePointData::GetSlice(idTrack);
 286                Int_t   partitionTrack = AliHLTTPCSpacePointData::GetPatch(idTrack);
 287                UInt_t  posTrack       = AliHLTTPCSpacePointData::GetNumber(idTrack);
 288
 289                  fOffArray->Clear();
 290                  for(Int_t cl=0; cl<numOfTotalSpacePoints; cl++){
 291                      UInt_t  idCluster        = fClusters[cl].fID;
 292                      Int_t   sliceCluster     = AliHLTTPCSpacePointData::GetSlice(idCluster);
 293                      Int_t   partitionCluster = AliHLTTPCSpacePointData::GetPatch(idCluster);
 294                      UInt_t  posCluster       = AliHLTTPCSpacePointData::GetNumber(idCluster);
 295
 296
 297                      if(sliceCluster==sliceTrack && partitionCluster==partitionTrack && posCluster==posTrack){
 298                         fClusters[cl].fUsed = kTRUE;
 299                         fClusters[cl].fTrackN = tr;
 300                         nClustersUsed++;
 301                         fOffArray->Add(new AliHLTTPCOfflineCluster(fClusters[cl]));
 302                      } // end if
 303                  } // end for clusters
 304                  PushBack((TObject*)fOffArray, kAliHLTDataTypeTObject, 0);
 305            } // end for hits
 306   } // end for loop over track segments
 307   return 0;
 308 } // end DoEvent()
 309
 310 int AliHLTTPCClusterConverterComponent::Configure(const char* arguments){
 311 // see header file for class documentation
 312
 313   int iResult=0;
 314   if (!arguments) return iResult;
 315   HLTInfo("parsing configuration string \'%s\'", arguments);
 316
 317   TString allArgs=arguments;
 318   TString argument;
 319   int bMissingParam=0;
 320
 321   TObjArray* pTokens = allArgs.Tokenize(" ");
 322   if (pTokens) {
 323     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
 324       argument=((TObjString*)pTokens->At(i))->GetString();
 325       if (argument.IsNull()) continue;
 326
 327       if (argument.CompareTo("-apply-noisemap")==0) {
 328         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 329         HLTInfo("got \'-apply-noisemap\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 330
 331       }
 332       else if (argument.CompareTo("-plot-side-c")==0) {
 333         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 334         HLTInfo("got \'-plot-side-c\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 335
 336       }
 337       else if (argument.CompareTo("-plot-side-a")==0) {
 338         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 339         HLTInfo("got \'-plot-side-a\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 340
 341       }
 342       else {
 343         HLTError("unknown argument %s", argument.Data());
 344         iResult=-EINVAL;
 345         break;
 346       }
 347     } // end for
 348
 349     delete pTokens;
 350
 351   } // end if pTokens
 352
 353   if (bMissingParam) {
 354     HLTError("missing parameter for argument %s", argument.Data());
 355     iResult=-EINVAL;
 356   }
 357    return iResult;
 358 }
 359
 360 int AliHLTTPCClusterConverterComponent::Reconfigure(const char* cdbEntry, const char* chainId){
 361 // see header file for class documentation
 362
 363    int iResult=0;
 364   const char* path="HLT/ConfigTPC/ClusterConverterComponent";
 365   const char* defaultNotify="";
 366   if (cdbEntry) {
 367     path=cdbEntry;
 368     defaultNotify=" (default)";
 369   }
 370   if (path) {
 371     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
 372     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 373     if (pEntry) {
 374       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
 375       if (pString) {
 376         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
 377         iResult=Configure(pString->GetString().Data());
 378       } else {
 379         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
 380       }
 381     } else {
 382       HLTError("can not fetch object \"%s\" from CDB", path);
 383     }
 384   }
 385
 386   return iResult;
 387  }