HLT/TRD/AliHLTTRDTrackerV1Component.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:                                                       *
   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   AliHLTTRDTrackerV1Component.cxx
  20     @author Theodor Rascanu
  21     @date
  22     @brief  A TRDTrackerV1 processing component for the HLT.
  23 */
  24
  25 #if __GNUC__ >= 3
  26 using namespace std;
  27 #endif
  28
  29 #include "AliHLTTRDTrackerV1Component.h"
  30 #include "AliHLTTRDDefinitions.h"
  31 #include "AliHLTTRDTrack.h"
  32 #include "AliHLTTRDUtils.h"
  33
  34 #include "TFile.h"
  35 #include "TChain.h"
  36
  37 #include "AliGeomManager.h"
  38 #include "AliCDBManager.h"
  39 #include "AliCDBStorage.h"
  40 #include "AliCDBEntry.h"
  41 #include "AliESDEvent.h"
  42 #include "AliESDfriend.h"
  43
  44 #include "AliTRDcalibDB.h"
  45 #include "AliTRDReconstructor.h"
  46 #include "AliTRDtrackerV1.h"
  47 #include "AliTRDrecoParam.h"
  48
  49 #include <cstdlib>
  50 #include <cerrno>
  51 #include <string>
  52
  53 ClassImp(AliHLTTRDTrackerV1Component)
  54
  55 void AliHLTTRDTrackerV1Component::AliHLTTRDESDEvent::CreateStdContent()
  56 {
  57   TClonesArray* tracksArray = new TClonesArray("AliESDtrack",0);
  58   tracksArray->SetName(AliESDEvent::fgkESDListName[AliESDEvent::kTracks]);
  59   AddObject(tracksArray);
  60   GetStdContent();
  61 }
  62
  63 void AliHLTTRDTrackerV1Component::AliHLTTRDESDEvent::Streamer(TBuffer &/*R__b*/)
  64 {
  65   AliFatal("class is for internal us only and not for streaming");
  66 }
  67
  68 AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component():
  69   AliHLTProcessor(),
  70   fOutputPercentage(100), // By default we copy to the output exactly what we got as input
  71   fTracker(NULL),
  72   fRecoParam(NULL),
  73   fReconstructor(NULL),
  74   fESD(NULL),
  75   fClusterArray(NULL),
  76   fRecoParamType(-1),
  77   fNtimeBins(-1),
  78   fPIDmethod(1),
  79   fgeometryFileName(""),
  80   fHLTflag(kTRUE),
  81   fOutputV1Tracks(kTRUE),
  82   fHighLevelOutput(kFALSE),
  83   fEmulateHLTTracks(kFALSE),
  84   fImproveTracklets(kFALSE)
  85 {
  86   // Default constructor
  87
  88 }
  89
  90 AliHLTTRDTrackerV1Component::~AliHLTTRDTrackerV1Component()
  91 {
  92   // Destructor
  93 }
  94
  95 const char* AliHLTTRDTrackerV1Component::GetComponentID()
  96 {
  97   // Return the component ID const char *
  98   return "TRDTrackerV1"; // The ID of this component
  99 }
 100
 101 void AliHLTTRDTrackerV1Component::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
 102 {
 103   // Get the list of input data
 104   list.clear(); // We do not have any requirements for our input data type(s).
 105   list.push_back(AliHLTTRDDefinitions::fgkClusterDataType);
 106 }
 107
 108 AliHLTComponentDataType AliHLTTRDTrackerV1Component::GetOutputDataType()
 109 {
 110   // Get the output data type
 111   return kAliHLTMultipleDataType;
 112 }
 113
 114 int AliHLTTRDTrackerV1Component::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
 115 {
 116   // Get the output data types
 117   tgtList.clear();
 118   tgtList.push_back(kAliHLTDataTypeTrack | kAliHLTDataOriginTRD);
 119   tgtList.push_back(AliHLTTRDDefinitions::fgkTracksDataType);
 120   return tgtList.size();
 121 }
 122
 123 void AliHLTTRDTrackerV1Component::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 124 {
 125   // Get the output data size
 126   constBase = 0;
 127   inputMultiplier = fOutputV1Tracks ? 2*((double)fOutputPercentage)/100.0 : 0.5*((double)fOutputPercentage)/100.0;
 128 }
 129
 130 // Spawn function, return new instance of this class
 131 AliHLTComponent* AliHLTTRDTrackerV1Component::Spawn()
 132 {
 133   return new AliHLTTRDTrackerV1Component;
 134 };
 135
 136
 137 int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
 138 {
 139   // perform initialization. We check whether our relative output size is specified in the arguments.
 140   int iResult=0;
 141
 142   fReconstructor = new AliTRDReconstructor();
 143   HLTDebug("TRDReconstructor at 0x%x", fReconstructor);
 144   fESD = new AliHLTTRDESDEvent();
 145   fESD->CreateStdContent();
 146
 147   TString configuration="";
 148   TString argument="";
 149   for (int i=0; i<argc && iResult>=0; i++) {
 150     argument=argv[i];
 151     if (!configuration.IsNull()) configuration+=" ";
 152     configuration+=argument;
 153   }
 154
 155   if (!configuration.IsNull()) {
 156     iResult=Configure(configuration.Data());
 157   } else {
 158     iResult=Reconfigure(NULL, NULL);
 159   }
 160
 161   if(iResult<0) return iResult;
 162
 163   fTracker = new AliTRDtrackerV1();
 164   HLTDebug("TRDTracker at 0x%x", fTracker);
 165   fTracker->SetReconstructor(fReconstructor);
 166
 167   fClusterArray = new TClonesArray("AliTRDcluster"); // would be nice to allocate memory for all clusters here.
 168
 169   return iResult;
 170 }
 171
 172 int AliHLTTRDTrackerV1Component::DoDeinit()
 173 {
 174   // Deinitialization of the component
 175
 176   fTracker->SetClustersOwner(kFALSE);
 177   delete fTracker;
 178   fTracker = NULL;
 179
 180   fClusterArray->Delete();
 181   delete fClusterArray;
 182   fClusterArray = NULL;
 183
 184   // We need to set clusters in Reconstructor to null to prevent from
 185   // double deleting, since we delete TClonesArray by ourself.
 186   fReconstructor->SetClusters(0x0);
 187   delete fReconstructor;
 188   fReconstructor = NULL;
 189   delete fESD;
 190   fESD = NULL;
 191
 192   AliTRDcalibDB::Terminate();
 193
 194   return 0;
 195 }
 196
 197 int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtData,
 198                                           const AliHLTComponentBlockData* blocks,
 199                                           AliHLTComponent_TriggerData& /*trigData*/,
 200                                           AliHLTUInt8_t* outputPtr,
 201                                           AliHLTUInt32_t& size,
 202                                           vector<AliHLTComponent_BlockData>& outputBlocks )
 203 {
 204   // Process an event
 205
 206   HLTDebug("NofBlocks %i", evtData.fBlockCnt );
 207
 208   fESD->Reset();
 209   //fESD->SetMagneticField(GetBz());
 210
 211   AliHLTUInt32_t totalSize = 0, offset = 0;
 212
 213   AliHLTComponentDataType expectedDataType = AliHLTTRDDefinitions::fgkClusterDataType;
 214   for ( unsigned long iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ )
 215     {
 216       const AliHLTComponentBlockData &block = blocks[iBlock];
 217       AliHLTComponentDataType inputDataType = block.fDataType;
 218
 219       if(inputDataType != expectedDataType)
 220         {
 221           HLTDebug( "Block # %i/%i; Event 0x%08LX (%Lu) Wrong received datatype: %s - Skipping",
 222                     iBlock, evtData.fBlockCnt-1,
 223                     evtData.fEventID, evtData.fEventID,
 224                     DataType2Text(inputDataType).c_str());
 225           continue;
 226         }
 227       else {
 228         HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s; Block Size: %i",
 229                  iBlock, evtData.fBlockCnt-1,
 230                  evtData.fEventID, evtData.fEventID,
 231                  DataType2Text(inputDataType).c_str(),
 232                  block.fSize);
 233       }
 234
 235 #ifndef NDEBUG
 236       unsigned long constBase;
 237       double inputMultiplier;
 238       GetOutputDataSize(constBase,inputMultiplier);
 239       if(size<(constBase+block.fSize*inputMultiplier)){
 240         HLTWarning("Memory Block given might be too small: %i < %i; Event %Lu", size, constBase+block.fSize*inputMultiplier, evtData.fEventID);
 241       }
 242 #endif
 243
 244       AliHLTTRDUtils::ReadClusters(fClusterArray, block.fPtr, block.fSize, &fNtimeBins);
 245       HLTDebug("Reading number of time bins from input block. Setting number of timebins to %d", fNtimeBins);
 246       AliTRDtrackerV1::SetNTimeBins(fNtimeBins);
 247
 248       HLTDebug("TClonesArray of clusters: nbEntries = %i", fClusterArray->GetEntriesFast());
 249       fTracker->LoadClusters(fClusterArray);
 250
 251       fTracker->Clusters2Tracks(fESD);
 252
 253       Int_t nTracks = fESD->GetNumberOfTracks();
 254       HLTInfo("Number of tracks  == %d ==", nTracks);
 255
 256       TClonesArray* trdTracks;
 257       trdTracks = fTracker->GetListOfTracks();
 258
 259       if(fHighLevelOutput){
 260         if(fEmulateHLTTracks && trdTracks){
 261           // TClonesArray* oldArr = trdTracks;
 262           trdTracks = new TClonesArray(*trdTracks);
 263           AliHLTTRDUtils::EmulateHLTTracks(trdTracks);
 264           // if(oldArr->At(0)){
 265           //   HLTInfo("Old Track:");
 266           //   ((AliTRDtrackV1*)oldArr->At(0))->Print("a");
 267           //   HLTInfo("\nNew Track:");
 268           //   ((AliTRDtrackV1*)trdTracks->At(0))->Print("a");
 269           // }
 270         }
 271
 272         TObjString strg;
 273         strg.String() += fNtimeBins;
 274         if(trdTracks)
 275         PushBack(trdTracks, AliHLTTRDDefinitions::fgkHiLvlTracksDataType, 0);
 276         else{
 277           TClonesArray temp("AliTRDtrackV1");
 278           PushBack(&temp, AliHLTTRDDefinitions::fgkHiLvlTracksDataType, 0);
 279         }
 280         PushBack(&strg, AliHLTTRDDefinitions::fgkHiLvlTracksDataType, 0);
 281
 282         if(fEmulateHLTTracks && trdTracks){
 283           trdTracks->Delete();
 284           delete trdTracks;
 285         }
 286       }
 287       else if(nTracks>0){
 288         HLTDebug("We have an output ESDEvent: 0x%x with %i tracks", fESD, nTracks);
 289         AliHLTUInt32_t addedSize = AliHLTTRDUtils::AddESDToOutput(fESD, outputPtr+offset);
 290         totalSize += addedSize;
 291
 292         // Fill block
 293         AliHLTComponentBlockData bd;
 294         FillBlockData( bd );
 295         //bd.fPtr = outputPtr;
 296         bd.fOffset = offset;
 297         bd.fSize = addedSize;
 298         bd.fSpecification = block.fSpecification;
 299         bd.fDataType = kAliHLTDataTypeTrack | kAliHLTDataOriginTRD;
 300         outputBlocks.push_back( bd );
 301         HLTDebug("BD ptr 0x%x, offset %i, size %i, datav1Type %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), bd.fSpecification);
 302         offset = totalSize;
 303
 304         if (fOutputV1Tracks && trdTracks){
 305           HLTDebug("We have an output array: pointer to trdTracks = 0x%x, nbEntries = %i", trdTracks, trdTracks->GetEntriesFast());
 306
 307           addedSize = AliHLTTRDUtils::AddTracksToOutput(trdTracks, outputPtr+offset, fNtimeBins);
 308           totalSize += addedSize;
 309
 310           // Fill block
 311           FillBlockData( bd );
 312           //bd.fPtr = outputPtr;
 313           bd.fOffset = offset;
 314           bd.fSize = addedSize;
 315           bd.fSpecification = block.fSpecification;
 316           bd.fDataType = AliHLTTRDDefinitions::fgkTracksDataType;
 317           outputBlocks.push_back( bd );
 318           HLTDebug("BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), bd.fSpecification);
 319           offset = totalSize;
 320         }
 321       }
 322
 323       HLTDebug("totalSize: %i", totalSize);
 324
 325 //       if ( totalSize > allocSize )
 326 //      {
 327 //        HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
 328 //        totalSize, size );
 329 //        return EMSGSIZE;
 330 //      }
 331
 332       //here we are deleting clusters (but not the TClonesArray itself)
 333       fTracker->UnloadClusters();
 334       AliTRDReconstructor::SetClusters(0x0);
 335       fClusterArray->Delete();
 336
 337     }
 338
 339   size = totalSize;
 340   HLTDebug("Event is done. size written to the output is %i", size);
 341   return 0;
 342 }
 343
 344 int AliHLTTRDTrackerV1Component::Configure(const char* arguments){
 345   int iResult=0;
 346   if (!arguments) return iResult;
 347
 348   TString allArgs=arguments;
 349   TString argument;
 350   int bMissingParam=0;
 351
 352   TObjArray* pTokens=allArgs.Tokenize(" ");
 353   if (pTokens) {
 354     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
 355       argument=((TObjString*)pTokens->At(i))->GetString();
 356       if (argument.IsNull()) continue;
 357
 358       if (argument.CompareTo("output_percentage")==0) {
 359         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 360         HLTInfo("Setting output percentage to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 361         fOutputPercentage=((TObjString*)pTokens->At(i))->GetString().Atoi();
 362         continue;
 363       }
 364       else if (argument.CompareTo("-solenoidBz")==0) {
 365         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 366         HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz());
 367         continue;
 368       }
 369       else if (argument.CompareTo("-geometry")==0) {
 370         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 371         HLTInfo("Setting geometry to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 372         fgeometryFileName=((TObjString*)pTokens->At(i))->GetString();
 373         continue;
 374       }
 375       else if (argument.CompareTo("-lowflux")==0) {
 376         fRecoParamType = 0;
 377         HLTInfo("Low flux reconstruction selected");
 378         continue;
 379       }
 380       else if (argument.CompareTo("-highflux")==0) {
 381         fRecoParamType = 1;
 382         HLTInfo("High flux reconstruction selected");
 383         continue;
 384       }
 385       else if (argument.CompareTo("-cosmics")==0) {
 386         fRecoParamType = 2;
 387         HLTInfo("Cosmics reconstruction selected");
 388         continue;
 389       }
 390       else if (argument.CompareTo("-HLTflag")==0) {
 391         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 392         TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
 393         if (toCompareTo.CompareTo("yes")==0){
 394           HLTInfo("Setting HLTflag to: %s", toCompareTo.Data());
 395           fHLTflag=kTRUE;
 396         }
 397         else if (toCompareTo.CompareTo("no")==0){
 398           HLTInfo("Setting HLTflag to: %s", toCompareTo.Data());
 399           fHLTflag=kFALSE;
 400         }
 401         else {
 402           HLTError("unknown argument for HLTflag: %s", toCompareTo.Data());
 403           iResult=-EINVAL;
 404           break;
 405         }
 406         continue;
 407       }
 408       else if (argument.CompareTo("-outputV1Tracks")==0) {
 409         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 410         TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
 411         if (toCompareTo.CompareTo("yes")==0){
 412           HLTInfo("Setting OutputV1Tracks to: %s", toCompareTo.Data());
 413           fOutputV1Tracks=kTRUE;
 414         }
 415         else if (toCompareTo.CompareTo("no")==0){
 416           HLTInfo("Setting OutputV1Tracks to: %s", toCompareTo.Data());
 417           fOutputV1Tracks=kFALSE;
 418         }
 419         else {
 420           HLTError("unknown argument for OutputV1Tracks: %s", toCompareTo.Data());
 421           iResult=-EINVAL;
 422           break;
 423         }
 424         continue;
 425       }
 426       else if (argument.CompareTo("-highLevelOutput")==0) {
 427         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 428         TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
 429         if (toCompareTo.CompareTo("yes")==0){
 430           HLTWarning("Setting highLevelOutput to: %s", toCompareTo.Data());
 431           fHighLevelOutput=kTRUE;
 432         }
 433         else if (toCompareTo.CompareTo("no")==0){
 434           HLTInfo("Setting highLevelOutput to: %s", toCompareTo.Data());
 435           fHighLevelOutput=kFALSE;
 436         }
 437         else {
 438           HLTError("unknown argument for highLevelOutput: %s", toCompareTo.Data());
 439           iResult=-EINVAL;
 440           break;
 441         }
 442         continue;
 443       }
 444       else if (argument.CompareTo("-emulateHLToutput")==0) {
 445         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 446         TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
 447         if (toCompareTo.CompareTo("yes")==0){
 448           HLTWarning("Setting emulateHLToutput to: %s", toCompareTo.Data());
 449           fEmulateHLTTracks=kTRUE;
 450         }
 451         else if (toCompareTo.CompareTo("no")==0){
 452           HLTInfo("Setting emulateHLToutput to: %s", toCompareTo.Data());
 453           fEmulateHLTTracks=kFALSE;
 454         }
 455         else {
 456           HLTError("unknown argument for emulateHLToutput: %s", toCompareTo.Data());
 457           iResult=-EINVAL;
 458           break;
 459         }
 460         continue;
 461       }
 462       else if (argument.CompareTo("-PIDmethod")==0) {
 463         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 464         TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
 465         if (toCompareTo.CompareTo("LH")==0){
 466           HLTInfo("Setting PID method to: %s", toCompareTo.Data());
 467           fPIDmethod=0;
 468         }
 469         else if (toCompareTo.CompareTo("NN")==0){
 470           HLTInfo("Setting PID method to: %s", toCompareTo.Data());
 471           fPIDmethod=1;
 472         }
 473         else if (toCompareTo.CompareTo("TM")==0){
 474           HLTInfo("Setting PID method to: %s", toCompareTo.Data());
 475           fPIDmethod=2;
 476         }
 477         else {
 478           HLTError("unknown argument for PID method: %s", toCompareTo.Data());
 479           iResult=-EINVAL;
 480           break;
 481         }
 482         continue;
 483       }
 484
 485       else {
 486         HLTError("unknown argument: %s", argument.Data());
 487         iResult=-EINVAL;
 488         break;
 489       }
 490     }
 491     delete pTokens;
 492   }
 493   if (bMissingParam) {
 494     HLTError("missing parameter for argument %s", argument.Data());
 495     iResult=-EINVAL;
 496   }
 497   if(iResult>=0){
 498     iResult=SetParams();
 499   }
 500   return iResult;
 501 }
 502
 503 int AliHLTTRDTrackerV1Component::SetParams()
 504 {
 505   Int_t iResult=0;
 506   if(!AliCDBManager::Instance()->IsDefaultStorageSet()){
 507     HLTError("DefaultStorage is not set in CDBManager");
 508     return -EINVAL;
 509   }
 510   if(AliCDBManager::Instance()->GetRun()<0){
 511     HLTError("Run Number is not set in CDBManager");
 512     return -EINVAL;
 513   }
 514   HLTInfo("CDB default storage: %s; RunNo: %i", (AliCDBManager::Instance()->GetDefaultStorage()->GetBaseFolder()).Data(), AliCDBManager::Instance()->GetRun());
 515
 516   if(!AliGeomManager::GetGeometry()){
 517     if(fgeometryFileName.CompareTo("")==0 || !TFile::Open(fgeometryFileName.Data())){
 518       HLTInfo("Loading standard geometry file");
 519       AliGeomManager::LoadGeometry();
 520     }else{
 521       HLTWarning("Loading NON-standard geometry file");
 522       AliGeomManager::LoadGeometry(fgeometryFileName.Data());
 523     }
 524     if(!AliGeomManager::GetGeometry()){
 525       HLTError("Could not load geometry");
 526       return -EINVAL;
 527     }
 528     HLTInfo("Applying Alignment from CDB object");
 529     AliGeomManager::ApplyAlignObjsFromCDB("TRD");
 530   }
 531   else{
 532     HLTInfo("Geometry Already Loaded!");
 533   }
 534
 535   if(fReconstructor->GetRecoParam()){
 536     fRecoParam = new AliTRDrecoParam(*fReconstructor->GetRecoParam());
 537     HLTInfo("RecoParam already set!");
 538   }else{
 539     if(fRecoParamType == 0){
 540       HLTDebug("Low flux params init.");
 541       fRecoParam = AliTRDrecoParam::GetLowFluxParam();
 542     }
 543     if(fRecoParamType == 1){
 544       HLTDebug("High flux params init.");
 545       fRecoParam = AliTRDrecoParam::GetHighFluxParam();
 546     }
 547     if(fRecoParamType == 2){
 548       HLTDebug("Cosmic Test params init.");
 549       fRecoParam = AliTRDrecoParam::GetCosmicTestParam();
 550     }
 551   }
 552
 553   if(!fRecoParam)
 554     {
 555       HLTError("No reco params initialized. Sniffing big trouble!");
 556       return -EINVAL;
 557     }
 558
 559   // backward compatibility to AliTRDrecoParam < r34995
 560 # ifndef HAVE_NOT_ALITRDRECOPARAM_r34995
 561 #   define AliTRDRecoParamSetPIDNeuralNetwork(b) fRecoParam->SetPIDNeuralNetwork(b)
 562 # else
 563 #   define AliTRDRecoParamSetPIDNeuralNetwork(b) fRecoParam->SetPIDNeuralNetwork()
 564 # endif
 565
 566   switch(fPIDmethod){
 567   case 0: AliTRDRecoParamSetPIDNeuralNetwork(kFALSE); break;
 568   case 1: AliTRDRecoParamSetPIDNeuralNetwork(kTRUE); break;
 569   case 2: AliTRDRecoParamSetPIDNeuralNetwork(kFALSE); break;
 570   }
 571
 572   fRecoParam->SetImproveTracklets(fImproveTracklets);
 573
 574   fRecoParam->SetStreamLevel(AliTRDrecoParam::kTracker, 0);
 575   fReconstructor->SetRecoParam(fRecoParam);
 576
 577   TString recoOptions="sa,!cw";
 578
 579   if(fHLTflag)
 580     recoOptions += ",hlt";
 581
 582   HLTDebug("Reconstructor options are: %s",recoOptions.Data());
 583   fReconstructor->SetOption(recoOptions.Data());
 584
 585   return iResult;
 586 }
 587
 588 int AliHLTTRDTrackerV1Component::Reconfigure(const char* cdbEntry, const char* chainId)
 589 {
 590   // see header file for class documentation
 591
 592   int iResult=0;
 593   const char* path="HLT/ConfigTRD/TrackerV1Component";
 594   const char* defaultNotify="";
 595   if (cdbEntry) {
 596     path=cdbEntry;
 597     defaultNotify=" (default)";
 598   }
 599   if (path) {
 600     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
 601     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 602     if (pEntry) {
 603       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
 604       if (pString) {
 605         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
 606         iResult=Configure(pString->GetString().Data());
 607       } else {
 608         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
 609       }
 610     } else {
 611       HLTError("cannot fetch object \"%s\" from CDB", path);
 612     }
 613   }
 614
 615   return iResult;
 616
 617 }
 618
 619 int AliHLTTRDTrackerV1Component::ReadPreprocessorValues(const char* modules)
 620 {
 621   // see header file for class documentation
 622
 623   int iResult = 0;
 624   TString str(modules);
 625   if(str.Contains("HLT") || str.Contains("TRD") || str.Contains("GRP")){
 626
 627   }
 628   return iResult;
 629 }