TRD online reco update (Theodor)
[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDClusterizerComponent.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   AliHLTTRDClusterizerComponent.cxx
20     @author 
21     @date   
22     @brief  A TRDClusterizer processing component for the HLT. 
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 "TTree.h"
36 #include "TFile.h"
37 #include "TBranch.h"
38
39 #include "AliHLTTRDClusterizerComponent.h"
40 #include "AliHLTTRDDefinitions.h"
41 #include "AliHLTTRDCluster.h"
42
43 #include "AliGeomManager.h"
44 #include "AliTRDReconstructor.h"
45 #include "AliCDBManager.h"
46 #include "AliCDBStorage.h"
47 #include "AliCDBEntry.h"
48 #include "AliHLTTRDClusterizer.h"
49 #include "AliTRDrecoParam.h"
50 #include "AliTRDrawStreamBase.h"
51 #include "AliTRDcluster.h"
52
53 #include "AliRawReaderMemory.h"
54
55 #ifdef HAVE_VALGRIND_CALLGRIND_H
56 #include <valgrind/callgrind.h>
57 #else
58 #define CALLGRIND_START_INSTRUMENTATION do { } while (0)
59 #define CALLGRIND_STOP_INSTRUMENTATION do { } while (0)
60 #endif
61
62 #include <cstdlib>
63 #include <cerrno>
64 #include <string>
65
66 #include "AliTRDrawStream.h"
67 #include "AliTRDrawFastStream.h"
68
69 ClassImp(AliHLTTRDClusterizerComponent)
70    
71 AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent()
72 : AliHLTProcessor(),
73   fOutputPercentage(500),
74   fOutputConst(0),
75   fClusterizer(NULL),
76   fRecoParam(NULL),
77   fMemReader(NULL),
78   fReconstructor(NULL),
79   fRecoParamType(-1),
80   fRecoDataType(-1),
81   fRawDataVersion(2),
82   fyPosMethod(1),
83   fgeometryFileName(""),
84   fProcessTracklets(kFALSE),
85   fHLTstreamer(kTRUE),
86   fTC(kFALSE)
87 {
88   // Default constructor
89
90 }
91
92 AliHLTTRDClusterizerComponent::~AliHLTTRDClusterizerComponent()
93 {
94   // Destructor
95   // Work is Done in DoDeInit()
96 }
97
98
99 const char* AliHLTTRDClusterizerComponent::GetComponentID()
100 {
101   // Return the component ID const char *
102   return "TRDClusterizer"; // The ID of this component
103 }
104
105 void AliHLTTRDClusterizerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
106 {
107   // Get the list of input data
108   list.clear(); // We do not have any requirements for our input data type(s).
109   list.push_back(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
110 }
111
112 AliHLTComponentDataType AliHLTTRDClusterizerComponent::GetOutputDataType()
113 {
114   // Get the output data type
115   return kAliHLTMultipleDataType;
116 }
117
118 int AliHLTTRDClusterizerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
119 {
120   // Get the output data type
121   tgtList.clear();
122   tgtList.push_back(AliHLTTRDDefinitions::fgkClusterDataType);
123   tgtList.push_back(AliHLTTRDDefinitions::fgkMCMtrackletDataType);
124   return tgtList.size();
125 }
126
127
128 void AliHLTTRDClusterizerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
129 {
130   // Get the output data size
131   constBase = fOutputConst;
132   inputMultiplier = ((double)fOutputPercentage)/100.0;
133 }
134
135 AliHLTComponent* AliHLTTRDClusterizerComponent::Spawn()
136 {
137   // Spawn function, return new instance of this class
138   return new AliHLTTRDClusterizerComponent;
139 };
140
141 int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
142 {
143   // perform initialization. We check whether our relative output size is specified in the arguments.
144   int iResult=0;
145   
146   fReconstructor = new AliTRDReconstructor();
147   HLTDebug("TRDReconstructor at 0x%x", fReconstructor);
148
149   TString configuration="";
150   TString argument="";
151   for (int i=0; i<argc && iResult>=0; i++) {
152     argument=argv[i];
153     if (!configuration.IsNull()) configuration+=" ";
154     configuration+=argument;
155   }
156
157   if (!configuration.IsNull()) {
158     iResult=Configure(configuration.Data());
159   } else {
160     iResult=Reconfigure(NULL, NULL);
161   }
162
163   if(!fClusterizer){
164     HLTFatal("Clusterizer was not initialized!");
165     return -1;
166   }
167
168   if(iResult<0) return iResult;
169
170   fMemReader = new AliRawReaderMemory;
171   fClusterizer->SetReconstructor(fReconstructor);
172   fClusterizer->SetUseLabels(kFALSE);
173
174   if(fReconstructor->IsProcessingTracklets())
175     fOutputConst = fClusterizer->GetTrMemBlockSize();
176
177   return iResult;
178 }
179
180 int AliHLTTRDClusterizerComponent::DoDeinit()
181 {
182   // Deinitialization of the component
183   delete fMemReader;
184   fMemReader = 0;
185   delete fClusterizer;
186   fClusterizer = 0;
187   
188   fReconstructor->SetClusters(0x0);
189   delete fReconstructor;
190   fReconstructor = 0x0;
191   return 0;
192
193   if (fRecoParam)
194     {
195       HLTDebug("Deleting fRecoParam");
196       delete fRecoParam;
197       fRecoParam = 0;
198     }
199 }
200
201 int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtData, 
202                                             const AliHLTComponentBlockData* blocks, 
203                                             AliHLTComponent_TriggerData& /*trigData*/, 
204                                             AliHLTUInt8_t* outputPtr, 
205                                             AliHLTUInt32_t& size, 
206                                             vector<AliHLTComponent_BlockData>& outputBlocks )
207 {
208   // Process an event
209
210   if (evtData.fEventID == 1)
211     CALLGRIND_START_INSTRUMENTATION;
212
213   HLTDebug( "NofBlocks %i", evtData.fBlockCnt );
214   // Process an event
215   AliHLTUInt32_t totalSize = 0, offset = 0;
216
217   //implement a usage of the following
218   //   AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
219   //   AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
220   //   void *triggerData = trigData.fData;
221   //HLTDebug( "Trigger data received. Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);
222
223   // Loop over all input blocks in the event
224   AliHLTComponentDataType expectedDataType = (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
225   for ( UInt_t iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ )
226     {      
227       const AliHLTComponentBlockData &block = blocks[iBlock];
228       // lets not use the internal TRD data types here : AliHLTTRDDefinitions::fgkDDLRawDataType
229       // which is depreciated - we use HLT global defs instead
230       //      if ( block.fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD) )
231       AliHLTComponentDataType inputDataType = block.fDataType;
232       if ( inputDataType != expectedDataType)
233         {
234           HLTDebug( "Block # %i/%i; Event 0x%08LX (%Lu) Wrong received datatype: %s - required datatype: %s; Skipping",
235                     iBlock, evtData.fBlockCnt,
236                     evtData.fEventID, evtData.fEventID, 
237                     DataType2Text(inputDataType).c_str(), 
238                     DataType2Text(expectedDataType).c_str());
239           continue;
240         }
241       else 
242         {
243           HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s; Block Size: %i",
244                    iBlock, evtData.fBlockCnt,
245                    evtData.fEventID, evtData.fEventID, 
246                    DataType2Text(inputDataType).c_str(),
247                    block.fSize);
248         }
249       
250 #ifndef NDEBUG
251       unsigned long constBase;
252       double inputMultiplier;
253       GetOutputDataSize(constBase,inputMultiplier);
254       if(size<(constBase+block.fSize*inputMultiplier)){
255         HLTWarning("Memory Block given might be too small: %i < %i; Event %Lu", size, constBase+block.fSize*inputMultiplier, evtData.fEventID);
256       }
257 #endif
258
259       // fMemReader->Reset();
260       fMemReader->SetMemory((UChar_t*) block.fPtr, block.fSize);
261
262       AliHLTUInt32_t spec = block.fSpecification;
263       
264       Int_t id = 1024;
265       
266       for ( Int_t ii = 0; ii < 18 ; ii++ ) {
267         if ( spec & 0x1 ) {
268           id += ii;
269           break;
270         }
271         spec = spec >> 1 ;
272       }
273
274       fMemReader->SetEquipmentID( id ); 
275       
276       fClusterizer->SetMemBlock(outputPtr+offset);
277       Bool_t bclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
278       if(bclustered)
279         {
280           HLTDebug("Clustered successfully");
281         }
282       else
283         {
284           HLTError("Clustering ERROR");
285           return -1;
286         }
287
288       AliHLTUInt32_t addedSize;
289       if(fReconstructor->IsProcessingTracklets()){
290         addedSize = fClusterizer->GetAddedTrSize();
291         totalSize += fClusterizer->GetTrMemBlockSize();  //if IsProcessingTracklets() is enabled we always reserve a data block of size GetTrMemBlockSize() for the tracklets
292         if (addedSize > 0){
293           // Using low-level interface 
294           // with interface classes
295           if ( totalSize > size )
296             {
297               HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
298                        totalSize, size );
299               return EMSGSIZE;
300             }
301
302           // Fill block 
303           AliHLTComponentBlockData bd;
304           FillBlockData( bd );
305           bd.fOffset = offset;
306           bd.fSize = addedSize;
307           bd.fSpecification = block.fSpecification;
308           bd.fDataType = AliHLTTRDDefinitions::fgkMCMtrackletDataType;
309           outputBlocks.push_back( bd );
310           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(), spec);
311         }
312         offset = totalSize;
313       }
314
315       addedSize = fClusterizer->GetAddedClSize();
316       if (addedSize > 0){
317         
318         Int_t* nTimeBins = (Int_t*)(outputPtr+offset+fClusterizer->GetAddedClSize());
319         *nTimeBins = fClusterizer->GetNTimeBins();
320         addedSize += sizeof(*nTimeBins);
321
322         totalSize += addedSize;
323         if ( totalSize > size )
324           {
325             HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
326                      totalSize, size );
327             return EMSGSIZE;
328           }
329
330         // Fill block 
331         AliHLTComponentBlockData bd;
332         FillBlockData( bd );
333         bd.fOffset = offset;
334         bd.fSize = addedSize;
335         bd.fSpecification = block.fSpecification;
336         bd.fDataType = AliHLTTRDDefinitions::fgkClusterDataType;
337         outputBlocks.push_back( bd );
338         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(), spec);
339         offset = totalSize;
340       }
341       else{
342         HLTDebug("Array of clusters is empty!");
343       }
344     }
345   fReconstructor->SetClusters(0x0);
346
347   size = totalSize;
348   HLTDebug("Event is done. size written to the output is %i", size);
349   return 0;
350 }
351
352 void AliHLTTRDClusterizerComponent::PrintObject( TClonesArray* inClustersArray)
353 {
354   AliTRDcluster* cluster=0x0;
355   
356   for (Int_t i=0; i < inClustersArray->GetEntriesFast(); i++){
357     cluster = dynamic_cast<AliTRDcluster*>(inClustersArray->At(i));
358     HLTDebug("cluster[%i]",i);
359     HLTDebug("  PadCol = %i; PadRow = %i; PadTime = %i", cluster->GetPadCol(), cluster->GetPadRow(), cluster->GetPadTime());
360     HLTDebug("  Detector = %i, Amplitude = %f, Center = %f", cluster->GetDetector(), cluster->GetQ(), cluster->GetCenter());
361     HLTDebug("  LocalTimeBin =  %i; NPads = %i; maskedPosition: %s, status: %s", cluster->GetLocalTimeBin(), cluster->GetNPads(),cluster->GetPadMaskedPosition(),cluster->GetPadMaskedPosition());
362   }
363   
364 }
365
366 int AliHLTTRDClusterizerComponent::Configure(const char* arguments){
367   int iResult=0;
368   if (!arguments) return iResult;
369   
370   TString allArgs=arguments;
371   TString argument;
372   int bMissingParam=0;
373
374   TObjArray* pTokens=allArgs.Tokenize(" ");
375   if (pTokens) {
376     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
377       argument=((TObjString*)pTokens->At(i))->GetString();
378       if (argument.IsNull()) continue;
379       
380       if (argument.CompareTo("output_percentage")==0) {
381         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
382         HLTInfo("Setting output percentage to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
383         fOutputPercentage=((TObjString*)pTokens->At(i))->GetString().Atoi();
384         continue;
385       } 
386       else if (argument.CompareTo("-geometry")==0) {
387         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
388         HLTInfo("Setting geometry to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
389         fgeometryFileName=((TObjString*)pTokens->At(i))->GetString();
390         continue;
391       } 
392       else if (argument.CompareTo("-lowflux")==0) {
393         fRecoParamType = 0;
394         HLTInfo("Low flux reconstruction selected");
395         continue;
396       }
397       else if (argument.CompareTo("-highflux")==0) {
398         fRecoParamType = 1;
399         HLTInfo("High flux reconstruction selected");
400         continue;
401       }
402       else if (argument.CompareTo("-cosmics")==0) {
403         fRecoParamType = 2;
404         HLTInfo("Cosmics reconstruction selected");
405         continue;
406       }
407       else if (argument.CompareTo("-simulation")==0) {
408         fRecoDataType = 0;
409         HLTInfo("Awaiting simulated data");
410         continue;
411       }
412       else if (argument.CompareTo("-experiment")==0) {
413         fRecoDataType = 1;
414         HLTInfo("Awaiting real data");
415         continue;
416       }
417       else if (argument.CompareTo("-processTracklets")==0) {
418         fProcessTracklets = kTRUE;
419         HLTInfo("Writing L1 tracklets to output");
420         continue;
421       }
422       else if (argument.CompareTo("-noZS")==0) {
423         fOutputPercentage = 100;
424         HLTInfo("Awaiting non zero surpressed data");
425         continue;
426       }
427       else if (argument.CompareTo("-faststreamer")==0) {
428         fHLTstreamer = kTRUE;
429         HLTInfo("Useing fast raw streamer");
430         continue;
431       }
432       else if (argument.CompareTo("-nofaststreamer")==0) {
433         fHLTstreamer = kFALSE;
434         HLTInfo("Don't use fast raw streamer");
435         continue;
436       }
437       else if (argument.CompareTo("-tailcancellation")==0) {
438         fTC = kTRUE;
439         HLTInfo("Useing tailcancellation");
440         continue;
441       }
442       else if (argument.CompareTo("-rawver")==0) {
443         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
444         HLTInfo("Raw data version is: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
445         fRawDataVersion=((TObjString*)pTokens->At(i))->GetString().Atoi();
446         continue;
447       } 
448       else if (argument.CompareTo("-yPosMethod")==0) {
449         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
450         TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
451         if (toCompareTo.CompareTo("COG")==0){
452           HLTInfo("Setting yPosMethod method to: %s", toCompareTo.Data());
453           fyPosMethod=0;
454         }
455         else if (toCompareTo.CompareTo("LUT")==0){
456           HLTInfo("Setting yPosMethod method to: %s", toCompareTo.Data());
457           fyPosMethod=1;
458         }
459         else if (toCompareTo.CompareTo("Gauss")==0){
460           HLTInfo("Setting yPosMethod method to: %s", toCompareTo.Data());
461           fyPosMethod=2;
462         }
463         else {
464           HLTError("unknown argument for yPosMethod: %s", toCompareTo.Data());
465           iResult=-EINVAL;
466           break;
467         }
468         continue;
469       }
470       
471       else {
472         HLTError("unknown argument: %s", argument.Data());
473         iResult=-EINVAL;
474         break;
475       }
476     }
477     delete pTokens;
478   }
479   if (bMissingParam) {
480     HLTError("missing parameter for argument %s", argument.Data());
481     iResult=-EINVAL;
482   }
483   if(iResult>=0){
484     iResult=SetParams();
485   }
486   return iResult;
487 }
488
489 int AliHLTTRDClusterizerComponent::SetParams()
490 {
491   Int_t iResult=0;
492   if(!AliCDBManager::Instance()->IsDefaultStorageSet()){
493     HLTError("DefaultStorage is not set in CDBManager");
494     return -EINVAL;
495   }
496   if(AliCDBManager::Instance()->GetRun()<0){
497     HLTError("Run Number is not set in CDBManager");
498     return -EINVAL;
499   }
500   HLTInfo("CDB default storage: %s; RunNo: %i", (AliCDBManager::Instance()->GetDefaultStorage()->GetBaseFolder()).Data(), AliCDBManager::Instance()->GetRun());
501
502   if(!AliGeomManager::GetGeometry()){
503     if(fgeometryFileName.CompareTo("")==0 || !TFile::Open(fgeometryFileName.Data())){
504       HLTInfo("Loading standard geometry file");
505       AliGeomManager::LoadGeometry();
506     }else{
507       HLTWarning("Loading NON-standard geometry file");
508       AliGeomManager::LoadGeometry(fgeometryFileName.Data());
509     }
510     if(!AliGeomManager::GetGeometry()){
511       HLTError("Could not load geometry");
512       return -EINVAL;
513     }
514   }
515   else{
516     HLTInfo("Geometry Already Loaded!");
517   }
518
519   if (fRecoParamType == 0)
520     {
521       HLTDebug("Low flux params init.");
522       fRecoParam = AliTRDrecoParam::GetLowFluxParam();
523     }
524
525   if (fRecoParamType == 1)
526     {
527       HLTDebug("High flux params init.");
528       fRecoParam = AliTRDrecoParam::GetHighFluxParam();
529     }
530   
531   if (fRecoParamType == 2)
532     {
533       HLTDebug("Cosmic Test params init.");
534       fRecoParam = AliTRDrecoParam::GetCosmicTestParam();
535     }
536
537   if (fRecoParam == 0)
538     {
539       HLTError("No reco params initialized. Sniffing big trouble!");
540       return -EINVAL;
541     }
542
543   // backward compatibility to AliTRDrecoParam < r34995
544 # ifndef HAVE_NOT_ALITRDRECOPARAM_r34995
545 #   define AliTRDRecoParamSetTailCancelation(b) fRecoParam->SetTailCancelation(b)
546 #   define AliTRDRecoParamSetGAUS(b) fRecoParam->SetGAUS(b)
547 #   define AliTRDRecoParamSetLUT(b) fRecoParam->SetLUT(b)
548 # else
549 #   define AliTRDRecoParamSetTailCancelation(b) fRecoParam->SetTailCancelation()
550 #   define AliTRDRecoParamSetGAUS(b) fRecoParam->SetGAUS()
551 #   define AliTRDRecoParamSetLUT(b) fRecoParam->SetLUT()
552 # endif
553
554   if(fTC){AliTRDRecoParamSetTailCancelation(kTRUE); HLTDebug("Enableing Tail Cancelation"); }
555   else{AliTRDRecoParamSetTailCancelation(kFALSE); HLTDebug("Enableing Tail Cancelation"); }
556
557   switch(fyPosMethod){
558   case 0: AliTRDRecoParamSetGAUS(kFALSE); AliTRDRecoParamSetLUT(kFALSE); break;
559   case 1: AliTRDRecoParamSetGAUS(kFALSE); AliTRDRecoParamSetLUT(kTRUE); break;
560   case 2: AliTRDRecoParamSetGAUS(kTRUE); AliTRDRecoParamSetLUT(kFALSE); break;
561   }
562
563   fRecoParam->SetStreamLevel(AliTRDrecoParam::kClusterizer, 0);
564   fReconstructor->SetRecoParam(fRecoParam);
565
566   TString recoOptions="hlt,!cw";
567   if(fProcessTracklets) recoOptions += ",tp";
568   else  recoOptions += ",!tp";
569
570   HLTDebug("Reconstructor options are: %s",recoOptions.Data());
571   fReconstructor->SetOption(recoOptions.Data());
572
573   if (fRecoDataType < 0 || fRecoDataType > 1)
574     {
575       HLTWarning("No data type selected. Use -simulation or -experiment flag. Defaulting to simulation.");
576       fRecoDataType = 0;
577     }
578
579   if (fRecoDataType == 0)
580     {
581       AliTRDrawStreamBase::SetRawStreamVersion(AliTRDrawStreamBase::kTRDsimStream);
582       HLTDebug("Data type expected is SIMULATION!");
583     }
584
585   if (fRecoDataType == 1)
586     {
587       AliTRDrawStreamBase::SetRawStreamVersion(AliTRDrawStreamBase::kTRDrealStream);
588       HLTDebug("Data type expected is EXPERIMENT!");
589     }
590
591   if (fHLTstreamer)
592     {
593       AliTRDrawStreamBase::SetRawStreamVersion("FAST");
594       HLTDebug("fast rawstreamer used");  
595     }
596
597   if(!fClusterizer){
598     fClusterizer = new AliHLTTRDClusterizer("TRDCclusterizer", "TRDCclusterizer");  
599     HLTDebug("TRDClusterizer at 0x%x", fClusterizer);
600   }
601
602   fClusterizer->SetRawVersion(fRawDataVersion);
603
604   return iResult;
605 }
606
607 int AliHLTTRDClusterizerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
608 {
609   // see header file for class documentation
610
611   int iResult=0;
612   const char* path="HLT/ConfigTRD/ClusterizerComponent";
613   const char* defaultNotify="";
614   if (cdbEntry) {
615     path=cdbEntry;
616     defaultNotify=" (default)";
617   }
618   if (path) {
619     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
620     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
621     if (pEntry) {
622       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
623       if (pString) {
624         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
625         iResult=Configure(pString->GetString().Data());
626       } else {
627         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
628       }
629     } else {
630       HLTError("cannot fetch object \"%s\" from CDB", path);
631     }
632   }
633
634   return iResult;
635 }