HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.cxx

   1 // **************************************************************************
   2 // This file is property of and copyright by the ALICE HLT Project          *
   3 // ALICE Experiment at CERN, All rights reserved.                           *
   4 //                                                                          *
   5 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
   6 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
   7 //                  Matthias Kretz <kretz@kde.org>                          *
   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
  20
  21 /** @file   AliHLTTPCCAGlobalMergerComponent.cxx
  22     @author Matthias Kretz
  23     @date
  24     @brief  HLT TPC CA global merger component.
  25 */
  26
  27 #if __GNUC__>= 3
  28 using namespace std;
  29 #endif
  30
  31 #include "AliHLTTPCCAGlobalMergerComponent.h"
  32 #include "AliHLTTPCCAMergerOutput.h"
  33 #include "AliHLTTPCTransform.h"
  34 #include "AliHLTTPCCAMerger.h"
  35 #include "AliHLTTPCVertex.h"
  36 #include "AliHLTTPCVertexData.h"
  37 #include "AliHLTTPCTrackSegmentData.h"
  38 #include "AliHLTTPCTrack.h"
  39 #include "AliHLTTPCTrackArray.h"
  40 #include "AliHLTTPCTrackletDataFormat.h"
  41 #include "AliHLTTPCCADef.h"
  42 #include "AliHLTTPCDefinitions.h"
  43 #include "AliHLTTPCCATrackConvertor.h"
  44 #include "AliHLTTPCCASliceOutput.h"
  45
  46 #include "AliCDBEntry.h"
  47 #include "AliCDBManager.h"
  48 #include "TObjString.h"
  49 #include "TObjArray.h"
  50
  51 #include <climits>
  52 #include <cstdlib>
  53 #include <cerrno>
  54
  55
  56 // ROOT macro for the implementation of ROOT specific class methods
  57 ClassImp( AliHLTTPCCAGlobalMergerComponent )
  58
  59
  60 // global object for registration
  61 AliHLTTPCCAGlobalMergerComponent AliHLTTPCCAGlobalMergerComponent::fgAliHLTTPCCAGlobalMergerComponent;
  62
  63 AliHLTTPCCAGlobalMergerComponent::AliHLTTPCCAGlobalMergerComponent()
  64   : fGlobalMerger( 0 ), fSolenoidBz(5)
  65 {
  66   // see header file for class documentation
  67 }
  68
  69 // Public functions to implement AliHLTComponent's interface.
  70 // These functions are required for the registration process
  71
  72 const char *AliHLTTPCCAGlobalMergerComponent::GetComponentID()
  73 {
  74   // see header file for class documentation
  75   return "TPCCAGlobalMerger";
  76 }
  77
  78 void AliHLTTPCCAGlobalMergerComponent::GetInputDataTypes( AliHLTComponentDataTypeList &list )
  79 {
  80   // see header file for class documentation
  81   list.clear();
  82   list.push_back( AliHLTTPCCADefinitions::fgkTrackletsDataType );
  83   //list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
  84   //list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
  85 }
  86
  87 AliHLTComponentDataType AliHLTTPCCAGlobalMergerComponent::GetOutputDataType()
  88 {
  89   // see header file for class documentation
  90   return AliHLTTPCDefinitions::fgkTracksDataType;
  91 }
  92
  93 void AliHLTTPCCAGlobalMergerComponent::GetOutputDataSize( unsigned long &constBase, double &inputMultiplier )
  94 {
  95   // see header file for class documentation
  96   // XXX TODO: Find more realistic values.
  97   constBase = 0;
  98   inputMultiplier = 1.0;
  99 }
 100
 101 AliHLTComponent *AliHLTTPCCAGlobalMergerComponent::Spawn()
 102 {
 103   // see header file for class documentation
 104   return new AliHLTTPCCAGlobalMergerComponent;
 105 }
 106
 107 int AliHLTTPCCAGlobalMergerComponent::DoInit( int argc, const char** argv )
 108 {
 109   // see header file for class documentation
 110   if ( fGlobalMerger ) {
 111     return EINPROGRESS;
 112   }
 113
 114   // Initialize the merger
 115
 116   fGlobalMerger = new AliHLTTPCCAMerger();
 117
 118   AliHLTTPCCAParam param;
 119
 120   {
 121     // get gemetry
 122     Int_t iSec = 0;
 123     Float_t inRmin = 83.65;
 124     Float_t outRmax = 247.7;
 125     Float_t plusZmin = 0.0529937;
 126     Float_t plusZmax = 249.778;
 127     Float_t minusZmin = -249.645;
 128     Float_t minusZmax = -0.0799937;
 129     Float_t dalpha = 0.349066;
 130     Float_t alpha = 0.174533 + dalpha*iSec;
 131     Bool_t zPlus = (iSec<18 );
 132     Float_t zMin =  zPlus ?plusZmin :minusZmin;
 133     Float_t zMax =  zPlus ?plusZmax :minusZmax;
 134     Int_t nRows = AliHLTTPCTransform::GetNRows();
 135     Float_t padPitch = 0.4;
 136     Float_t sigmaZ = 0.228808;
 137     Float_t *rowX = new Float_t [nRows];
 138     for( Int_t irow=0; irow<nRows; irow++){
 139       rowX[irow] = AliHLTTPCTransform::Row2X( irow );
 140     }
 141
 142     param.Initialize( iSec, nRows, rowX, alpha, dalpha,
 143                       inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
 144     delete[] rowX;
 145   }
 146
 147
 148   fGlobalMerger->SetSliceParam( param );
 149
 150   Int_t iResult = 0;
 151
 152   TString arguments="";
 153   for (int i=0; i<argc; i++) {
 154     TString argument=argv[i];
 155     if (!arguments.IsNull()) arguments+=" ";
 156     arguments+=argument;
 157   }
 158   if (!arguments.IsNull()) {
 159     iResult=Configure(arguments.Data());
 160   } else {
 161     iResult=Reconfigure(NULL, NULL);
 162   }
 163   return iResult;
 164 }
 165
 166 int AliHLTTPCCAGlobalMergerComponent::DoDeinit()
 167 {
 168   // see header file for class documentation
 169   delete fGlobalMerger;
 170   fGlobalMerger = 0;
 171
 172   return 0;
 173 }
 174
 175 int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &evtData,
 176                                                const AliHLTComponentBlockData *blocks, AliHLTComponentTriggerData &/*trigData*/,
 177     AliHLTUInt8_t *outputPtr, AliHLTUInt32_t &size, AliHLTComponentBlockDataList &outputBlocks )
 178 {
 179   // see header file for class documentation
 180   int iResult = 0;
 181   UInt_t maxBufferSize = size;
 182
 183   size = 0;
 184
 185   if ( !outputPtr ) {
 186       return -ENOSPC;
 187   }
 188   if ( !IsDataEvent() ) {
 189     return 0;
 190   }
 191
 192   fGlobalMerger->Clear();
 193
 194   const AliHLTComponentBlockData *const blocksEnd = blocks + evtData.fBlockCnt;
 195   for ( const AliHLTComponentBlockData *block = blocks; block < blocksEnd; ++block ) {
 196     if ( block->fDataType != AliHLTTPCCADefinitions::fgkTrackletsDataType ) {
 197       continue;
 198     }
 199
 200     int slice = AliHLTTPCDefinitions::GetMinSliceNr( *block );
 201     if ( slice < 0 || slice >= AliHLTTPCTransform::GetNSlice() ) {
 202       HLTError( "invalid slice number %d extracted from specification 0x%08lx,  skipping block of type %s",
 203           slice, block->fSpecification, DataType2Text(block->fDataType).c_str() );
 204       // just remember the error, if there are other valid blocks ignore the error, return code otherwise
 205       iResult = -EBADF;
 206       continue;
 207     }
 208
 209     if ( slice != AliHLTTPCDefinitions::GetMaxSliceNr( *block ) ) {
 210       // the code was not written for/ never used with multiple slices in one data block/ specification
 211       HLTWarning("specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code",
 212           block->fSpecification, DataType2Text(block->fDataType).c_str());
 213     }
 214     AliHLTTPCCASliceOutput *sliceOut =  reinterpret_cast<AliHLTTPCCASliceOutput *>( block->fPtr );
 215     sliceOut->SetPointers();
 216     fGlobalMerger->SetSliceData( slice, sliceOut );
 217   }
 218   fGlobalMerger->Reconstruct();
 219
 220   const AliHLTTPCCAMergerOutput *mergerOutput = fGlobalMerger->Output();
 221
 222
 223   // Fill output tracks
 224
 225   UInt_t mySize = 0;
 226
 227   {
 228     // check if there was enough space in the output buffer
 229
 230     Int_t nTracks = mergerOutput->NTracks();
 231
 232     AliHLTTPCTrackArray array( nTracks );
 233
 234     Int_t nClusters=0;
 235     for( Int_t itr=0; itr<nTracks; itr++){
 236
 237       // convert AliHLTTPCCAMergedTrack to AliHLTTPCTrack
 238
 239       const AliHLTTPCCAMergedTrack &track = mergerOutput->Track( itr );
 240       AliHLTTPCTrack out;
 241
 242       // first convert to AliExternalTrackParam ( Kappa to Pt )
 243
 244       AliExternalTrackParam tp, tpEnd;
 245       AliHLTTPCCATrackConvertor::GetExtParam( track.InnerParam(), tp, 0 );
 246       AliHLTTPCCATrackConvertor::GetExtParam( track.OuterParam(), tpEnd, 0 );
 247
 248       // set parameters, with rotation to global coordinates
 249
 250       out.SetCharge((Int_t ) tp.GetSign());
 251       out.SetPt( TMath::Abs(tp.GetSignedPt()) );
 252       out.SetPsi( fmod( TMath::ASin( tp.GetSnp() ) + track.InnerAlpha() ,2*TMath::Pi() ) );
 253       out.SetTgl( tp.GetTgl() );
 254       {
 255         Float_t sinA = TMath::Sin( track.InnerAlpha() );
 256         Float_t cosA = TMath::Cos( track.InnerAlpha() );
 257
 258         out.SetFirstPoint( tp.GetX()*cosA - tp.GetY()*sinA,
 259                            tp.GetX()*sinA + tp.GetY()*cosA,
 260                            tp.GetZ() );
 261       }
 262
 263       {
 264         Float_t sinA = TMath::Sin( track.OuterAlpha() );
 265         Float_t cosA = TMath::Cos( track.OuterAlpha() );
 266
 267         out.SetLastPoint( tpEnd.GetX()*cosA - tpEnd.GetY()*sinA,
 268                           tpEnd.GetX()*sinA + tpEnd.GetY()*cosA,
 269                           tpEnd.GetZ() );
 270       }
 271
 272       // set parameter errors w/o rotation, as it is done in AliHLTTPCTrackArray
 273
 274       out.SetY0err(tp.GetSigmaY2());
 275       out.SetZ0err(tp.GetSigmaZ2());
 276       Float_t h = -out.GetPt()*out.GetPt();
 277       out.SetPterr( h*h*tp.GetSigma1Pt2() );
 278       h = 1./TMath::Sqrt(1-out.GetSnp()*out.GetSnp());
 279       out.SetPsierr(h*h*tp.GetSigmaSnp2());
 280       out.SetTglerr(tp.GetSigmaTgl2());
 281
 282       // set cluster ID's
 283
 284       UInt_t hitID[1000];
 285       for( Int_t i=0; i<track.NClusters(); i++ ) hitID[i] = mergerOutput->ClusterIDsrc(track.FirstClusterRef()+i);
 286
 287       out.SetNHits( track.NClusters() );
 288       out.SetHits( track.NClusters(), hitID );
 289
 290       out.SetSector(-1);
 291       out.CalculateHelix();
 292       if( !out.CheckConsistency() )  *(array.NextTrack()) = out;
 293       nClusters+=track.NClusters();
 294     }
 295
 296
 297     if ( sizeof(AliHLTTPCTrackletData) + nTracks*sizeof(AliHLTTPCTrackSegmentData) + nClusters*sizeof(UInt_t)
 298          > maxBufferSize ){
 299       iResult = -ENOSPC;
 300     } else {
 301       AliHLTTPCTrackletData *outPtr = (AliHLTTPCTrackletData*)(outputPtr);
 302       UInt_t nOutTracks = 0;
 303       mySize = array.WriteTracks( nOutTracks, outPtr->fTracklets );
 304       mySize += sizeof(AliHLTTPCTrackletData);
 305       outPtr->fTrackletCnt = nOutTracks;
 306     }
 307   }
 308
 309   AliHLTComponentBlockData resultData;
 310   FillBlockData( resultData );
 311   resultData.fOffset = 0;
 312   resultData.fSize = mySize;
 313   resultData.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( 0, 35, 0, 5 );
 314   outputBlocks.push_back( resultData );
 315   size = resultData.fSize;
 316
 317   //HLTWarning("CAGlobalMerger:: output %d tracks",mergerOutput->NTracks());
 318
 319   return iResult;
 320 }
 321
 322
 323
 324 Int_t AliHLTTPCCAGlobalMergerComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
 325 {
 326   // see header file for class documentation
 327
 328
 329   HLTWarning("TODO: dummy Reconfigure() method" );
 330   return 0;
 331   /*
 332
 333   Int_t iResult=0;
 334   const char* pathBField=kAliHLTCDBSolenoidBz;
 335
 336   if (pathBField) {
 337     HLTInfo("reconfigure B-Field from entry %s, chain id %s", pathBField,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
 338     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField);//,GetRunNo());
 339     if (pEntry) {
 340       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
 341       if (pString) {
 342         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
 343         iResult=Configure(pString->GetString().Data());
 344       } else {
 345         HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField);
 346       }
 347     } else {
 348       HLTError("cannot fetch object \"%s\" from CDB", pathBField);
 349     }
 350   }
 351   return iResult;
 352 */
 353 }
 354
 355
 356 Int_t AliHLTTPCCAGlobalMergerComponent::Configure( const char* arguments )
 357 {
 358   //* Set parameters
 359
 360   Int_t iResult=0;
 361   if (!arguments) return iResult;
 362
 363   TString allArgs=arguments;
 364   TString argument;
 365   Int_t bMissingParam=0;
 366
 367   TObjArray* pTokens=allArgs.Tokenize(" ");
 368
 369   Int_t nArgs =  pTokens ?pTokens->GetEntries() :0;
 370
 371   for (int i=0; i<nArgs; i++ ){
 372     argument=((TObjString*)pTokens->At(i))->GetString();
 373     if (argument.IsNull()){
 374     }
 375     else if (argument.CompareTo("-solenoidBz")==0 ){
 376       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 377       fSolenoidBz = ((TObjString*)pTokens->At(i))->GetString().Atof();
 378       HLTInfo("Magnetic Field set to: %f", fSolenoidBz );
 379     }
 380     else {
 381       HLTError("Unknown option %s ", argument.Data());
 382       iResult=-EINVAL;
 383     }
 384   }
 385   delete pTokens;
 386
 387   if (bMissingParam) {
 388     HLTError("Specifier missed for %s", argument.Data());
 389     iResult=-EINVAL;
 390   }
 391
 392   return iResult;
 393 }
 394