HLT/TRD/AliHLTTRDCalibrationComponent.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
   7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
   8  *          for The ALICE Off-line 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   AliHLTTRDCalibrationComponent.cxx
  20     @author Timm Steinbeck, Matthias Richter
  21     @date
  22     @brief  A TRDCalibration processing component for the HLT. */
  23
  24 #if __GNUC__ >= 3
  25 using namespace std;
  26 #endif
  27
  28 #include "TTree.h"
  29 #include "TFile.h"
  30 #include "TBranch.h"
  31 #include "TH2I.h"
  32 #include "TH2.h"
  33 #include "TProfile2D.h"
  34
  35 #include "AliHLTReadoutList.h"
  36
  37 #include "AliHLTTRDCalibrationComponent.h"
  38 #include "AliHLTTRDDefinitions.h"
  39 #include "AliHLTTRDUtils.h"
  40
  41 #include "AliCDBManager.h"
  42 #include "AliCDBStorage.h"
  43 #include "AliRawReaderMemory.h"
  44
  45 #include "AliTRDCalPad.h"
  46 #include "AliTRDCalDet.h"
  47
  48 #include "AliTRDCalibraFillHisto.h"
  49 #include "AliTRDtrackV1.h"
  50
  51 #include "AliTRDCalibraFit.h"
  52 #include "AliTRDCalibraMode.h"
  53 #include "AliTRDCalibraVector.h"
  54 #include "AliTRDCalibraVdriftLinearFit.h"
  55 #include "AliTRDReconstructor.h"
  56 #include "AliTRDrecoParam.h"
  57
  58 #include <cstdlib>
  59 #include <cerrno>
  60 #include <string>
  61
  62 ClassImp(AliHLTTRDCalibrationComponent);
  63
  64 AliHLTTRDCalibrationComponent::AliHLTTRDCalibrationComponent()
  65   : AliHLTCalibrationProcessor(),
  66     fTRDCalibraFillHisto(NULL),
  67     fOutputSize(500000),
  68     fTracksArray(NULL),
  69     fOutArray(NULL),
  70     fAfterRunArray(NULL),
  71     fDisplayArray(NULL),
  72     fSavedTimeBins(kFALSE),
  73     fTrgStrings(NULL),
  74     fAccRejTrg(0),
  75     fMinClusters(0),
  76     fMinTracklets(0),
  77     fTakeAllEvents(kFALSE)
  78 {
  79   // Default constructor
  80 }
  81
  82 AliHLTTRDCalibrationComponent::~AliHLTTRDCalibrationComponent()
  83 {
  84   // Destructor
  85 }
  86
  87 const char* AliHLTTRDCalibrationComponent::GetComponentID()
  88 {
  89   // Return the component ID const char *
  90   return "TRDCalibration"; // The ID of this component
  91 }
  92
  93 void AliHLTTRDCalibrationComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  94 {
  95   // Get the list of input data
  96   list.clear(); // We do not have any requirements for our input data type(s).
  97   list.push_back(AliHLTTRDDefinitions::fgkTracksDataType);
  98 }
  99
 100 AliHLTComponentDataType AliHLTTRDCalibrationComponent::GetOutputDataType()
 101 {
 102   // Get the output data type
 103   return kAliHLTMultipleDataType;
 104   //  return AliHLTTRDDefinitions::fgkCalibrationDataType;
 105
 106 }
 107
 108 int AliHLTTRDCalibrationComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
 109 {
 110   // Get the output data type
 111   tgtList.clear();
 112   tgtList.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
 113   tgtList.push_back(AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 114   return tgtList.size();
 115 }
 116
 117 void AliHLTTRDCalibrationComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 118 {
 119   // Get the output data size
 120   constBase = fOutputSize;
 121   inputMultiplier = 0;
 122 }
 123
 124 AliHLTComponent* AliHLTTRDCalibrationComponent::Spawn()
 125 {
 126   // Spawn function, return new instance of this class
 127   return new AliHLTTRDCalibrationComponent;
 128 };
 129
 130 Int_t AliHLTTRDCalibrationComponent::ScanArgument( int argc, const char** argv )
 131 {
 132   // perform initialization. We check whether our relative output size is specified in the arguments.
 133   int i = 0;
 134   char* cpErr;
 135   if(!fTrgStrings)
 136     fTrgStrings = new TObjArray();
 137
 138   while ( i < argc )
 139     {
 140       HLTDebug("argv[%d] == %s", i, argv[i] );
 141       if ( !strcmp( argv[i], "output_size" ) )
 142         {
 143           if ( i+1>=argc )
 144             {
 145               HLTError("Missing output_size parameter");
 146               return ENOTSUP;
 147             }
 148           HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
 149           fOutputSize = strtoul( argv[i+1], &cpErr, 0 );
 150           if ( *cpErr )
 151             {
 152               HLTError("Cannot convert output_size parameter '%s'", argv[i+1] );
 153               return EINVAL;
 154             }
 155           HLTInfo("Output size set to %lu %%", fOutputSize );
 156           i += 2;
 157           continue;
 158         }
 159       if ( !strcmp( argv[i], "-minClusters" ) )
 160         {
 161           if ( i+1>=argc )
 162             {
 163               HLTError("Missing minClusters parameter");
 164               return ENOTSUP;
 165             }
 166           HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
 167           fMinClusters = strtoul( argv[i+1], &cpErr, 0 );
 168           i += 2;
 169           continue;
 170         }
 171       if ( !strcmp( argv[i], "-minTracklets" ) )
 172         {
 173           if ( i+1>=argc )
 174             {
 175               HLTError("Missing minTracklets parameter");
 176               return ENOTSUP;
 177             }
 178           HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
 179           fMinTracklets = strtoul( argv[i+1], &cpErr, 0 );
 180           i += 2;
 181           continue;
 182         }
 183       if ( !strcmp( argv[i], "-TrgStr" ) )
 184         {
 185           if ( i+1>=argc )
 186             {
 187               HLTError("Missing parameter for mbTriggerString");
 188               return ENOTSUP;
 189             }
 190           HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
 191           fTrgStrings->Add(new TObjString(argv[i+1]));
 192           i += 2;
 193           continue;
 194         }
 195
 196       if ( !strcmp( argv[i], "-acceptTrgStr" ) )
 197         {
 198           fAccRejTrg=1;
 199           i += 1;
 200           continue;
 201         }
 202       if ( !strcmp( argv[i], "-rejectTrgStr" ) )
 203         {
 204           fAccRejTrg=-1;
 205           i += 1;
 206           continue;
 207         }
 208       if ( !strcmp( argv[i], "-takeAllEvents" ) )
 209         {
 210           fTakeAllEvents = kTRUE;
 211           fAccRejTrg = 0;
 212           i += 1;
 213           continue;
 214         }
 215
 216       else {
 217         HLTError("Unknown option '%s'", argv[i] );
 218         return EINVAL;
 219       }
 220     }
 221   return i;
 222 }
 223
 224 Int_t AliHLTTRDCalibrationComponent::InitCalibration()
 225 {
 226
 227   if(!fTrgStrings)
 228     fTrgStrings = new TObjArray();
 229
 230   if(!AliCDBManager::Instance()->IsDefaultStorageSet()){
 231     HLTError("DefaultStorage is not set in CDBManager");
 232     return -EINVAL;
 233   }
 234   if(AliCDBManager::Instance()->GetRun()<0){
 235     HLTError("Run Number is not set in CDBManager");
 236     return -EINVAL;
 237   }
 238   HLTInfo("CDB default storage: %s; RunNo: %i", (AliCDBManager::Instance()->GetDefaultStorage()->GetBaseFolder()).Data(), AliCDBManager::Instance()->GetRun());
 239
 240   if(fTrgStrings->GetEntriesFast()>0 && !fAccRejTrg){
 241     HLTError("Trigger string(s) given, but acceptTrgStr or rejectTrgStr not selected");
 242     return -EINVAL;
 243   }
 244
 245   fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
 246   fTRDCalibraFillHisto->SetIsHLT(kTRUE);
 247   fTRDCalibraFillHisto->SetHisto2d(); // choose to use histograms
 248   fTRDCalibraFillHisto->SetCH2dOn();  // choose to calibrate the gain
 249   fTRDCalibraFillHisto->SetPH2dOn();  // choose to calibrate the drift velocity
 250   fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
 251   fTRDCalibraFillHisto->SetIsHLT(); // per detector
 252   //fTRDCalibraFillHisto->SetDebugLevel(1);// debug
 253   fTRDCalibraFillHisto->SetFillWithZero(kTRUE);
 254   fTRDCalibraFillHisto->SetLinearFitterOn(kTRUE);
 255   fTRDCalibraFillHisto->SetNumberBinCharge(100);
 256
 257   fTracksArray = new TClonesArray("AliTRDtrackV1");
 258   fOutArray = new TObjArray(4);
 259   fAfterRunArray=new TObjArray(5);
 260   fDisplayArray=new TObjArray(4);
 261
 262   HLTDebug("run SetupCTPData");
 263   SetupCTPData();
 264
 265   return 0;
 266 }
 267
 268 Int_t AliHLTTRDCalibrationComponent::DeinitCalibration()
 269 {
 270
 271   // Deinitialization of the component
 272
 273   HLTDebug("DeinitCalibration");
 274   delete fTracksArray; fTracksArray=0;
 275   //fTRDCalibraFillHisto->Destroy();
 276   //fOutArray->Delete();
 277   delete fOutArray; fOutArray=0;
 278   fAfterRunArray->Delete();
 279   delete fAfterRunArray; fAfterRunArray=0;
 280   fDisplayArray->Delete();
 281   delete fDisplayArray; fDisplayArray=0;
 282   fTrgStrings->Delete();
 283   delete fTrgStrings; fTrgStrings=0;
 284   return 0;
 285 }
 286
 287 Int_t AliHLTTRDCalibrationComponent::ProcessCalibration(const AliHLTComponent_EventData& /*evtData*/,
 288                                                         const AliHLTComponent_BlockData* /*blocks*/,
 289                                                         AliHLTComponent_TriggerData& trigData,
 290                                                         AliHLTUInt8_t* /*outputPtr*/,
 291                                                         AliHLTUInt32_t& /*size*/,
 292                                                         vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
 293 {
 294   // Process an event
 295
 296   TClonesArray* TCAarray[18] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 297   Int_t usedEntries = 0;
 298   Int_t blockOrObject = 0;
 299   Int_t nTimeBins = -1;
 300
 301   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(AliHLTTRDDefinitions::fgkTracksDataType); pBlock; pBlock=GetNextInputBlock())
 302     {
 303       TCAarray[0] = fTracksArray;
 304       AliHLTTRDUtils::ReadTracks(TCAarray[0], pBlock->fPtr, pBlock->fSize, &nTimeBins);
 305       usedEntries = 1;
 306       blockOrObject = -1;
 307     }
 308
 309   for(const TObject *iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkHiLvlTracksDataType); iter; iter = GetNextInputObject())
 310     {
 311       if(blockOrObject<0){
 312         HLTError("You may not mix high level and low level!");
 313         return -1;
 314       }
 315
 316       TCAarray[usedEntries] = dynamic_cast<TClonesArray*>(const_cast<TObject*>(iter));
 317       if(!TCAarray[usedEntries])continue;
 318       TObjString* strg = dynamic_cast<TObjString*>(const_cast<TObject*>(GetNextInputObject()));
 319       if(!strg)continue;
 320
 321       nTimeBins = strg->String().Atoi();
 322       usedEntries++;
 323       blockOrObject = 1;
 324     }
 325
 326   if(!blockOrObject)
 327     return 0;
 328
 329   if(!fSavedTimeBins){
 330     if(nTimeBins<0){
 331       HLTFatal("Number of timebins is negative!");
 332       return -1;
 333     }
 334     HLTDebug("Saving number of time bins which was read from input block. Value is: %d", nTimeBins);
 335     fTRDCalibraFillHisto->Init2Dhistos(nTimeBins); // initialise the histos
 336     fTRDCalibraFillHisto->SetNumberClusters(fMinClusters); // At least fMinClusters clusters
 337     fTRDCalibraFillHisto->SetNumberClustersf(nTimeBins); // Not more than %d  clusters
 338     fSavedTimeBins=kTRUE;
 339   }
 340
 341   Bool_t TriggerPassed = fTakeAllEvents;
 342
 343   if(fAccRejTrg){
 344     if(fAccRejTrg>0){
 345       TriggerPassed=kFALSE;
 346       for(int i = 0; i < fTrgStrings->GetEntriesFast(); i++){
 347         const TObjString *const obString=(TObjString*)fTrgStrings->At(i);
 348         const TString tString=obString->GetString();
 349         //printf("Trigger Output: %i\n",EvaluateCTPTriggerClass(tString.Data(),trigData));
 350         if(EvaluateCTPTriggerClass(tString.Data(),trigData)){TriggerPassed=kTRUE; break;}
 351       }
 352     }
 353     else{
 354       TriggerPassed=kTRUE;
 355       for(int i = 0; i < fTrgStrings->GetEntriesFast(); i++){
 356         const TObjString *const obString=(TObjString*)fTrgStrings->At(i);
 357         const TString tString=obString->GetString();
 358         if(EvaluateCTPTriggerClass(tString.Data(),trigData)){TriggerPassed=kFALSE; break;}
 359       }
 360     }
 361   }
 362
 363   fTRDCalibraFillHisto->SetCH2dOn(TriggerPassed);
 364   fTRDCalibraFillHisto->SetPH2dOn(TriggerPassed);
 365   for(int i=0; i<usedEntries; i++){
 366     const TClonesArray* inArr = TCAarray[i];
 367     Int_t nbEntries = inArr->GetEntries();
 368     HLTDebug(" %i TRDtracks in tracksArray", nbEntries);
 369     AliTRDtrackV1* trdTrack = 0x0;
 370     for (Int_t ii = 0; ii < nbEntries; ii++){
 371       HLTDebug("%i/%i: ", ii+1, nbEntries);
 372       trdTrack = (AliTRDtrackV1*)inArr->At(ii);
 373       if(trdTrack->GetNumberOfTracklets()<fMinTracklets)continue;
 374       fTRDCalibraFillHisto->UpdateHistogramsV1(trdTrack);
 375       // for(int i3=0; i3<7; i3++)
 376       //   if(trdTrack->GetTracklet(i3))trdTrack->GetTracklet(i3)->Bootstrap(fReconstructor);
 377     }
 378   }
 379
 380   if(!fOutArray->At(0))FormOutput(0);
 381   if(!fDisplayArray->At(0))FormOutput(1);
 382   PushBack(fDisplayArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
 383
 384   if(blockOrObject<0){
 385     TCAarray[0]->Delete();
 386   }
 387
 388   return 0;
 389
 390 }
 391
 392 /**
 393  * Form output array of histrograms
 394  */
 395 //============================================================================
 396 void AliHLTTRDCalibrationComponent::FormOutput(Int_t param)
 397 {
 398   // gain histo
 399   TH2I *hCH2d = fTRDCalibraFillHisto->GetCH2d();
 400   if(!param)fOutArray->Add(hCH2d);
 401   else fDisplayArray->Add(hCH2d);
 402
 403   // drift velocity histo
 404   TProfile2D *hPH2d = fTRDCalibraFillHisto->GetPH2d();
 405   if(!param)fOutArray->Add(hPH2d);
 406   else fDisplayArray->Add(hPH2d);
 407
 408   // PRF histo
 409   TProfile2D *hPRF2d = fTRDCalibraFillHisto->GetPRF2d();
 410   if(!param)fOutArray->Add(hPRF2d);
 411   else fDisplayArray->Add(hPRF2d);
 412
 413   // Vdrift Linear Fit
 414   if(!param){
 415     AliTRDCalibraVdriftLinearFit *hVdriftLinearFitOne=(AliTRDCalibraVdriftLinearFit *)fTRDCalibraFillHisto->GetVdriftLinearFit();
 416     fOutArray->Add(hVdriftLinearFitOne);
 417   }
 418   else{
 419     TH2S *hVdriftLinearFitOne = (TH2S *)(((AliTRDCalibraVdriftLinearFit *)fTRDCalibraFillHisto->GetVdriftLinearFit())->GetLinearFitterHisto(10,kTRUE));
 420     fDisplayArray->Add(hVdriftLinearFitOne);
 421   }
 422
 423   HLTDebug("GetCH2d = 0x%x; NEntries = %i; size = %i", hCH2d, hCH2d->GetEntries(), sizeof(*hCH2d));
 424   hCH2d->Print();
 425   HLTDebug("GetPH2d = 0x%x; NEntries = %i; size = %i", hPH2d, hPH2d->GetEntries(), sizeof(*hPH2d));
 426   hPH2d->Print();
 427   HLTDebug("GetPRF2d = 0x%x; NEntries = %i; size = %i", hPRF2d, hPRF2d->GetEntries(), sizeof(*hPRF2d));
 428   hPRF2d->Print();
 429   //HLTDebug("GetVdriftLinearFit = 0x%x; size = %i", hVdriftLinearFitOne, sizeof(hVdriftLinearFitOne));
 430
 431   HLTDebug("output Array: pointer = 0x%x; NEntries = %i; size = %i", fOutArray, fOutArray->GetEntries(), sizeof(fOutArray));
 432
 433 }
 434
 435 Int_t AliHLTTRDCalibrationComponent::ShipDataToFXS(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 436 {
 437   //fTRDCalibraFillHisto->DestroyDebugStreamer();
 438
 439   AliHLTReadoutList rdList(AliHLTReadoutList::kTRD);
 440
 441   EORCalibration();
 442
 443   fOutArray->Remove(fOutArray->FindObject("AliTRDCalibraVdriftLinearFit"));
 444   //fOutArray->Remove(fOutArray->FindObject("PRF2d"));
 445   //fOutArray->Remove(fOutArray->FindObject("PH2d"));
 446   //fOutArray->Remove(fOutArray->FindObject("CH2d"));
 447
 448   if(!(fOutArray->FindObject("CH2d"))) {
 449     TH2I * ch2d = new TH2I("CH2d","Nz0Nrphi0",100,0.0,300.0,540,0,540);
 450     fOutArray->Add(ch2d);
 451   }
 452
 453   if(!(fOutArray->FindObject("PH2d"))) {
 454     TProfile2D * ph2d = new TProfile2D("PH2d","Nz0Nrphi0",30,-0.05,2.95,540,0,540);
 455     fOutArray->Add(ph2d);
 456   }
 457
 458   if(!(fOutArray->FindObject("PRF2d"))) {
 459     TProfile2D * prf2d = new TProfile2D("PRF2d","Nz0Nrphi0Ngp3",60,-9.0,9.0,540,0,540);
 460     fOutArray->Add(prf2d);
 461   }
 462
 463   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
 464
 465   PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 466   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 467
 468   return 0;
 469 }
 470
 471 Int_t AliHLTTRDCalibrationComponent::EORCalibration()
 472 {
 473   //Also Fill histograms for the online display
 474   TH2I *hCH2d=(TH2I*)fOutArray->FindObject("CH2d");
 475   TProfile2D *hPH2d=(TProfile2D*)fOutArray->FindObject("PH2d");
 476   TProfile2D *hPRF2d= (TProfile2D*)fOutArray->FindObject("PRF2d");
 477   AliTRDCalibraVdriftLinearFit* hVdriftLinearFit = (AliTRDCalibraVdriftLinearFit*)fOutArray->FindObject("AliTRDCalibraVdriftLinearFit");
 478
 479
 480   if(!hCH2d || !hPH2d || !hPRF2d || !hVdriftLinearFit) return 0;
 481
 482   //Fit
 483   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 484
 485   //Gain
 486   calibra->SetMinEntries(100);
 487   calibra->AnalyseCH(hCH2d);
 488   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 489     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 490   Int_t nbfit       = calibra->GetNumberFit();
 491   Int_t nbE         = calibra->GetNumberEnt();
 492   TH1F *coefgain = 0x0;
 493   // enough statistics
 494   //if ((nbtg >                  0) &&
 495   //   (nbfit        >= 0.2*nbE)) {
 496   // create the cal objects
 497   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 498   TObjArray object           = calibra->GetVectorFit();
 499   AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,kFALSE);
 500   coefgain                   = objgaindet->MakeHisto1DAsFunctionOfDet();
 501   //}
 502   calibra->ResetVectorFit();
 503
 504   // vdrift second method
 505   calibra->SetMinEntries(100); // If there is less than 100
 506   hVdriftLinearFit->FillPEArray();
 507   calibra->AnalyseLinearFitters(hVdriftLinearFit);
 508   nbtg = 540;
 509   nbfit = calibra->GetNumberFit();
 510   nbE   = calibra->GetNumberEnt();
 511   TH1F *coefdriftsecond = 0x0;
 512   // enough statistics
 513   //if ((nbtg >                  0) &&
 514   // (nbfit        >= 0.1*nbE)) {
 515   // create the cal objects
 516   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 517   object  = calibra->GetVectorFit();
 518   AliTRDCalDet *objdriftvelocitydetsecond = calibra->CreateDetObjectVdrift(&object,kTRUE);
 519   objdriftvelocitydetsecond->SetTitle("secondmethodvdrift");
 520   coefdriftsecond  = objdriftvelocitydetsecond->MakeHisto1DAsFunctionOfDet();
 521   //}
 522   calibra->ResetVectorFit();
 523
 524   // vdrift first method
 525   calibra->SetMinEntries(100*20); // If there is less than 20000
 526   calibra->AnalysePH(hPH2d);
 527   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 528     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 529   nbfit        = calibra->GetNumberFit();
 530   nbE          = calibra->GetNumberEnt();
 531   TH1F *coefdrift = 0x0;
 532   TH1F *coeft0 = 0x0;
 533   // enough statistics
 534   //if ((nbtg >                  0) &&
 535   // (nbfit        >= 0.2*nbE)) {
 536   // create the cal objects
 537   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 538   //calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 539   object  = calibra->GetVectorFit();
 540   AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 541   coefdrift        = objdriftvelocitydet->MakeHisto1DAsFunctionOfDet();
 542   object              = calibra->GetVectorFit2();
 543   AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
 544   coeft0        = objtime0det->MakeHisto1DAsFunctionOfDet();
 545   //}
 546   calibra->ResetVectorFit();
 547
 548
 549   //PRF
 550   calibra->SetMinEntries(200);
 551   calibra->AnalysePRFMarianFit(hPRF2d);
 552   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 553     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 554   nbfit        = calibra->GetNumberFit();
 555   nbE          = calibra->GetNumberEnt();
 556   TH1F *coefprf = 0x0;
 557   // enough statistics
 558   //if ((nbtg >                  0) &&
 559   //  (nbfit        >= 0.95*nbE)) {
 560   // create cal pad objects
 561   object            = calibra->GetVectorFit();
 562   TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
 563   coefprf                     = ((AliTRDCalPad *) objPRFpad)->MakeHisto1D();
 564   //}
 565   calibra->ResetVectorFit();
 566
 567
 568   coefgain->SetName("coefgain");
 569   coefprf->SetName("coefprf");
 570   coefdrift->SetName("coefdrift");
 571   coefdriftsecond->SetName("coefdriftsecond");
 572   coeft0->SetName("coeft0");
 573   if(coefgain) fAfterRunArray->Add(coefgain);
 574   if(coefprf) fAfterRunArray->Add(coefprf);
 575   if(coefdrift) fAfterRunArray->Add(coefdrift);
 576   if(coefdriftsecond) fAfterRunArray->Add(coefdriftsecond);
 577   if(coeft0) fAfterRunArray->Add(coeft0);
 578
 579
 580   if(coefgain||coefprf||coefdrift||coeft0||coefdriftsecond) {
 581     PushBack(fAfterRunArray, AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 582   }
 583
 584   // TString fileName="/tmp/CalibHistoDump_run";
 585   // fileName+=AliCDBManager::Instance()->GetRun();
 586   // fileName+=".root";
 587   // HLTInfo("Dumping Histogram file to %s",fileName.Data());
 588   // TFile* file = TFile::Open(fileName, "RECREATE");
 589   // fAfterRunArray->Write();
 590   // fOutArray->Write();
 591   // file->Close();
 592   // HLTInfo("Histogram file dumped");
 593
 594   return 0;
 595 }
 596