HLT/MUON/OnlineAnalysis/AliHLTMUONHitReconstructorComponent.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ///*
  19 //
  20 //  The HitRec Component is designed to deal the rawdata inputfiles to findout the
  21 //  the reconstructed hits. The output is send to the output block for further
  22 //  processing.
  23 //
  24 //  Author : Indranil Das ( indra.das@saha.ac.in || indra.ehep@gmail.com )
  25 //
  26 //*/
  27
  28 #if __GNUC__>= 3
  29 using namespace std;
  30 #endif
  31
  32 #include "AliHLTMUONHitReconstructorComponent.h"
  33 #include "AliHLTMUONHitReconstructor.h"
  34 #include "AliHLTMUONRecHitsBlockStruct.h"
  35 #include "AliHLTLogging.h"
  36 #include "AliHLTSystem.h"
  37 #include "AliHLTDefinitions.h"
  38 #include <stdlib.h>
  39 #include <errno.h>
  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   :
  53   fHitRec(NULL)
  54 {
  55   // see header file for class documentation
  56 }
  57
  58 AliHLTMUONHitReconstructorComponent::~AliHLTMUONHitReconstructorComponent()
  59 {
  60   // see header file for class documentation
  61
  62 }
  63
  64 int AliHLTMUONHitReconstructorComponent::DoInit( int argc, const char** argv ){
  65   // see header file for class documentation
  66
  67   fHitRec = new AliHLTMUONHitReconstructor();
  68
  69   HLTInfo("dHLT hitrec");
  70   if (argc==0 && argv==NULL) {
  71     Logging( kHLTLogError, "AliHLTMUONHitReconstructorComponent::DoInit", "Arguments missing", " no arguments" );
  72     // this is just to get rid of the warning "unused parameter"
  73   }
  74
  75   Int_t i = 0;
  76   char lutFileName[500],buspatchFileName[500];
  77   int iDDL = -1;
  78   while(i<argc){
  79     if ( !strcmp( argv[i], "lut" ) ) {
  80       if ( argc <= i+1 ) {
  81         Logging( kHLTLogError, "AliHLTMUONHitReconstructorComponent::DoInit", "Missing LookupTable filename", "LookupTable filename not specified" );
  82         return EINVAL; /* Invalid argument */
  83       }
  84
  85       sprintf(lutFileName,"%s",argv[i+1]);
  86
  87       i += 2;
  88       continue;
  89     }// lut argument
  90
  91     if ( !strcmp( argv[i], "ddl" ) ) {
  92       if ( argc <= i+1 ) {
  93         Logging( kHLTLogError, "AliHLTMUONHitReconstructorComponent::DoInit", "Missing DDL argument", "DDL number not specified" );
  94         HLTError("AliHLTMUONHitReconstructorComponent::DoInit : DDL number is not specified ");
  95         return EINVAL;  /* Invalid argument */
  96       }
  97
  98       iDDL = atoi(argv[i+1]);
  99
 100       i += 2;
 101       continue;
 102     }// ddl argument
 103
 104     if ( !strcmp( argv[i], "buspatchmap" ) ) {
 105       if ( argc <= i+1 ) {
 106         Logging( kHLTLogError, "AliHLTMUONHitReconstructorComponent::DoInit", "Missing buspatch filename", "buspatch filename not specified" );
 107         return EINVAL; /* Invalid argument */
 108       }
 109
 110       sprintf(buspatchFileName,"%s",argv[i+1]);
 111
 112       i += 2;
 113       continue;
 114     }// buspatch argument
 115
 116
 117
 118   }// end of while loop
 119
 120   int lutline = fHitRec->GetLutLine(iDDL);
 121   AliHLTMUONHitReconstructor::DHLTLut* lookupTable = new AliHLTMUONHitReconstructor::DHLTLut[lutline];
 122   if(!ReadLookUpTable(lookupTable,lutFileName,iDDL)){
 123     Logging(kHLTLogInfo, "AliHLTMUONHitReconstructorComponent::DoInit", "Failed to read lut", "lut cannot be read, DoInit");
 124     return ENOENT ; /* No such file or directory */
 125   }else{
 126     for(int i = 0;i<lutline; i++){
 127       //#ifdef MY_DEBUG
 128 //       printf("%d\t%d\t%d\t%f\t%f\t%f\t%d\t\n",
 129 //           lookupTable[i].fIdManuChannel,
 130 //           lookupTable[i].fIX,
 131 //           lookupTable[i].fIY,
 132 //           lookupTable[i].fRealX,
 133 //           lookupTable[i].fRealY,
 134 //           lookupTable[i].fRealZ,
 135 //           lookupTable[i].fPcbZone,
 136 //           lookupTable[i].fPlane
 137 //           );
 138       //#endif
 139     }
 140
 141     BusToDetElem busToDetElem;
 142     if(!ReadBusPatchToDetElemFile(busToDetElem,buspatchFileName)){
 143       Logging(kHLTLogInfo, "AliHLTMUONHitReconstructorComponent::DoInit", "Failed to read buspatchmap", "buspatchmap cannot be read, DoInit");
 144       return ENOENT ; /* No such file or directory */
 145     }
 146
 147     fHitRec->SetBusToDetMap(busToDetElem);
 148     fHitRec->LoadLookUpTable(lookupTable,iDDL);
 149
 150   }// reading lut
 151
 152   return 0;
 153 }
 154
 155 int AliHLTMUONHitReconstructorComponent::DoDeinit(){
 156   // see header file for class documentation
 157   if(fHitRec)
 158     delete fHitRec;
 159   HLTInfo("dHLT hitrec");
 160   return 0;
 161 }
 162
 163 int AliHLTMUONHitReconstructorComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 164                                       AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
 165                                       AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks ) {
 166   // see header file for class documentation
 167   HLTInfo("dHLT hitrec");
 168
 169 //   if (evtData.fStructSize==0 && blocks==NULL && trigData.fStructSize==0 &&
 170 //       outputPtr==0 && size==0)
 171 //   {
 172 //     outputBlocks.clear();
 173 //     // this is just to get rid of the warning "unused parameter"
 174 //  }
 175
 176   unsigned long totalSize = 0;
 177   unsigned long mySize;
 178   //cout<<"Block Count : "<<evtData.fBlockCnt<<endl;
 179   for(UInt_t i=0;i<evtData.fBlockCnt;i++){
 180
 181     cout<<"0: totalsize : "<<totalSize<<"\tkAliHLTBlockAlignment :"<<kAliHLTBlockAlignment<<"\t size :"<<size<<endl;
 182
 183     // Align the beginning of this  block to the required value.
 184     //    if ( totalSize % kAliHLTBlockAlignment ){
 185     //      totalSize += kAliHLTBlockAlignment-(totalSize % kAliHLTBlockAlignment);
 186     //    }
 187
 188     if ( totalSize > size )
 189       break;
 190
 191     cout<<"1: totalsize : "<<totalSize<<"\tkAliHLTBlockAlignment :"<<kAliHLTBlockAlignment<<endl;
 192     // Determine the size we should use for the output for this block (the input block's size times the relative output size)
 193
 194
 195     int totalDDLSize = blocks[i].fSize/4;
 196     int ddlRawDataSize = totalDDLSize - AliHLTMUONHitReconstructor::GetkDDLHeaderSize();
 197     int ddlHeader[8];
 198     memcpy((char *) & ddlHeader,blocks[i].fPtr,(size_t)4*(AliHLTMUONHitReconstructor::GetkDDLHeaderSize()));
 199
 200 //     for(int j=0;j<8;j++)
 201 //       HLTDebug("ddlHeader[%d] : %d\n",j,ddlHeader[j]);
 202
 203     int* buffer = new int[ddlRawDataSize];
 204     memcpy((int*)buffer,((int*)blocks[i].fPtr + AliHLTMUONHitReconstructor::GetkDDLHeaderSize()),(sizeof(int)*ddlRawDataSize));
 205
 206 //     for(int j=0;j<ddlRawDataSize;j++)
 207 //       HLTDebug("buffer[%d] : %x\n",j,buffer[j]);
 208
 209
 210     AliHLTMUONRecHitStruct recHit[300];
 211     int nofHit = 300;
 212
 213     if(! (fHitRec->Run(buffer,&ddlRawDataSize,recHit,&nofHit))){
 214       cerr <<"AliHLTMUONHitReconstructorComponent::DoEvent : ERROR In Processing of HitRec Algo "<< endl;
 215       return EIO;
 216     }
 217
 218     mySize = sizeof(AliHLTMUONRecHitStruct)*nofHit;
 219
 220     HLTInfo("mySize set (1) mySize == %lu B - blocks[%lu].fSize == %lu",
 221              mySize, i, blocks[i].fSize);
 222
 223     // Check how much space we have left and adapt this output block's size accordingly.
 224     if ( totalSize + mySize > size )
 225       mySize = size-totalSize;
 226
 227     Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "mySize set (2)", "mySize == %lu B - totalSize == %lu - size == %lu",
 228                  mySize, totalSize, size );
 229
 230     if ( mySize<=0 )
 231       continue; // No room left to write a further block.
 232
 233     // Now copy the input block
 234     unsigned long copied = 0;
 235     // First copy all full multiples of the input block
 236     while ( copied+blocks[i].fSize <= mySize )
 237       {
 238         Logging( kHLTLogInfo, "0 : HLT::Dummy::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B",
 239                  blocks[i].fSize, copied, totalSize );
 240         memcpy( outputPtr+totalSize+copied, blocks[i].fPtr, blocks[i].fSize );
 241         copied += blocks[i].fSize;
 242       }
 243     // And the copy the remaining fragment of the block
 244     Logging( kHLTLogInfo, "1 : HLT::Dummy::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B",
 245              mySize-copied, copied, totalSize );
 246     memcpy( outputPtr+totalSize+copied, blocks[i].fPtr, mySize-copied );
 247     Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "Copied", "Copied: %lu B - totalSize: %lu B",
 248              copied, totalSize );
 249
 250
 251
 252     AliHLTComponentBlockData bd;
 253     FillBlockData( bd );
 254     bd.fOffset = totalSize;;
 255     bd.fSize = mySize;
 256     //bd.fPtr = (AliHLTUInt8_t*)(&recHit[0]);
 257     bd.fSpecification = blocks[i].fSpecification;
 258     outputBlocks.push_back( bd );
 259
 260     totalSize += mySize;
 261
 262     //    for(int j=0; j<nofHit; j++){
 263 //       printf("%d\t\t%d\t\t%f\t%f\t%f\n",
 264 //           i,outPtr->fRecPoint[j].fDetElemId,outPtr->fRecPoint[j].fX,
 265 //           outPtr->fRecPoint[j].fY,outPtr->fRecPoint[j].fZ);
 266 //       printf("1 : %d\t\t%d\t\t%f\t%f\t%f\n",
 267 //           i,(((AliHLTMUONRecHitStruct*)bd.fPtr) + j)->fDetElemId,
 268 //           (((AliHLTMUONRecHitStruct*)bd.fPtr) + j)->fX,
 269 //           (((AliHLTMUONRecHitStruct*)bd.fPtr) + j)->fY,
 270 //           (((AliHLTMUONRecHitStruct*)bd.fPtr) + j)->fZ);
 271 //    }// nof RecHits
 272
 273
 274     if(totalSize > size){
 275       cout<<"size : "<<size<<"\t  totalSize: "<<totalSize<<"\t mySize :"<<mySize<<endl;
 276       Logging( kHLTLogError, "AliHLTMUONHitReconstructorComponent::DoEvent", "Size exceeds the quota", "Size Exceeds the maximum quota" );
 277       return EMSGSIZE;
 278     }
 279
 280   }// block loop
 281
 282   size = totalSize;
 283
 284   return 0;
 285 }
 286
 287
 288 bool AliHLTMUONHitReconstructorComponent::ReadLookUpTable(
 289                 AliHLTMUONHitReconstructor::DHLTLut* lookupTable, const char* lutpath, int iDDL
 290         )
 291 {
 292 // Reads in a lookup table for the hit reconstruction algorithm from file.
 293
 294         if (iDDL < AliHLTMUONHitReconstructor::GetkDDLOffSet() ||
 295                 iDDL >= AliHLTMUONHitReconstructor::GetkDDLOffSet() + AliHLTMUONHitReconstructor::GetkNofDDL())
 296         {
 297 //              Logging(kHLTLogError, "AliHLTMUONHitReconstructorComponent::ReadLookUpTable", "Invalid DDL")
 298 //                      << "DDL number is out of range (must be " << AliHLTLog::kDec << HLTMUONHitRec::fgkDDLOffSet
 299 //                      << " <= iDDL < " << AliHLTLog::kDec
 300 //                      << HLTMUONHitRec::fgkDDLOffSet + HLTMUONHitRec::fgkNofDDL
 301 //                      << ENDLOG;
 302                 return false;
 303         }
 304
 305         int lutLine = fHitRec->GetLutLine(iDDL);
 306 //      cout<<"LutLine :"<<lutLine<<endl;
 307         FILE* fin = fopen(lutpath, "r");
 308         if (fin == NULL)
 309         {
 310 //              LOG(kHLTLogError, "AliHLTMUONHitReconstructorComponent::ReadLookUpTable", "I/O error")
 311 //                      << "Failed to open file: " << lutpath << ENDLOG;
 312                 return false;
 313         }
 314
 315 #       ifdef DEBUG
 316 //      Logging(kHLTLogError, "AliHLTMUONHitReconstructorComponent::ReadLookUpTable", "Trace")
 317 //              << "Reading LUT file: " << lutpath << ENDLOG;
 318 #       endif
 319
 320         for(int i=0;i<lutLine;i++)
 321         {
 322                 fscanf(
 323                         fin,
 324                         "%d\t%d\t%d\t%f\t%f\t%f\t%d\t%d\n",
 325                         &lookupTable[i].fIdManuChannel,
 326                         &lookupTable[i].fIX,
 327                         &lookupTable[i].fIY,
 328                         &lookupTable[i].fRealX,
 329                         &lookupTable[i].fRealY,
 330                         &lookupTable[i].fRealZ,
 331                         &lookupTable[i].fPcbZone,
 332                         &lookupTable[i].fPlane
 333                 );
 334         }
 335
 336         fclose(fin);
 337         return true;
 338 }
 339
 340 // implement this as well.
 341
 342 bool AliHLTMUONHitReconstructorComponent::ReadBusPatchToDetElemFile(
 343                 BusToDetElem& busToDetElem, const char* buspatchmappath
 344         )
 345 {
 346 // Loads the bus patch to detector element ID map from an ASCII file.
 347
 348         char getLine[80];
 349         char temp;
 350         int detElem, minBusPatch, maxBusPatch;
 351
 352         FILE* fin = fopen(buspatchmappath, "r");
 353         if (fin == NULL)
 354         {
 355 //              Logging(kHLTLogError, "AliHLTMUONHitReconstructorComponent::ReadBusPatchToDetElemFile", "I/O error")
 356 //                      << "Failed to open file: " << buspatchmappath << ENDLOG;
 357                 return false;
 358         }
 359
 360 #       ifdef DEBUG
 361 //      Logging(kHLTLogError, "AliHLTMUONHitReconstructorComponent::ReadBusPatchToDetElemFile", "Trace")
 362 //              << "Reading bus patch mapping file: " << buspatchmappath << ENDLOG;
 363 #       endif
 364
 365         while (feof(fin)==0)
 366         {
 367                 fgets(getLine,80,fin);
 368                 sscanf(getLine, "%d\t%d %c %d", &detElem, &minBusPatch, &temp, &maxBusPatch);
 369                 if (detElem >= 700 && detElem <= 1025)
 370                 {
 371                         for(int i = minBusPatch; i <= maxBusPatch; i++)
 372                                 busToDetElem[i] = detElem;
 373                 } // detElem condn
 374         } // while loop for file
 375
 376         fclose(fin);
 377         return true;
 378 }