b59eb284604ed208dbeb3a07c8cb1608316e6e82
[u/mrichter/AliRoot.git] / 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->DestroyDebugStreamer();
276   //fTRDCalibraFillHisto->Destroy();
277   //fOutArray->Delete();
278   delete fOutArray; fOutArray=0;
279   fAfterRunArray->Delete();
280   delete fAfterRunArray; fAfterRunArray=0;
281   fDisplayArray->Delete();
282   delete fDisplayArray; fDisplayArray=0;
283   fTrgStrings->Delete();
284   delete fTrgStrings; fTrgStrings=0;
285   return 0;
286 }
287
288 Int_t AliHLTTRDCalibrationComponent::ProcessCalibration(const AliHLTComponent_EventData& /*evtData*/,
289                                                         const AliHLTComponent_BlockData* /*blocks*/,
290                                                         AliHLTComponent_TriggerData& /*trigData*/,
291                                                         AliHLTUInt8_t* /*outputPtr*/,
292                                                         AliHLTUInt32_t& /*size*/,
293                                                         vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
294 {
295   // Process an event
296         
297   TClonesArray* TCAarray[18] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
298   Int_t usedEntries = 0;
299   Int_t blockOrObject = 0;
300   Int_t nTimeBins = -1;
301
302   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(AliHLTTRDDefinitions::fgkTracksDataType); pBlock; pBlock=GetNextInputBlock()) 
303     {
304       TCAarray[0] = fTracksArray;
305       AliHLTTRDUtils::ReadTracks(TCAarray[0], pBlock->fPtr, pBlock->fSize, &nTimeBins);
306       usedEntries = 1;
307       blockOrObject = -1;
308     }  
309
310   for(const TObject *iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkHiLvlTracksDataType); iter; iter = GetNextInputObject()) 
311     {
312       if(blockOrObject<0){
313         HLTError("You may not mix high level and low level!");
314         return -1;
315       }
316
317       TCAarray[usedEntries] = dynamic_cast<TClonesArray*>(const_cast<TObject*>(iter));
318       if(!TCAarray[usedEntries])continue;
319       TObjString* strg = dynamic_cast<TObjString*>(const_cast<TObject*>(GetNextInputObject()));
320       if(!strg)continue;
321
322       nTimeBins = strg->String().Atoi();
323       usedEntries++;
324       blockOrObject = 1;
325     }
326
327   if(!blockOrObject)
328     return 0;
329
330   if(!fSavedTimeBins){
331     if(nTimeBins<0){
332       HLTFatal("Number of timebins is negative!");
333       return -1;
334     }
335     HLTDebug("Saving number of time bins which was read from input block. Value is: %d", nTimeBins);
336     fTRDCalibraFillHisto->Init2Dhistos(nTimeBins); // initialise the histos
337     fTRDCalibraFillHisto->SetNumberClusters(fMinClusters); // At least fMinClusters clusters
338     fTRDCalibraFillHisto->SetNumberClustersf(nTimeBins); // Not more than %d  clusters
339     fSavedTimeBins=kTRUE;
340   }
341
342   Bool_t TriggerPassed = fTakeAllEvents;
343
344   if(fAccRejTrg){
345     if(fAccRejTrg>0){
346       TriggerPassed=kFALSE;
347       for(int i = 0; i < fTrgStrings->GetEntriesFast(); i++){
348         const TObjString *const obString=(TObjString*)fTrgStrings->At(i);
349         const TString tString=obString->GetString();
350         if(CheckCTPTrigger(tString.Data())>0){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(CheckCTPTrigger(tString.Data())>0){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   AliHLTReadoutList rdList(AliHLTReadoutList::kTRD);
438
439   EORCalibration();
440   
441   fOutArray->Remove(fOutArray->FindObject("AliTRDCalibraVdriftLinearFit"));
442   //fOutArray->Remove(fOutArray->FindObject("PRF2d"));
443   //fOutArray->Remove(fOutArray->FindObject("PH2d"));
444   //fOutArray->Remove(fOutArray->FindObject("CH2d"));
445
446   if(!(fOutArray->FindObject("CH2d"))) {
447     TH2I * ch2d = new TH2I("CH2d","Nz0Nrphi0",100,0.0,300.0,540,0,540);
448     fOutArray->Add(ch2d);
449   }
450
451   if(!(fOutArray->FindObject("PH2d"))) {
452     TProfile2D * ph2d = new TProfile2D("PH2d","Nz0Nrphi0",30,-0.05,2.95,540,0,540);
453     fOutArray->Add(ph2d);
454   }
455
456   if(!(fOutArray->FindObject("PRF2d"))) {
457     TProfile2D * prf2d = new TProfile2D("PRF2d","Nz0Nrphi0Ngp3",60,-9.0,9.0,540,0,540);
458     fOutArray->Add(prf2d);
459   }
460
461   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
462
463   PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", &rdList );
464   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
465
466   return 0;
467 }
468
469 Int_t AliHLTTRDCalibrationComponent::EORCalibration()
470 {
471   //Also Fill histograms for the online display
472   TH2I *hCH2d=(TH2I*)fOutArray->FindObject("CH2d");
473   TProfile2D *hPH2d=(TProfile2D*)fOutArray->FindObject("PH2d");
474   TProfile2D *hPRF2d= (TProfile2D*)fOutArray->FindObject("PRF2d");
475   AliTRDCalibraVdriftLinearFit* hVdriftLinearFit = (AliTRDCalibraVdriftLinearFit*)fOutArray->FindObject("AliTRDCalibraVdriftLinearFit");
476  
477
478   if(!hCH2d || !hPH2d || !hPRF2d || !hVdriftLinearFit) return 0; 
479
480   //Fit
481   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
482
483   //Gain
484   calibra->SetMinEntries(100);
485   calibra->AnalyseCH(hCH2d);
486   //Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
487   //  + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
488   //Int_t nbfit       = calibra->GetNumberFit();
489   //Int_t nbE         = calibra->GetNumberEnt();
490   TH1F *coefgain = 0x0;
491   // enough statistics
492   //if ((nbtg >                  0) && 
493   //   (nbfit        >= 0.2*nbE)) {
494   // create the cal objects
495   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
496   TObjArray object           = calibra->GetVectorFit();
497   AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,kFALSE);
498   coefgain                   = objgaindet->MakeHisto1DAsFunctionOfDet();
499   //}
500   calibra->ResetVectorFit();
501
502   // vdrift second method
503   calibra->SetMinEntries(100); // If there is less than 100
504   hVdriftLinearFit->FillPEArray();
505   calibra->AnalyseLinearFitters(hVdriftLinearFit);
506   //nbtg = 540;
507   //nbfit = calibra->GetNumberFit();
508   //nbE   = calibra->GetNumberEnt();
509   TH1F *coefdriftsecond = 0x0;
510   // enough statistics
511   //if ((nbtg >                  0) && 
512   // (nbfit        >= 0.1*nbE)) {
513   // create the cal objects
514   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
515   object  = calibra->GetVectorFit();
516   AliTRDCalDet *objdriftvelocitydetsecond = calibra->CreateDetObjectVdrift(&object,kTRUE);
517   objdriftvelocitydetsecond->SetTitle("secondmethodvdrift");
518   coefdriftsecond  = objdriftvelocitydetsecond->MakeHisto1DAsFunctionOfDet();
519   //}
520   calibra->ResetVectorFit();
521   
522   // vdrift first method
523   calibra->SetMinEntries(100*20); // If there is less than 20000
524   calibra->AnalysePH(hPH2d);
525   //nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
526   //  + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
527   //nbfit        = calibra->GetNumberFit();
528   //nbE          = calibra->GetNumberEnt();
529   TH1F *coefdrift = 0x0;
530   TH1F *coeft0 = 0x0;
531   // enough statistics
532   //if ((nbtg >                  0) && 
533   // (nbfit        >= 0.2*nbE)) {
534   // create the cal objects
535   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
536   //calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
537   object  = calibra->GetVectorFit();
538   AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
539   coefdrift        = objdriftvelocitydet->MakeHisto1DAsFunctionOfDet();
540   object              = calibra->GetVectorFit2();
541   AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
542   coeft0        = objtime0det->MakeHisto1DAsFunctionOfDet();
543   //}
544   calibra->ResetVectorFit();
545            
546
547   //PRF
548   calibra->SetMinEntries(200); 
549   calibra->AnalysePRFMarianFit(hPRF2d);
550   //nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
551   //  + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
552   //nbfit        = calibra->GetNumberFit();
553   //nbE          = calibra->GetNumberEnt();
554   TH1F *coefprf = 0x0;
555   // enough statistics
556   //if ((nbtg >                  0) && 
557   //  (nbfit        >= 0.95*nbE)) {
558   // create cal pad objects 
559   object            = calibra->GetVectorFit();
560   TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
561   coefprf                     = ((AliTRDCalPad *) objPRFpad)->MakeHisto1D();
562   //}
563   calibra->ResetVectorFit();
564
565
566   coefgain->SetName("coefgain");
567   coefprf->SetName("coefprf");
568   coefdrift->SetName("coefdrift");
569   coefdriftsecond->SetName("coefdriftsecond");
570   coeft0->SetName("coeft0");
571   if(coefgain) fAfterRunArray->Add(coefgain);
572   if(coefprf) fAfterRunArray->Add(coefprf);
573   if(coefdrift) fAfterRunArray->Add(coefdrift);
574   if(coefdriftsecond) fAfterRunArray->Add(coefdriftsecond);
575   if(coeft0) fAfterRunArray->Add(coeft0);
576   
577
578   if(coefgain||coefprf||coefdrift||coeft0||coefdriftsecond) {
579     PushBack(fAfterRunArray, AliHLTTRDDefinitions::fgkEORCalibrationDataType);
580   }
581
582   // TString fileName="/tmp/CalibHistoDump_run";
583   // fileName+=AliCDBManager::Instance()->GetRun();
584   // fileName+=".root";
585   // HLTInfo("Dumping Histogram file to %s",fileName.Data());
586   // TFile* file = TFile::Open(fileName, "RECREATE");
587   // fAfterRunArray->Write();
588   // fOutArray->Write();
589   // file->Close();
590   // HLTInfo("Histogram file dumped");
591
592   return 0;
593 }       
594