HLT/MUON/OnlineAnalysis/AliHLTMUONHitReconstructorComponent.cxx

   1 /**************************************************************************
   2  * This file is property of and copyright by the ALICE HLT Project        *
   3  * All rights reserved.                                                   *
   4  *                                                                        *
   5  * Primary Authors:                                                       *
   6  *   Indranil Das <indra.das@saha.ac.in>                                  *
   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 /* $Id$ */
  18
  19 ///*
  20 //
  21 //  The HitRec Component is designed to deal the rawdata inputfiles to findout the
  22 //  the reconstructed hits. The output is send to the output block for further
  23 //  processing.
  24 //
  25 //  Author : Indranil Das ( indra.das@saha.ac.in || indra.ehep@gmail.com )
  26 //
  27 //*/
  28
  29 #include "AliHLTMUONRecHitsBlockStruct.h"
  30 #include "AliHLTMUONHitReconstructorComponent.h"
  31 #include "AliHLTMUONHitReconstructor.h"
  32 #include "AliHLTMUONConstants.h"
  33 #include "AliHLTMUONDataBlockWriter.h"
  34 #include "AliHLTLogging.h"
  35 #include "AliHLTSystem.h"
  36 #include "AliHLTDefinitions.h"
  37 #include <cstdlib>
  38 #include <cerrno>
  39 #include <cassert>
  40
  41 namespace
  42 {
  43         // The global object used for automatic component registration,
  44         // Note DO NOT use this component for calculation!
  45         AliHLTMUONHitReconstructorComponent gAliHLTMUONHitReconstructorComponent;
  46 }
  47
  48 ClassImp(AliHLTMUONHitReconstructorComponent)
  49
  50
  51 AliHLTMUONHitReconstructorComponent::AliHLTMUONHitReconstructorComponent() :
  52         fHitRec(NULL),
  53         fDDLDir(""),
  54         fDDL(0),
  55         fReaderType(false),
  56         fWarnForUnexpecedBlock(false)
  57 {
  58 }
  59
  60
  61 AliHLTMUONHitReconstructorComponent::~AliHLTMUONHitReconstructorComponent()
  62 {
  63 }
  64
  65 const char* AliHLTMUONHitReconstructorComponent::GetComponentID()
  66 {
  67         return AliHLTMUONConstants::HitReconstructorId();
  68 }
  69
  70
  71 void AliHLTMUONHitReconstructorComponent::GetInputDataTypes( std::vector<AliHLTComponentDataType>& list)
  72 {
  73         list.clear();
  74         list.push_back( AliHLTMUONConstants::TrackingDDLRawDataType() );
  75 }
  76
  77
  78 AliHLTComponentDataType AliHLTMUONHitReconstructorComponent::GetOutputDataType()
  79 {
  80         return AliHLTMUONConstants::RecHitsBlockDataType();
  81 }
  82
  83
  84 void AliHLTMUONHitReconstructorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  85 {
  86         constBase = sizeof(AliHLTMUONRecHitsBlockWriter::HeaderType);
  87         inputMultiplier = 1;
  88 }
  89
  90
  91 // Spawn function, return new instance of this class
  92 AliHLTComponent* AliHLTMUONHitReconstructorComponent::Spawn()
  93 {
  94         return new AliHLTMUONHitReconstructorComponent;
  95 }
  96
  97
  98 int AliHLTMUONHitReconstructorComponent::DoInit(int argc, const char** argv)
  99 {
 100   // perform initialization. We check whether our relative output size is specified in the arguments.
 101
 102   HLTInfo("Initialising DHLT HitReconstruction Component");
 103
 104   fHitRec = new AliHLTMUONHitReconstructor();
 105   fWarnForUnexpecedBlock = false;
 106
 107   // this is to get rid of the warning "unused parameter"
 108   if (argc==0 && argv==NULL) {
 109     HLTError("Arguments missing", " no arguments" );
 110   }
 111
 112   char lutFileName[500],buspatchFileName[500];
 113
 114   int i = 0;
 115   char* cpErr;
 116   while ( i < argc )
 117     {
 118       HLTDebug("argv[%d] == %s", i, argv[i] );
 119
 120       if ( !strcmp( argv[i], "-lut" ) ) {
 121         if ( argc <= i+1 ) {
 122           HLTError("LookupTable filename not specified" );
 123           return EINVAL; /* Invalid argument */
 124         }
 125
 126         sprintf(lutFileName,"%s",argv[i+1]);
 127
 128         i += 2;
 129         continue;
 130       }// lut argument
 131
 132
 133       if ( !strcmp( argv[i], "-ddl" ) ) {
 134         if ( argc <= i+1 ) {
 135           HLTError("DDL number not specified" );
 136           return EINVAL;  /* Invalid argument */
 137         }
 138
 139         unsigned long num = strtoul( argv[i+1], &cpErr, 0 );
 140         if (cpErr == NULL or *cpErr != '\0')
 141           {
 142             HLTError("Cannot convert '%s' to DDL Number ", argv[i+1] );
 143             return EINVAL;
 144           }
 145         if (num < 13 or 20 < num)
 146         {
 147                 HLTError("The DDL number must be in the range [13..20].");
 148                 return EINVAL;
 149         }
 150         fDDL = num - 1;
 151
 152         i += 2;
 153         continue;
 154       }// ddl argument
 155
 156
 157       if ( !strcmp( argv[i], "-rawdir" ) ) {
 158         if ( argc <= i+1 ) {
 159           HLTError("DDL directory not specified" );
 160           return EINVAL;  /* Invalid argument */
 161         }
 162
 163         fDDLDir = argv[i+1] ;
 164
 165         i += 2;
 166         continue;
 167       }// ddl directory argument
 168
 169
 170       if ( !strcmp( argv[i], "-buspatchmap" ) ) {
 171         if ( argc <= i+1 ) {
 172           HLTError("Buspatch filename not specified" );
 173           return EINVAL; /* Invalid argument */
 174         }
 175
 176         sprintf(buspatchFileName,"%s",argv[i+1]);
 177
 178         i += 2;
 179         continue;
 180       }// buspatch argument
 181
 182       if ( !strcmp( argv[i], "-rawreader" ) ) {
 183         fReaderType = true; // true when using rawreader for standalone it is set to false.
 184         i += 1;
 185         continue;
 186       }
 187
 188       if ( !strcmp( argv[i], "-warn_on_unexpected_block" ) ) {
 189         fWarnForUnexpecedBlock = true;
 190         i++;
 191         continue;
 192       }
 193
 194       HLTError("Unknown option '%s'", argv[i] );
 195       return EINVAL;
 196
 197     }//while loop
 198
 199   int lutline = fHitRec->GetLutLine(fDDL);
 200   AliHLTMUONHitReconstructor::DHLTLut* lookupTable = new AliHLTMUONHitReconstructor::DHLTLut[lutline];
 201   if(!ReadLookUpTable(lookupTable,lutFileName)){
 202     HLTError("Failed to read lut, lut cannot be read, DoInit");
 203     return ENOENT ; /* No such file or directory */
 204   }else{
 205
 206     BusToDetElem busToDetElem;
 207     BusToDDL busToDDL;
 208     if(!ReadBusPatchToDetElemFile(busToDetElem,busToDDL,buspatchFileName)){
 209       HLTError("Failed to read buspatchmap, buspatchmap cannot be read, DoInit");
 210       return ENOENT ; /* No such file or directory */
 211     }
 212
 213     fHitRec->SetBusToDetMap(busToDetElem);
 214     fHitRec->SetBusToDDLMap(busToDDL);
 215     fHitRec->LoadLookUpTable(lookupTable,fDDL);
 216
 217   }// reading lut
 218
 219   delete []lookupTable;
 220
 221   HLTInfo("Initialisation of DHLT HitReconstruction Component is done");
 222
 223   return 0;
 224 }
 225
 226
 227 int AliHLTMUONHitReconstructorComponent::DoDeinit()
 228 {
 229   if(fHitRec)
 230     delete fHitRec;
 231
 232   HLTInfo(" Deinitialising DHLT HitReconstruction Component");
 233
 234   return 0;
 235 }
 236
 237
 238 int AliHLTMUONHitReconstructorComponent::DoEvent(
 239                 const AliHLTComponentEventData& evtData,
 240                 const AliHLTComponentBlockData* blocks,
 241                 AliHLTComponentTriggerData& /*trigData*/,
 242                 AliHLTUInt8_t* outputPtr,
 243                 AliHLTUInt32_t& size,
 244                 std::vector<AliHLTComponentBlockData>& outputBlocks
 245         )
 246 {
 247         // Process an event
 248         unsigned long totalSize = 0; // Amount of memory currently consumed in bytes.
 249
 250         HLTDebug("Processing event %llu with %u input data blocks.",
 251                 evtData.fEventID, evtData.fBlockCnt
 252         );
 253
 254         // Loop over all input blocks in the event
 255         for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
 256         {
 257 #ifdef __DEBUG
 258                 char id[kAliHLTComponentDataTypefIDsize+1];
 259                 for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
 260                         id[i] = blocks[n].fDataType.fID[i];
 261                 id[kAliHLTComponentDataTypefIDsize] = '\0';
 262                 char origin[kAliHLTComponentDataTypefOriginSize+1];
 263                 for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
 264                         origin[i] = blocks[n].fDataType.fOrigin[i];
 265                 origin[kAliHLTComponentDataTypefOriginSize] = '\0';
 266 #endif // __DEBUG
 267                 HLTDebug("Handling block: %u, with fDataType.fID = '%s',"
 268                           " fDataType.fID = '%s', fPtr = %p and fSize = %u bytes.",
 269                         n, static_cast<char*>(id), static_cast<char*>(origin),
 270                         blocks[n].fPtr, blocks[n].fSize
 271                 );
 272
 273                 if (blocks[n].fDataType != AliHLTMUONConstants::TrackingDDLRawDataType())
 274                 {
 275                         // Log a message indicating that we got a data block that we
 276                         // do not know how to handle.
 277                         char id[kAliHLTComponentDataTypefIDsize+1];
 278                         for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
 279                                 id[i] = blocks[n].fDataType.fID[i];
 280                         id[kAliHLTComponentDataTypefIDsize] = '\0';
 281                         char origin[kAliHLTComponentDataTypefOriginSize+1];
 282                         for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
 283                                 origin[i] = blocks[n].fDataType.fOrigin[i];
 284                         origin[kAliHLTComponentDataTypefOriginSize] = '\0';
 285
 286                         if (fWarnForUnexpecedBlock)
 287                                 HLTWarning("Received a data block of a type we cannot handle: '%s' origin: '%s'",
 288                                         static_cast<char*>(id), static_cast<char*>(origin)
 289                                 );
 290                         else
 291                                 HLTDebug("Received a data block of a type we cannot handle: '%s' origin: '%s'",
 292                                         static_cast<char*>(id), static_cast<char*>(origin)
 293                                 );
 294
 295                         continue;
 296                 }
 297
 298                 // Create a new output data block and initialise the header.
 299                 AliHLTMUONRecHitsBlockWriter block(outputPtr+totalSize, size-totalSize);
 300                 if (not block.InitCommonHeader())
 301                 {
 302                         HLTError("There is not enough space in the output buffer for the new data block.",
 303                                  " We require at least %u bytes, but have %u bytes left.",
 304                                 sizeof(AliHLTMUONRecHitsBlockWriter::HeaderType),
 305                                 block.BufferSize()
 306                         );
 307                         break;
 308                 }
 309
 310                 AliHLTUInt32_t totalDDLSize = blocks[n].fSize / sizeof(AliHLTUInt32_t);
 311                 AliHLTUInt32_t ddlRawDataSize = totalDDLSize - fHitRec->GetkDDLHeaderSize();
 312                 AliHLTUInt32_t* buffer = reinterpret_cast<AliHLTUInt32_t*>(blocks[n].fPtr)
 313                         + fHitRec->GetkDDLHeaderSize();
 314                 AliHLTUInt32_t nofHit = block.MaxNumberOfEntries();
 315
 316                 HLTDebug("=========== Dumping DDL payload buffer ==========");
 317                 for (AliHLTUInt32_t j = 0; j < totalDDLSize; j++)
 318                         HLTDebug("buffer[%d] : %x",j,buffer[j]);
 319                 HLTDebug("================== End of dump =================");
 320
 321                 if (not fHitRec->Run(buffer, ddlRawDataSize, block.GetArray(), nofHit))
 322                 {
 323                         HLTError("Error while processing of hit reconstruction algorithm.");
 324                         size = totalSize; // Must tell the framework how much buffer space was used.
 325                         return EIO;
 326                 }
 327
 328                 // nofHit should now contain the number of reconstructed hits actually found
 329                 // and filled into the output data block, so we can set this number.
 330                 assert( nofHit <= block.MaxNumberOfEntries() );
 331                 block.SetNumberOfEntries(nofHit);
 332
 333                 HLTDebug("Number of reconstructed hits found is %d", nofHit);
 334
 335                 // Fill a block data structure for our output block.
 336                 AliHLTComponentBlockData bd;
 337                 FillBlockData(bd);
 338                 bd.fPtr = outputPtr;
 339                 // This block's start (offset) is after all other blocks written so far.
 340                 bd.fOffset = totalSize;
 341                 bd.fSize = block.BytesUsed();
 342                 bd.fDataType = AliHLTMUONConstants::RecHitsBlockDataType();
 343                 bd.fSpecification = blocks[n].fSpecification;
 344                 outputBlocks.push_back(bd);
 345
 346                 // Increase the total amount of data written so far to our output memory
 347                 totalSize += block.BytesUsed();
 348         }
 349         // Finally we set the total size of output memory we consumed.
 350         size = totalSize;
 351
 352         return 0;
 353 }
 354
 355
 356 bool AliHLTMUONHitReconstructorComponent::ReadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookupTable, const char* lutpath)
 357 {
 358   if (fDDL < AliHLTMUONHitReconstructor::GetkDDLOffSet() ||
 359       fDDL >= AliHLTMUONHitReconstructor::GetkDDLOffSet() + AliHLTMUONHitReconstructor::GetkNofDDL()){
 360     HLTError("DDL number is out of range");
 361     return false;
 362   }
 363
 364   int lutLine = fHitRec->GetLutLine(fDDL);
 365
 366   FILE* fin = fopen(lutpath, "r");
 367   if (fin == NULL){
 368     HLTError("Failed to open file: %s",lutpath);
 369     return false;
 370   }
 371
 372   for(int i=0;i<lutLine;i++){
 373     fscanf(
 374            fin,
 375            "%d\t%d\t%d\t%f\t%f\t%f\t%d\t%d\n",
 376            &lookupTable[i].fIdManuChannel,
 377            &lookupTable[i].fIX,
 378            &lookupTable[i].fIY,
 379            &lookupTable[i].fRealX,
 380            &lookupTable[i].fRealY,
 381            &lookupTable[i].fRealZ,
 382            &lookupTable[i].fPcbZone,
 383            &lookupTable[i].fPlane
 384            );
 385   }
 386
 387   fclose(fin);
 388   return true;
 389 }
 390
 391
 392 bool AliHLTMUONHitReconstructorComponent::ReadBusPatchToDetElemFile(BusToDetElem& busToDetElem, BusToDDL& busToDDL, const char* buspatchmappath)
 393 {
 394   char getLine[80];
 395   char temp;
 396   int detElem, minBusPatch, maxBusPatch, ddl;
 397
 398   FILE* fin = fopen(buspatchmappath, "r");
 399   if (fin == NULL){
 400     HLTError("Failed to open file: %s",buspatchmappath);
 401     return false;
 402   }
 403
 404   while (feof(fin)==0){
 405     fgets(getLine,80,fin);
 406     sscanf(getLine, "%d\t%d %c %d\t%d", &detElem, &minBusPatch, &temp, &maxBusPatch,&ddl);
 407     if (detElem >= 700 && detElem <= 1025){
 408
 409       for(int i = minBusPatch; i <= maxBusPatch; i++){
 410         busToDetElem[i] = detElem;
 411         busToDDL[i] = ddl;
 412       }//for loop
 413     } // detElem condn
 414   } // while loop for file
 415
 416   fclose(fin);
 417   return true;
 418 }