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