HLT/TPCLib/AliHLTTPCHistogramHandlerComponent.cxx

   1 // $Id$
   2 //**************************************************************************
   3 //* This file is property of and copyright by the ALICE HLT Project        *
   4 //* ALICE Experiment at CERN, All rights reserved.                         *
   5 //*                                                                        *
   6 //* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *
   7 //*                  for The ALICE HLT Project.                            *
   8 //*                                                                        *
   9 //* Permission to use, copy, modify and distribute this software and its   *
  10 //* documentation strictly for non-commercial purposes is hereby granted   *
  11 //* without fee, provided that the above copyright notice appears in all   *
  12 //* copies and that both the copyright notice and this permission notice   *
  13 //* appear in the supporting documentation. The authors make no claims     *
  14 //* about the suitability of this software for any purpose. It is          *
  15 //* provided "as is" without express or implied warranty.                  *
  16 //**************************************************************************
  17
  18 /** @file   AliHLTTPCHistogramHandlerComponent.cxx
  19     @author Kalliopi Kanaki
  20     @date
  21     @brief  The Histogram Handler component
  22 */
  23
  24 #if __GNUC__>= 3
  25 using namespace std;
  26 #endif
  27 #include "AliHLTTPCHistogramHandlerComponent.h"
  28 #include "AliHLTTPCDefinitions.h"
  29 #include "AliCDBEntry.h"
  30 #include "AliCDBManager.h"
  31 #include "AliHLTTPCTransform.h"
  32
  33 #include <cstdlib>
  34 #include <cerrno>
  35 #include "TString.h"
  36 #include "TFile.h"
  37 #include "TObjArray.h"
  38 #include "TObjString.h"
  39 #include <sys/time.h>
  40 #include "TH1.h"
  41 #include "TH2.h"
  42 #include "TLine.h"
  43 #include "TMath.h"
  44
  45 ClassImp(AliHLTTPCHistogramHandlerComponent) //ROOT macro for the implementation of ROOT specific class methods
  46
  47   AliHLTTPCHistogramHandlerComponent::AliHLTTPCHistogramHandlerComponent()
  48     :
  49     fSpecification(0),
  50     fNoiseHistograms(0),
  51     fKryptonHistograms(0),
  52     fUseGeneral(kFALSE),
  53     fIgnoreSpecification(kFALSE),
  54     fSlice(-99),
  55
  56     fHistTH1Tmp(NULL),
  57     fTotalClusterChargeIROCAll(NULL),
  58     fTotalClusterChargeOROCAll(NULL),
  59     fQMaxPartitionAll(NULL),
  60     fPlotQmaxROCAll(NULL),
  61     fNumberOfClusters(NULL),
  62
  63     fHistTH2Tmp(NULL),
  64     fHistTPCSideAmax(NULL),
  65     fHistTPCSideCmax(NULL),
  66     fHistTPCSideAtot(NULL),
  67     fHistTPCSideCtot(NULL),
  68     fHistTPCSideArms(NULL),
  69     fHistTPCSideCrms(NULL),
  70
  71     fHistogramData()
  72 {
  73   // see header file for class documentation
  74   // or
  75   // refer to README to build package
  76   // or
  77   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  78 }
  79
  80 AliHLTTPCHistogramHandlerComponent::~AliHLTTPCHistogramHandlerComponent() {
  81   // see header file for class documentation
  82
  83 }
  84
  85 // Public functions to implement AliHLTComponent's interface.
  86 // These functions are required for the registration process
  87
  88 const char* AliHLTTPCHistogramHandlerComponent::GetComponentID() {
  89   // see header file for class documentation
  90
  91   return "TPCHistogramHandler";
  92 }
  93
  94 void AliHLTTPCHistogramHandlerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
  95   // see header file for class documentation
  96
  97   list.clear();
  98   list.push_back( kAliHLTDataTypeHistogram );
  99 }
 100
 101 AliHLTComponentDataType AliHLTTPCHistogramHandlerComponent::GetOutputDataType() {
 102   // see header file for class documentation
 103
 104   return kAliHLTDataTypeHistogram;
 105 }
 106
 107 int AliHLTTPCHistogramHandlerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) {
 108   // see header file for class documentation
 109
 110   tgtList.clear();
 111   tgtList.push_back(kAliHLTDataTypeHistogram);
 112   return tgtList.size();
 113 }
 114
 115 void AliHLTTPCHistogramHandlerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
 116   // see header file for class documentation
 117
 118   constBase=0;
 119   inputMultiplier=2.0;
 120 }
 121
 122 AliHLTComponent* AliHLTTPCHistogramHandlerComponent::Spawn() {
 123   // see header file for class documentation
 124
 125   return new AliHLTTPCHistogramHandlerComponent();
 126 }
 127
 128 int AliHLTTPCHistogramHandlerComponent::DoInit( int argc, const char** argv ) {
 129   // see header file for class documentation
 130
 131   //Int_t i = 0;
 132   //Char_t* cpErr;
 133
 134   int iResult=0;
 135
 136   TString configuration="";
 137   TString argument="";
 138   for (int j=0; j<argc && iResult>=0; j++) {
 139
 140     argument=argv[j];
 141     if (!configuration.IsNull()) configuration+=" ";
 142     configuration+=argument;
 143   }
 144
 145   if (!configuration.IsNull()) {
 146     iResult=Configure(configuration.Data());
 147   } else {
 148     iResult=Reconfigure(NULL, NULL);
 149   }
 150
 151   if(fUseGeneral == kFALSE){
 152     fHistTPCSideAmax = new TH2F("fHistTPCSideAmax","TPC side A (max signal)",250,-250,250,250,-250,250);
 153     fHistTPCSideAmax->SetXTitle("global X (cm)"); fHistTPCSideAmax->SetYTitle("global Y (cm)");
 154     fHistTPCSideCmax = new TH2F("fHistTPCSideCmax","TPC side C (max signal)",250,-250,250,250,-250,250);
 155     fHistTPCSideCmax->SetXTitle("global X (cm)"); fHistTPCSideCmax->SetYTitle("global Y (cm)");
 156
 157     fHistTPCSideAtot = new TH2F("fHistTPCSideAtot","TPC side A (total signal)",250,-250,250,250,-250,250);
 158     fHistTPCSideAtot->SetXTitle("global X (cm)"); fHistTPCSideAtot->SetYTitle("global Y (cm)");
 159     fHistTPCSideCtot = new TH2F("fHistTPCSideCtot","TPC side C (total signal)",250,-250,250,250,-250,250);
 160     fHistTPCSideCtot->SetXTitle("global X (cm)"); fHistTPCSideCtot->SetYTitle("global Y (cm)");
 161
 162     fHistTPCSideArms = new TH2F("fHistTPCSideArms","TPC side A (baseline RMS)",250,-250,250,250,-250,250);
 163     fHistTPCSideArms->SetXTitle("global X (cm)"); fHistTPCSideArms->SetYTitle("global Y (cm)");
 164     fHistTPCSideCrms = new TH2F("fHistTPCSideCrms","TPC side C (baseline RMS)",250,-250,250,250,-250,250);
 165     fHistTPCSideCrms->SetXTitle("global X (cm)"); fHistTPCSideCrms->SetYTitle("global Y (cm)");
 166   }
 167   return 0;
 168 } // end DoInit()
 169
 170 int AliHLTTPCHistogramHandlerComponent::DoDeinit() {
 171   // see header file for class documentation
 172
 173   if(fHistTPCSideAmax){ delete fHistTPCSideAmax; fHistTPCSideAmax=NULL; }
 174   if(fHistTPCSideCmax){ delete fHistTPCSideCmax; fHistTPCSideCmax=NULL; }
 175
 176   if(fHistTPCSideAtot){ delete fHistTPCSideAtot; fHistTPCSideAtot=NULL; }
 177   if(fHistTPCSideCtot){ delete fHistTPCSideCtot; fHistTPCSideCtot=NULL; }
 178
 179   if(fHistTPCSideArms){ delete fHistTPCSideArms; fHistTPCSideArms=NULL; }
 180   if(fHistTPCSideCrms){ delete fHistTPCSideCrms; fHistTPCSideCrms=NULL; }
 181
 182   return 0;
 183 }
 184
 185 int AliHLTTPCHistogramHandlerComponent::DoEvent(const AliHLTComponentEventData&/* evtData*/, AliHLTComponentTriggerData& /*trigData*/){
 186   // see header file for class documentation
 187
 188   //HLTInfo("--- Entering DoEvent() in TPCHistogramHandler ---");
 189
 190   if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
 191
 192   if(fUseGeneral == kFALSE){
 193     fTotalClusterChargeIROCAll = new TH1F("fTotalClusterChargeIROCAll","Total Charge of clusters in all IROC",4000,0,4000);
 194     fTotalClusterChargeOROCAll = new TH1F("fTotalClusterChargeOROCAll","Total Charge of clusters in all OROC",4000,0,4000);
 195     fQMaxPartitionAll          = new TH1F("fQMaxPartitionAll",         "QMax for All Partitions",             216,0,216);
 196     fPlotQmaxROCAll            = new TH1F("fQMaxROCAll",               "QMax for All ROC",                    72,0,72);
 197     fNumberOfClusters          = new TH1F("fNumberOfClusters",         "Total Number of Clusters",            1,0,1);
 198   }
 199
 200   const TObject *iter = NULL;
 201   for(iter = GetFirstInputObject(kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputObject()){
 202
 203     //      HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 204     //               evtData.fEventID, evtData.fEventID,
 205     //               DataType2Text(GetDataType(iter)).c_str(),
 206     //               DataType2Text(kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC).c_str());
 207
 208     //      if (GetDataType(iter) == (kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC) && GetEventCount()<2){
 209     //          HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeHistogram)!",
 210     //   DataType2Text(kAliHLTDataTypeHistogram).c_str(),
 211     //          DataType2Text(kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC).c_str());
 212     //      }
 213
 214     if (GetDataType(iter) != (kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC)) continue;
 215
 216     // Summing the output histograms of the AliHLTTPCNoiseMapComponent (from partition to TPC sides)
 217
 218     if(fUseGeneral == kFALSE){
 219       if(fNoiseHistograms == kTRUE){
 220
 221         fHistTH2Tmp = (TH2F*)iter;
 222         TString histName = fHistTH2Tmp->GetName();
 223
 224         UInt_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(iter));
 225         UInt_t maxSlice     = AliHLTTPCDefinitions::GetMaxSliceNr(GetSpecification(iter));
 226         UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(iter));
 227         UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(GetSpecification(iter));
 228
 229         if((minSlice!=maxSlice) || (minPartition!=maxPartition)){
 230           HLTWarning("TPCHistogramHandler::The Noise Map component is not running on partition level!");
 231         }
 232
 233         // minSlice=maxSlice, when the Noise Map component runs on partition level (as it should)
 234
 235         if     (histName.Contains("fHistSideAMaxSignal")) fHistTPCSideAmax->Add(fHistTH2Tmp,1);
 236         else if(histName.Contains("fHistSideATotSignal")) fHistTPCSideAtot->Add(fHistTH2Tmp,1);
 237         else if(histName.Contains("fHistSideAPadRMS"))    fHistTPCSideArms->Add(fHistTH2Tmp,1);
 238         else if(histName.Contains("fHistSideCMaxSignal")) fHistTPCSideCmax->Add(fHistTH2Tmp,1);
 239         else if(histName.Contains("fHistSideCTotSignal")) fHistTPCSideCtot->Add(fHistTH2Tmp,1);
 240         else if(histName.Contains("fHistSideCPadRMS"))    fHistTPCSideCrms->Add(fHistTH2Tmp,1);
 241         else continue;
 242
 243       } // endif fNoiseHistograms==kTRUE
 244
 245       // Summing the output of AliHLTTPCClusterHistoComponent
 246       if(fKryptonHistograms){
 247         Int_t thisrow=-1,thissector=-1,row=-1;
 248
 249         AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(iter));
 250         AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(iter));
 251         row = AliHLTTPCTransform::GetFirstRow(patch);
 252         AliHLTTPCTransform::Slice2Sector(slice,row,thissector,thisrow);
 253
 254         fHistTH1Tmp = (TH1F*)iter;
 255         TString name = fHistTH1Tmp->GetName();
 256
 257         if(name=="fTotalClusterChargeIROCAll"){
 258           fTotalClusterChargeIROCAll->Add(fTotalClusterChargeIROCAll,fHistTH1Tmp,1,1);
 259         }
 260         else if(name=="fTotalClusterChargeOROCAll"){
 261           fTotalClusterChargeOROCAll->Add(fTotalClusterChargeOROCAll,fHistTH1Tmp,1,1);
 262         }
 263         else if(name=="fQMaxPartitionAll"){
 264           for(Int_t t=0;t<216;t++){
 265             if(fHistTH1Tmp->GetBinContent(t)>fQMaxPartitionAll->GetBinContent(t)){
 266               fQMaxPartitionAll->SetBinContent(t,fHistTH1Tmp->GetBinContent(t));
 267             }
 268           }
 269         }
 270         else if(name=="fQMaxROCAll"){
 271           for(Int_t t=0;t<72;t++){
 272             if(fHistTH1Tmp->GetBinContent(t)>fPlotQmaxROCAll->GetBinContent(t)){
 273               fPlotQmaxROCAll->SetBinContent(t,fHistTH1Tmp->GetBinContent(t));
 274             }
 275           }
 276         }
 277         else if(name=="fNumberOfClusters"){
 278           fNumberOfClusters->Add(fNumberOfClusters,fHistTH1Tmp,1,1);
 279         }
 280         else{
 281           HLTWarning("No histogram names match. %s",name.Data());
 282           continue;
 283         }
 284       } //endif fKryptonHistograms==kTRUE
 285     }
 286
 287     else { // means fUseGeneral ==kTRUE
 288
 289       TH1 * tmp = (TH1*)iter;
 290       TString histName = tmp->GetName();
 291       UInt_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(iter));
 292       UInt_t maxSlice     = AliHLTTPCDefinitions::GetMaxSliceNr(GetSpecification(iter));
 293       UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(iter));
 294       UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(GetSpecification(iter));
 295
 296       Bool_t histogramNotAdded = kTRUE;
 297
 298       for(UInt_t i=0;i<fHistogramData.size();i++){
 299         if(fIgnoreSpecification == kTRUE){
 300
 301           /*
 302             if(histName.Contains(Form("_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition))){
 303             cout << "HistogramContains the given string." << endl;
 304             }
 305           */
 306           histName.ReplaceAll(Form("_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition),"");
 307         }
 308
 309         if(histName.CompareTo(fHistogramData.at(i).fHistogram->GetName())==0){
 310           if((minSlice==fHistogramData.at(i).fMinSlice && maxSlice == fHistogramData.at(i).fMaxSlice) || fIgnoreSpecification == kTRUE){
 311             if((minPartition==fHistogramData.at(i).fMinPartition && maxPartition == fHistogramData.at(i).fMaxPartition) || fIgnoreSpecification == kTRUE){
 312               fHistogramData.at(i).fHistogram->Add(tmp);
 313               histogramNotAdded = kFALSE;
 314               break;
 315             }
 316             else{
 317               HLTWarning("Histogram with same name does not have the same partition specification");
 318             }
 319           }
 320           else{
 321             HLTWarning("Histogram with same name does not have the same slice specification");
 322           }
 323         }
 324       }
 325
 326       if(fHistogramData.size()==0){
 327         if(fIgnoreSpecification == kTRUE){
 328            if(histName.Contains(Form("_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition))){
 329               cout << "HistogramContains the given string." << endl;
 330            }
 331            histName.ReplaceAll(Form("_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition),"");
 332         }
 333       }
 334
 335       if(histogramNotAdded == kTRUE){
 336          tmp->SetName(histName);
 337          AliHLTHistogramData  histogramData;
 338          histogramData.fHistogram = tmp;
 339          histogramData.fMinSlice = minSlice;
 340          histogramData.fMaxSlice = maxSlice;
 341          histogramData.fMinPartition = minPartition;
 342          histogramData.fMaxPartition = maxPartition;
 343          fHistogramData.push_back(histogramData);
 344       }
 345     }
 346   } // end for loop over histogram blocks
 347
 348   MakeHistosPublic();
 349   return 0;
 350 } // end DoEvent()
 351
 352 void AliHLTTPCHistogramHandlerComponent::MakeHistosPublic() {
 353   // see header file for class documentation
 354
 355   if(fUseGeneral == kFALSE){
 356     if(fNoiseHistograms){
 357       PushBack((TObject*)fHistTPCSideAmax,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification( 0,17,0,5));
 358       PushBack((TObject*)fHistTPCSideCmax,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(18,35,0,5));
 359
 360       PushBack((TObject*)fHistTPCSideAtot,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification( 0,17,0,5));
 361       PushBack((TObject*)fHistTPCSideCtot,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(18,35,0,5));
 362
 363       PushBack((TObject*)fHistTPCSideArms,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification( 0,17,0,5));
 364       PushBack((TObject*)fHistTPCSideCrms,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(18,35,0,5));
 365
 366       //if(fHistTH2Tmp)  { delete fHistTH2Tmp;   fHistTH2Tmp=NULL;   }
 367       //     if(fHistTPCSideA){ delete fHistTPCSideA; fHistTPCSideA=NULL; }
 368       //     if(fHistTPCSideC){ delete fHistTPCSideC; fHistTPCSideC=NULL; }
 369     }
 370
 371     if(fKryptonHistograms){
 372       PushBack((TObject*)fTotalClusterChargeIROCAll,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,17,0,1));
 373       PushBack((TObject*)fTotalClusterChargeOROCAll,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,17,2,5));
 374       PushBack((TObject*)fQMaxPartitionAll,        kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
 375       PushBack((TObject*)fPlotQmaxROCAll,          kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
 376       PushBack((TObject*)fNumberOfClusters,        kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
 377
 378       if(fTotalClusterChargeIROCAll){ delete fTotalClusterChargeIROCAll; fTotalClusterChargeIROCAll=NULL; }
 379       if(fTotalClusterChargeOROCAll){ delete fTotalClusterChargeOROCAll; fTotalClusterChargeOROCAll=NULL; }
 380       if(fQMaxPartitionAll)         { delete fQMaxPartitionAll;          fQMaxPartitionAll=NULL;          }
 381       if(fPlotQmaxROCAll)           { delete fPlotQmaxROCAll;            fPlotQmaxROCAll=NULL;            }
 382       if(fNumberOfClusters)         { delete fNumberOfClusters;          fNumberOfClusters=NULL;          }
 383       if(fHistTH1Tmp)               { delete fHistTH1Tmp;                fHistTH1Tmp=NULL;                }
 384     }
 385   }
 386   else{ // means fUseGeneral == kTRUE
 387     for(UInt_t i=0;i<fHistogramData.size();i++){
 388       PushBack((TObject*)fHistogramData.at(i).fHistogram,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(
 389                                                                                                                                 fHistogramData.at(i).fMinSlice,fHistogramData.at(i).fMaxSlice,fHistogramData.at(i).fMinPartition,fHistogramData.at(i).fMaxPartition));
 390     }
 391     fHistogramData.clear();
 392   }
 393   //  TObjArray histos;
 394
 395   //   if(fPlotSideA) histos.Add(fHistSideA);
 396   //   if(fPlotSideC) histos.Add(fHistSideC);
 397   //   if(fApplyNoiseMap) histos.Add(fHistCDBMap);
 398   //
 399   //   TIter iterator(&histos);
 400   //   while(TObject *pObj=iterator.Next()){
 401   //
 402   //         PushBack(pObj, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, fSpecification);
 403   //   }
 404   //
 405   //
 406   //   //PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);
 407 }
 408
 409 int AliHLTTPCHistogramHandlerComponent::Configure(const char* arguments) {
 410   // see header file for class documentation
 411
 412   int iResult=0;
 413   if (!arguments) return iResult;
 414   HLTInfo("parsing configuration string \'%s\'", arguments);
 415
 416   TString allArgs=arguments;
 417   TString argument;
 418   int bMissingParam=0;
 419
 420   TObjArray* pTokens=allArgs.Tokenize(" ");
 421   if (pTokens) {
 422     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
 423       argument=((TObjString*)pTokens->At(i))->GetString();
 424       if (argument.IsNull()) continue;
 425
 426       if (argument.CompareTo("-sum-noise-histograms")==0) {
 427         fNoiseHistograms = kTRUE;
 428         HLTInfo("got \'-sum-noise-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 429
 430       } else if (argument.CompareTo("-sum-krypton-histograms")==0) {
 431         fKryptonHistograms = kTRUE;
 432         HLTInfo("got \'-sum-krypton-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 433
 434       } else if (argument.CompareTo("-use-general")==0) {
 435         fUseGeneral = kTRUE;
 436         HLTInfo("got \'-use-general\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 437
 438       } else if (argument.CompareTo("-ignore-specification")==0) {
 439         fIgnoreSpecification = kTRUE;
 440         HLTInfo("got \'-ignore-specification\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 441       }
 442       else {
 443         HLTError("unknown argument %s", argument.Data());
 444         iResult=-EINVAL;
 445         break;
 446       }
 447     } // end for
 448
 449     /*for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
 450       argument=((TObjString*)pTokens->At(i))->GetString();
 451       if (argument.IsNull()) continue;
 452
 453       if (argument.CompareTo("-sum-noise-histograms")==0) {
 454         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 455         HLTInfo("got \'-sum-noise-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 456
 457       } else if (argument.CompareTo("-sum-krypton-histograms")==0) {
 458         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 459         HLTInfo("got \'-sum-krypton-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 460
 461       } else if (argument.CompareTo("-use-general")==0) {
 462         fUseGeneral = kTRUE;
 463         HLTInfo("got \'-use-general\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 464
 465       } else if (argument.CompareTo("-ignore-specification")==0) {
 466         fIgnoreSpecification = kTRUE;
 467         HLTInfo("got \'-ignore-specification\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
 468       }
 469       else {
 470         HLTError("unknown argument %s", argument.Data());
 471         iResult=-EINVAL;
 472         break;
 473       }
 474     } // end for*/
 475
 476     delete pTokens;
 477
 478   } // end if pTokens
 479
 480   if (bMissingParam) {
 481     HLTError("missing parameter for argument %s", argument.Data());
 482     iResult=-EINVAL;
 483   }
 484   return iResult;
 485 }
 486
 487 int AliHLTTPCHistogramHandlerComponent::Reconfigure(const char* cdbEntry, const char* chainId) {
 488   // see header file for class documentation
 489
 490   int iResult=0;
 491   const char* path="HLT/ConfigTPC/TPCHistogramHandlerComponent";
 492   const char* defaultNotify="";
 493   if (cdbEntry) {
 494     path=cdbEntry;
 495     defaultNotify=" (default)";
 496   }
 497
 498   if (path) {
 499     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
 500     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 501     if (pEntry) {
 502       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
 503       if (pString) {
 504         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
 505         iResult=Configure(pString->GetString().Data());
 506       } else {
 507         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
 508       }
 509     } else {
 510       HLTError("cannot fetch object \"%s\" from CDB", path);
 511     }
 512   }
 513   return iResult;
 514 }