HLT/TRD/AliHLTTRDCalibrationComponent.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors:                                                               *
   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   AliHLTTRDCalibrationComponent.cxx
  19 //  @author
  20 //  @date
  21 //  @brief  A TRDCalibration processing component for the HLT.
  22 //
  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         if(CheckCTPTrigger(tString.Data())>0){TriggerPassed=kTRUE; break;}
 350       }
 351     }
 352     else{
 353       TriggerPassed=kTRUE;
 354       for(int i = 0; i < fTrgStrings->GetEntriesFast(); i++){
 355         const TObjString *const obString=(TObjString*)fTrgStrings->At(i);
 356         const TString tString=obString->GetString();
 357         if(CheckCTPTrigger(tString.Data())>0){TriggerPassed=kFALSE; break;}
 358       }
 359     }
 360   }
 361
 362   fTRDCalibraFillHisto->SetCH2dOn(TriggerPassed);
 363   fTRDCalibraFillHisto->SetPH2dOn(TriggerPassed);
 364   for(int i=0; i<usedEntries; i++){
 365     const TClonesArray* inArr = TCAarray[i];
 366     Int_t nbEntries = inArr->GetEntries();
 367     HLTDebug(" %i TRDtracks in tracksArray", nbEntries);
 368     AliTRDtrackV1* trdTrack = 0x0;
 369     for (Int_t ii = 0; ii < nbEntries; ii++){
 370       HLTDebug("%i/%i: ", ii+1, nbEntries);
 371       trdTrack = (AliTRDtrackV1*)inArr->At(ii);
 372       if(trdTrack->GetNumberOfTracklets()<fMinTracklets)continue;
 373       fTRDCalibraFillHisto->UpdateHistogramsV1(trdTrack);
 374       // for(int i3=0; i3<7; i3++)
 375       //   if(trdTrack->GetTracklet(i3))trdTrack->GetTracklet(i3)->Bootstrap(fReconstructor);
 376     }
 377   }
 378
 379   if(!fOutArray->At(0))FormOutput(0);
 380   if(!fDisplayArray->At(0))FormOutput(1);
 381   PushBack(fDisplayArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
 382
 383   if(blockOrObject<0){
 384     TCAarray[0]->Delete();
 385   }
 386
 387   return 0;
 388
 389 }
 390
 391 /**
 392  * Form output array of histrograms
 393  */
 394 //============================================================================
 395 void AliHLTTRDCalibrationComponent::FormOutput(Int_t param)
 396 {
 397   // gain histo
 398   TH2I *hCH2d = fTRDCalibraFillHisto->GetCH2d();
 399   if(!param)fOutArray->Add(hCH2d);
 400   else fDisplayArray->Add(hCH2d);
 401
 402   // drift velocity histo
 403   TProfile2D *hPH2d = fTRDCalibraFillHisto->GetPH2d();
 404   if(!param)fOutArray->Add(hPH2d);
 405   else fDisplayArray->Add(hPH2d);
 406
 407   // PRF histo
 408   TProfile2D *hPRF2d = fTRDCalibraFillHisto->GetPRF2d();
 409   if(!param)fOutArray->Add(hPRF2d);
 410   else fDisplayArray->Add(hPRF2d);
 411
 412   // Vdrift Linear Fit
 413   if(!param){
 414     AliTRDCalibraVdriftLinearFit *hVdriftLinearFitOne=(AliTRDCalibraVdriftLinearFit *)fTRDCalibraFillHisto->GetVdriftLinearFit();
 415     fOutArray->Add(hVdriftLinearFitOne);
 416   }
 417   else{
 418     TH2S *hVdriftLinearFitOne = (TH2S *)(((AliTRDCalibraVdriftLinearFit *)fTRDCalibraFillHisto->GetVdriftLinearFit())->GetLinearFitterHisto(10,kTRUE));
 419     fDisplayArray->Add(hVdriftLinearFitOne);
 420   }
 421
 422   HLTDebug("GetCH2d = 0x%x; NEntries = %i; size = %i", hCH2d, hCH2d->GetEntries(), sizeof(*hCH2d));
 423   hCH2d->Print();
 424   HLTDebug("GetPH2d = 0x%x; NEntries = %i; size = %i", hPH2d, hPH2d->GetEntries(), sizeof(*hPH2d));
 425   hPH2d->Print();
 426   HLTDebug("GetPRF2d = 0x%x; NEntries = %i; size = %i", hPRF2d, hPRF2d->GetEntries(), sizeof(*hPRF2d));
 427   hPRF2d->Print();
 428   //HLTDebug("GetVdriftLinearFit = 0x%x; size = %i", hVdriftLinearFitOne, sizeof(hVdriftLinearFitOne));
 429
 430   HLTDebug("output Array: pointer = 0x%x; NEntries = %i; size = %i", fOutArray, fOutArray->GetEntries(), sizeof(fOutArray));
 431
 432 }
 433
 434 Int_t AliHLTTRDCalibrationComponent::ShipDataToFXS(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 435 {
 436   //fTRDCalibraFillHisto->DestroyDebugStreamer();
 437
 438   AliHLTReadoutList rdList(AliHLTReadoutList::kTRD);
 439
 440   EORCalibration();
 441
 442   fOutArray->Remove(fOutArray->FindObject("AliTRDCalibraVdriftLinearFit"));
 443   //fOutArray->Remove(fOutArray->FindObject("PRF2d"));
 444   //fOutArray->Remove(fOutArray->FindObject("PH2d"));
 445   //fOutArray->Remove(fOutArray->FindObject("CH2d"));
 446
 447   if(!(fOutArray->FindObject("CH2d"))) {
 448     TH2I * ch2d = new TH2I("CH2d","Nz0Nrphi0",100,0.0,300.0,540,0,540);
 449     fOutArray->Add(ch2d);
 450   }
 451
 452   if(!(fOutArray->FindObject("PH2d"))) {
 453     TProfile2D * ph2d = new TProfile2D("PH2d","Nz0Nrphi0",30,-0.05,2.95,540,0,540);
 454     fOutArray->Add(ph2d);
 455   }
 456
 457   if(!(fOutArray->FindObject("PRF2d"))) {
 458     TProfile2D * prf2d = new TProfile2D("PRF2d","Nz0Nrphi0Ngp3",60,-9.0,9.0,540,0,540);
 459     fOutArray->Add(prf2d);
 460   }
 461
 462   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
 463
 464   PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", &rdList );
 465   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 466
 467   return 0;
 468 }
 469
 470 Int_t AliHLTTRDCalibrationComponent::EORCalibration()
 471 {
 472   //Also Fill histograms for the online display
 473   TH2I *hCH2d=(TH2I*)fOutArray->FindObject("CH2d");
 474   TProfile2D *hPH2d=(TProfile2D*)fOutArray->FindObject("PH2d");
 475   TProfile2D *hPRF2d= (TProfile2D*)fOutArray->FindObject("PRF2d");
 476   AliTRDCalibraVdriftLinearFit* hVdriftLinearFit = (AliTRDCalibraVdriftLinearFit*)fOutArray->FindObject("AliTRDCalibraVdriftLinearFit");
 477
 478
 479   if(!hCH2d || !hPH2d || !hPRF2d || !hVdriftLinearFit) return 0;
 480
 481   //Fit
 482   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 483
 484   //Gain
 485   calibra->SetMinEntries(100);
 486   calibra->AnalyseCH(hCH2d);
 487   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 488     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 489   Int_t nbfit       = calibra->GetNumberFit();
 490   Int_t nbE         = calibra->GetNumberEnt();
 491   TH1F *coefgain = 0x0;
 492   // enough statistics
 493   //if ((nbtg >                  0) &&
 494   //   (nbfit        >= 0.2*nbE)) {
 495   // create the cal objects
 496   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 497   TObjArray object           = calibra->GetVectorFit();
 498   AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,kFALSE);
 499   coefgain                   = objgaindet->MakeHisto1DAsFunctionOfDet();
 500   //}
 501   calibra->ResetVectorFit();
 502
 503   // vdrift second method
 504   calibra->SetMinEntries(100); // If there is less than 100
 505   hVdriftLinearFit->FillPEArray();
 506   calibra->AnalyseLinearFitters(hVdriftLinearFit);
 507   nbtg = 540;
 508   nbfit = calibra->GetNumberFit();
 509   nbE   = calibra->GetNumberEnt();
 510   TH1F *coefdriftsecond = 0x0;
 511   // enough statistics
 512   //if ((nbtg >                  0) &&
 513   // (nbfit        >= 0.1*nbE)) {
 514   // create the cal objects
 515   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 516   object  = calibra->GetVectorFit();
 517   AliTRDCalDet *objdriftvelocitydetsecond = calibra->CreateDetObjectVdrift(&object,kTRUE);
 518   objdriftvelocitydetsecond->SetTitle("secondmethodvdrift");
 519   coefdriftsecond  = objdriftvelocitydetsecond->MakeHisto1DAsFunctionOfDet();
 520   //}
 521   calibra->ResetVectorFit();
 522
 523   // vdrift first method
 524   calibra->SetMinEntries(100*20); // If there is less than 20000
 525   calibra->AnalysePH(hPH2d);
 526   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 527     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 528   nbfit        = calibra->GetNumberFit();
 529   nbE          = calibra->GetNumberEnt();
 530   TH1F *coefdrift = 0x0;
 531   TH1F *coeft0 = 0x0;
 532   // enough statistics
 533   //if ((nbtg >                  0) &&
 534   // (nbfit        >= 0.2*nbE)) {
 535   // create the cal objects
 536   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 537   //calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 538   object  = calibra->GetVectorFit();
 539   AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 540   coefdrift        = objdriftvelocitydet->MakeHisto1DAsFunctionOfDet();
 541   object              = calibra->GetVectorFit2();
 542   AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
 543   coeft0        = objtime0det->MakeHisto1DAsFunctionOfDet();
 544   //}
 545   calibra->ResetVectorFit();
 546
 547
 548   //PRF
 549   calibra->SetMinEntries(200);
 550   calibra->AnalysePRFMarianFit(hPRF2d);
 551   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 552     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 553   nbfit        = calibra->GetNumberFit();
 554   nbE          = calibra->GetNumberEnt();
 555   TH1F *coefprf = 0x0;
 556   // enough statistics
 557   //if ((nbtg >                  0) &&
 558   //  (nbfit        >= 0.95*nbE)) {
 559   // create cal pad objects
 560   object            = calibra->GetVectorFit();
 561   TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
 562   coefprf                     = ((AliTRDCalPad *) objPRFpad)->MakeHisto1D();
 563   //}
 564   calibra->ResetVectorFit();
 565
 566
 567   coefgain->SetName("coefgain");
 568   coefprf->SetName("coefprf");
 569   coefdrift->SetName("coefdrift");
 570   coefdriftsecond->SetName("coefdriftsecond");
 571   coeft0->SetName("coeft0");
 572   if(coefgain) fAfterRunArray->Add(coefgain);
 573   if(coefprf) fAfterRunArray->Add(coefprf);
 574   if(coefdrift) fAfterRunArray->Add(coefdrift);
 575   if(coefdriftsecond) fAfterRunArray->Add(coefdriftsecond);
 576   if(coeft0) fAfterRunArray->Add(coeft0);
 577
 578
 579   if(coefgain||coefprf||coefdrift||coeft0||coefdriftsecond) {
 580     PushBack(fAfterRunArray, AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 581   }
 582
 583   // TString fileName="/tmp/CalibHistoDump_run";
 584   // fileName+=AliCDBManager::Instance()->GetRun();
 585   // fileName+=".root";
 586   // HLTInfo("Dumping Histogram file to %s",fileName.Data());
 587   // TFile* file = TFile::Open(fileName, "RECREATE");
 588   // fAfterRunArray->Write();
 589   // fOutArray->Write();
 590   // file->Close();
 591   // HLTInfo("Histogram file dumped");
 592
 593   return 0;
 594 }
 595