Modifications in the calibration/preprocessor for new raw data version
[u/mrichter/AliRoot.git] / TRD / AliTRDPreprocessor.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ////////////////////////////////////////////////////////////////////////////
19 //                                                                        //
20 // This class is a first implementation for the TRD.                      //
21 // It takes data from HLT and computes the parameters                     //
22 // and stores both reference data and online calibration                  //
23 // parameters in the CDB                                                  //
24 // It alsotakes DCS data, does spline fits                                //
25 // and stores both reference data and spline fits results                 //
26 // in the CDB                                                             //
27 //                                                                        //
28 // Author:                                                                //
29 //   R. Bailhache (R.Bailhache@gsi.de)                                    //
30 //   W. Monange   (w.monange@gsi.de)                                      //
31 //                                                                        //
32 ////////////////////////////////////////////////////////////////////////////
33
34 #include "AliTRDPreprocessor.h"
35
36 #include <TFile.h>
37 #include <TProfile2D.h>
38 #include <TStopwatch.h>
39 #include <TObjString.h>
40 #include <TString.h>
41 #include <TList.h>
42 #include <TCollection.h>
43
44 #include "AliCDBMetaData.h"
45 #include "AliLog.h"
46
47 #include "AliTRDSensorArray.h"
48 #include "AliTRDCalibraFit.h"
49 #include "AliTRDCalibraMode.h"
50 #include "AliTRDCalibPadStatus.h"
51 #include "Cal/AliTRDCalDet.h"
52 #include "Cal/AliTRDCalPadStatus.h"
53
54 ClassImp(AliTRDPreprocessor)
55
56 //______________________________________________________________________________________________
57 AliTRDPreprocessor::AliTRDPreprocessor(AliShuttleInterface *shuttle)
58   :AliPreprocessor("TRD", shuttle),
59    fVdriftHLT(0)
60 {
61   //
62   // Constructor
63   //
64
65 }
66
67 //______________________________________________________________________________________________
68 AliTRDPreprocessor::~AliTRDPreprocessor()
69 {
70   //
71   // Destructor
72   //
73
74 }
75
76 //______________________________________________________________________________________________
77 void AliTRDPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
78 {
79   //
80   // Initialization routine for the TRD preprocessor
81   //
82
83   AliPreprocessor::Initialize(run,startTime,endTime);
84
85 }
86
87 //______________________________________________________________________________________________
88 UInt_t AliTRDPreprocessor::Process(TMap* dcsAliasMap)
89 {
90   //
91   // Process DCS and calibration part for HLT
92   //
93
94   TString runType = GetRunType();
95   Log(Form("runtype %s\n",runType.Data()));
96   
97   if (runType=="PEDESTAL_RUN"){
98     if(ExtractPedestals()) return 1;
99     return 0;
100   } 
101
102   //
103   // DCS
104   //
105   
106   if(ProcessDCS(dcsAliasMap)) return 1;
107
108   //
109   // Process the calibration data for the HLT and DAQ part
110   //
111   
112   if (runType=="PHYSICS"){
113     //TString runPar = GetRunParameter("HLTStatus")
114     //if(runPar=="1") {
115     if(ExtractHLT()) return 1;
116     //if (fResult > 0) return fResult;
117     //} 
118     if(!fVdriftHLT) {
119       if(ExtractDriftVelocityDAQ()) return 1;
120     }
121   }
122   
123   return 0;  
124   
125 }
126
127 //______________________________________________________________________________
128 Bool_t AliTRDPreprocessor::ProcessDCS(TMap * dcsAliasMap)
129 {
130   Bool_t error=kFALSE;
131
132   AliCDBMetaData metaData;
133   metaData.SetBeamPeriod(0);
134   metaData.SetResponsible("Wilfried Monange/Raphaelle Bailhache");
135   metaData.SetComment("TRD calib test");
136         
137         
138   Log ("****** DCS ******\n");
139         
140   TObjArray * list=AliTRDSensorArray::GetList ();
141         
142   if (list == 0x0) {
143     Log ("Error during AliTRDSensorArray::GetList");
144     Log ("DCS will not be processing");
145     return kTRUE;
146   }
147
148   Int_t nEntries = list->GetEntries ();
149   Log (Form ("%d alias loaded", nEntries));
150                 
151   Bool_t * results=new Bool_t [nEntries];
152   Int_t  * nGraph=new Int_t [nEntries];
153                 
154   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
155                         
156     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
157                         
158     oneTRDDCS->SetStartTime (TTimeStamp (fStartTime));
159     oneTRDDCS->SetEndTime (TTimeStamp (fEndTime));
160                         
161     Log (Form("Processing DCS : \"%s\"", oneTRDDCS->GetStoreName ().Data ()));
162                         
163     TMap * map;
164
165     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
166                 
167     nGraph [iAlias] = map->GetEntries ();
168                 
169     if (nGraph [iAlias] == 0) {
170       Log("No TGraph for this dcsDatapointAlias : not stored");
171       results [iAlias] = kFALSE;
172       continue;
173     }
174                 
175     oneTRDDCS->SetGraph(map);
176     results[iAlias]=Store("Calib", oneTRDDCS->GetStoreName().Data(), oneTRDDCS, &metaData, 0, kTRUE); 
177     delete map;         
178
179     //results [iAlias] = StoreReferenceData("Calib", oneTRDDCS->GetStoreName ().Data (), oneTRDDCS, &metaData); 
180
181
182     if (!results[iAlias]) {
183       AliError("Problem during StoreRef DCS");
184       error=kTRUE;
185     }
186
187
188     //BEGIN TEST (should not be removed ...)
189     /*
190     oneTRDDCS->ClearGraph();
191     oneTRDDCS->ClearFit();
192     oneTRDDCS->SetDiffCut2 (0.1);
193     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
194     oneTRDDCS->SetGraph (map);
195     Store("Calib", ("cut_"+oneTRDDCS->GetStoreName()).Data(), oneTRDDCS, &metaData, 0, kTRUE); 
196     delete map;
197
198
199     if(iAlias==1 || iAlias==19) continue;
200     
201     oneTRDDCS->ClearGraph();
202     oneTRDDCS->ClearFit();
203     oneTRDDCS->SetDiffCut2(0);
204     map=oneTRDDCS->ExtractDCS(dcsAliasMap);
205     oneTRDDCS->MakeSplineFit(map);
206     Store("Calib", ("fit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE); 
207     delete map;
208
209      
210     oneTRDDCS->ClearGraph(); 
211     oneTRDDCS->ClearFit();
212     oneTRDDCS->SetDiffCut2 (0.1);
213     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
214     oneTRDDCS->MakeSplineFit(map);
215     Store("Calib", ("cutfit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE); 
216     delete map;
217     */    
218     //END TEST
219
220       
221       
222   }
223                 
224   Log ("         Summury of DCS :\n");
225   Log (Form("%30s %10s %10s", "dcsDatapointAlias", "Stored ?", "# graph"));
226   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
227     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
228     Log (Form ("%30s %10s %4d", 
229                oneTRDDCS->GetStoreName ().Data (),
230                results[iAlias] ? "ok" : "X",
231                nGraph [iAlias]));
232   }
233   Log ("*********** End of DCS **********");
234   
235   delete results;
236   delete nGraph;
237
238   return error;
239 }
240
241 //______________________________________________________________________________________________
242 Bool_t AliTRDPreprocessor::ExtractPedestals()
243 {
244   //
245   // Pedestal running on LDCs at the DAQ
246   //
247  
248   Bool_t error = kFALSE;
249
250   // Init a AliTRDCalibPadStatus
251   AliTRDCalibPadStatus calPedSum = AliTRDCalibPadStatus();
252
253   AliCDBMetaData metaData;
254   metaData.SetBeamPeriod(0);
255   metaData.SetResponsible("Raphaelle Bailhache");
256   metaData.SetComment("TRD calib test");
257   
258   // Sum the contributions of the LDCs
259   TList * listpad = GetFileSources(kDAQ,"PADSTATUS");
260   if (!listpad) {
261     Log("No list found for the PEDESTRAL Run");
262     return kTRUE;
263   }
264   
265   // loop through all files from LDCs
266   
267   UInt_t index = 0;
268   while (listpad->At(index)!=NULL) {
269     TObjString* fileNameEntry = (TObjString*) listpad->At(index);
270     if (fileNameEntry != NULL)
271       {
272         TString fileName = GetFile(kDAQ, "PADSTATUS",
273                                    fileNameEntry->GetString().Data());
274         if(fileName.Length() ==0){
275           Log(Form("Error by retrieving the file %d for the pedestal",(Int_t)index));
276           delete listpad;
277           return kTRUE;
278         }
279         
280         TFile *f = TFile::Open(fileName);
281         AliTRDCalibPadStatus *calPed;
282         f->GetObject("calibpadstatus",calPed);
283         
284         if(calPed){
285           
286           Int_t sm = -1; 
287
288           // analyse
289           //calPed->AnalyseHisto();
290                   
291           // Add to the calPedSum
292           for (Int_t idet=0; idet<540; idet++) {
293             AliTRDCalROC *rocMean  = calPed->GetCalRocMean(idet, kFALSE);
294             if ( rocMean )  {
295               calPedSum.SetCalRocMean(rocMean,idet);
296               sm = (Int_t) (idet / 30);
297             }
298             AliTRDCalROC *rocRMS = calPed->GetCalRocRMS(idet, kFALSE);
299             if ( rocRMS )  {
300               calPedSum.SetCalRocRMS(rocRMS,idet);
301             }
302           }// det loop
303
304           // store as reference data
305           TString name("PadStatus");
306           name += sm;
307           if(!StoreReferenceData("DAQData",(const char *)name,(TObject *) calPed,&metaData)){
308             Log(Form("Error storing AliTRDCalibPadStatus object %d as reference data",(Int_t)index));
309             error = kTRUE;
310           }
311
312         } // calPed
313       } // fileNameEntry
314     ++index;
315   }// while (list)
316   Log(Form("%d elements found in the list for the pedestal",(Int_t)index));
317   if(index==0){
318     delete listpad;
319     return kTRUE;
320   }
321   //
322   // Store pedestal entry to OCDB
323   //
324   
325   
326   // Create Pad Status
327   AliTRDCalPadStatus *calPadStatus = calPedSum.CreateCalPadStatus();
328   AliCDBMetaData md3; 
329   md3.SetObjectClassName("AliTRDCalPadStatus");
330   md3.SetResponsible("Raphaelle Bailhache");
331   md3.SetBeamPeriod(1);
332   md3.SetComment("TRD calib test");
333   if(!Store("Calib","PadStatus"    ,(TObject *)calPadStatus, &md3, 0, kTRUE)){
334     Log("Error storing the pedestal");
335     delete listpad;
336     return kTRUE;
337   }
338
339   // Create Noise 
340   //Make the AliTRDCalPad
341   AliTRDCalPad *calPad2 = calPedSum.CreateCalPad();
342   AliCDBMetaData md4; 
343   md4.SetObjectClassName("AliTRDCalPad");
344   md4.SetResponsible("Raphaelle Bailhache");
345   md4.SetBeamPeriod(1);
346   md4.SetComment("TRD calib test");
347   if(!Store("Calib","PadNoise"    ,(TObject *)calPad2, &md4, 0, kTRUE)){
348     Log("Error storing the pedestal");
349     delete listpad;
350     return kTRUE;
351   }
352   //Make the AliTRDCalDet correspondant
353   AliTRDCalDet *calDet = calPedSum.CreateCalDet();
354   AliCDBMetaData md5; 
355   md5.SetObjectClassName("AliTRDCalDet");
356   md5.SetResponsible("Raphaelle Bailhache");
357   md5.SetBeamPeriod(1);
358   md5.SetComment("TRD calib test");
359   if(!Store("Calib","DetNoise"    ,(TObject *)calDet, &md5, 0, kTRUE)){
360     Log("Error storing the pedestal");
361     delete listpad;
362     return kTRUE;
363   }  
364
365   delete listpad;
366   return error; 
367
368 }
369 //______________________________________________________________________________________________
370 Bool_t AliTRDPreprocessor::ExtractDriftVelocityDAQ()
371 {
372   //
373   // Drift velocity DA running on monitoring servers at the DAQ
374   //
375
376   Bool_t error = kFALSE; 
377
378   // Objects for HLT and DAQ zusammen
379   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
380   AliCDBMetaData metaData;
381   metaData.SetBeamPeriod(0);
382   metaData.SetResponsible("Raphaelle Bailhache");
383   metaData.SetComment("TRD calib test");
384   // Store the infos for the detector
385   AliCDBMetaData md1; 
386   md1.SetObjectClassName("AliTRDCalDet");
387   md1.SetResponsible("Raphaelle Bailhache");
388   md1.SetBeamPeriod(0);
389   md1.SetComment("TRD calib test");
390   // Store the infos for the pads
391   AliCDBMetaData md2; 
392   md2.SetObjectClassName("AliTRDCalPad");
393   md2.SetResponsible("Raphaelle Bailhache");
394   md2.SetBeamPeriod(0);
395   md2.SetComment("TRD calib test");
396
397
398
399
400   // Take the file from the DAQ file exchange server
401   TList *listdaq = GetFileSources(kDAQ,"VDRIFT");
402   if (!listdaq) {
403     Log("No list found for vdrift (DAQ)");
404     return kTRUE;
405   }
406   
407   if(listdaq->GetSize() !=1){
408     Log(Form("Problem on the size of the list: %d (DAQ)",listdaq->GetSize()));
409     delete listdaq;
410     return kTRUE;
411   }
412   
413   TObjString* fileNameEntry = (TObjString*) listdaq->At(0);
414   if(fileNameEntry != NULL){
415     TString fileName = GetFile(kDAQ, "VDRIFT",
416                                fileNameEntry->GetString().Data());
417     if(fileName.Length() ==0){
418       Log("Error retrieving the file vdrift (DAQ)");
419       delete listdaq;
420       return kTRUE;
421     }
422     TFile *filedaq = TFile::Open(fileName);
423     TProfile2D *histodriftvelocity = (TProfile2D *) filedaq->Get("PH2d");
424     if (histodriftvelocity) {
425       
426       // store as reference data
427       if(!StoreReferenceData("DAQData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
428         Log("Error storing 2D Profile for vdrift from the DAQ");
429         error = kTRUE;
430       }
431       
432       // analyse
433       
434       Log("Take the PH reference data. Now we will try to fit\n");
435       calibra->SetMinEntries(2000); // If there is less than 2000
436       calibra->AnalysePH(histodriftvelocity);
437       
438       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
439         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
440       Int_t nbfit        = calibra->GetNumberFit();
441       Int_t nbE        = calibra->GetNumberEnt();
442       
443       // if enough statistics store the results
444       if ((nbtg >                  0) && 
445           (nbfit        >= 0.95*nbE)) {
446         // create the cal objects
447         TObjArray object      = calibra->GetVectorFit();
448         AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
449         TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
450         object              = calibra->GetVectorFit2();
451         AliTRDCalDet *objtime0det         = calibra->CreateDetObjectT0(&object,kTRUE);
452         TObject *objtime0pad         = calibra->CreatePadObjectT0();
453         calibra->ResetVectorFit();
454         // store
455         if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
456           Log("Error storing the calibration object for the chamber vdrift (DAQ)");
457           error = kTRUE;
458         }
459         if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
460           Log("Error storing the calibration object for the chamber t0 (DAQ)");
461           error = kTRUE;
462         }
463         if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
464           Log("Error storing the calibration object for the local drift velocity (DAQ)");
465           error = kTRUE;
466         }
467         if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
468           Log("Error storing the calibration object for the local time0 (DAQ)");
469           error = kTRUE;
470         }
471       }
472       else{
473         Log("Not enough statistics for the average pulse height (DAQ)");
474       }
475     } // histo here
476   }// if fileNameEntry
477   
478   delete listdaq; 
479   return error; 
480   
481 }
482 //______________________________________________________________________________________________
483 Bool_t AliTRDPreprocessor::ExtractHLT()
484 {
485   //
486   // Gain, vdrift and PRF calibration running on HLT
487   // return kFALSE if NULL pointer to the list
488   //
489
490   Bool_t error = kFALSE;
491
492   // Objects for HLT and DAQ zusammen
493   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
494   AliCDBMetaData metaData;
495   metaData.SetBeamPeriod(0);
496   metaData.SetResponsible("Raphaelle Bailhache");
497   metaData.SetComment("TRD calib test");
498   // Store the infos for the detector
499   AliCDBMetaData md1; 
500   md1.SetObjectClassName("AliTRDCalDet");
501   md1.SetResponsible("Raphaelle Bailhache");
502   md1.SetBeamPeriod(0);
503   md1.SetComment("TRD calib test");
504   // Store the infos for the pads
505   AliCDBMetaData md2; 
506   md2.SetObjectClassName("AliTRDCalPad");
507   md2.SetResponsible("Raphaelle Bailhache");
508   md2.SetBeamPeriod(0);
509   md2.SetComment("TRD calib test");
510
511   
512   // Take the file from the HLT file exchange server
513   TList *listhlt = GetFileSources(kHLT,"GAINDRIFTPRF");
514   if (!listhlt) {
515     Log("No list found for the HLT");
516     return kTRUE;
517   }
518
519   if(listhlt->GetSize() != 1) {
520     Log(Form("Problem on the size of the list: %d (HLT)",listhlt->GetSize()));
521     delete listhlt;
522     return kTRUE;
523   }
524   
525   TObjString* fileNameEntry = (TObjString*) listhlt->At(0);
526   if(fileNameEntry != NULL){
527     TString fileName = GetFile(kHLT, "GAINDRIFTPRF",
528                                fileNameEntry->GetString().Data());
529     if(fileName.Length() ==0){
530       Log("Error retrieving the file (HLT)");
531       delete listhlt;
532       return kTRUE;
533     }
534     // Take the file
535     TFile *filehlt = TFile::Open(fileName);
536     
537     
538     // gain
539     TH2I *histogain = (TH2I *) filehlt->Get("CH2d");
540     histogain->SetDirectory(0);
541     if (histogain) {
542       // store the reference data
543       if(!StoreReferenceData("HLTData","Gain",(TObject *) histogain,&metaData)){
544         Log("Error storing 2D histos for gain");
545         error = kTRUE;
546       }
547       // analyse
548       Log("Take the CH reference data. Now we will try to fit\n");
549       calibra->SetMinEntries(1000); // If there is less than 1000 entries in the histo: no fit
550       calibra->AnalyseCH(histogain);
551       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
552         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
553       Int_t nbfit       = calibra->GetNumberFit();
554       Int_t nbE         = calibra->GetNumberEnt();
555       // enough statistics
556       if ((nbtg >                  0) && 
557           (nbfit        >= 0.95*nbE)) {
558         // create the cal objects
559         TObjArray object           = calibra->GetVectorFit();
560         AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,calibra->GetScaleFitFactor(),kTRUE);
561         TObject *objgainpad        = calibra->CreatePadObjectGain();
562         // store them
563         if(!Store("Calib","ChamberGainFactor",(TObject *) objgaindet         ,&md1,0,kTRUE)){
564           Log("Error storing the calibration object for the chamber gain");
565           error = kTRUE;
566         }
567         if(!Store("Calib","LocalGainFactor"  ,(TObject *) objgainpad         ,&md2,0,kTRUE)){
568           Log("Error storing the calibration object for the local gain factor");
569           error = kTRUE;
570         }
571       }
572       calibra->ResetVectorFit();
573     }// if histogain
574     
575     
576     
577     // vdrift
578     fVdriftHLT = kFALSE;
579     TProfile2D *histodriftvelocity = (TProfile2D *) filehlt->Get("PH2d");
580     histodriftvelocity->SetDirectory(0);
581     if (histodriftvelocity) {
582       // store the reference data
583       if(!StoreReferenceData("HLTData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
584         Log("Error storing 2D Profile for average pulse height (HLT)");
585         error = kTRUE;
586       }
587       // analyse
588       Log("Take the PH reference data. Now we will try to fit\n");
589       calibra->SetMinEntries(1000*20); // If there is less than 20000
590       calibra->AnalysePH(histodriftvelocity);
591       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
592         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
593       Int_t nbfit        = calibra->GetNumberFit();
594       Int_t nbE          = calibra->GetNumberEnt();
595       // enough statistics
596       if ((nbtg >                  0) && 
597           (nbfit        >= 0.95*nbE)) {
598         // create the cal objects
599         TObjArray object  = calibra->GetVectorFit();
600         AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
601         TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
602         object              = calibra->GetVectorFit2();
603         AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
604         TObject *objtime0pad       = calibra->CreatePadObjectT0();
605         // store them
606         if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
607           Log("Error storing the calibration object for the chamber vdrift (HLT)");
608           error = kTRUE;                
609         }
610         if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
611           Log("Error storing the calibration object for the chamber t0 (HLT)");
612           error = kTRUE;
613         }
614         if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
615           Log("Error storing the calibration object for the local drift velocity (HLT)");
616           error = kTRUE;
617         }
618         if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
619           Log("Error storing the calibration object for the local time0 (HLT)");
620           error = kTRUE;
621         }
622         fVdriftHLT = kTRUE;
623       }
624       calibra->ResetVectorFit();
625     }// if TProfile2D
626     
627     
628     // prf
629     TProfile2D *histoprf = (TProfile2D *) filehlt->Get("PRF2d");
630     histoprf->SetDirectory(0);
631     if (histoprf) {
632       // store reference data
633       if(!StoreReferenceData("HLTData","PRF",(TObject *) histoprf,&metaData)){
634         Log("Error storing the 2D Profile for Pad Response Function");
635         error = kTRUE;
636       }
637       // analyse
638       Log("Take the PRF reference data. Now we will try to fit\n");
639       calibra->SetMinEntries(600); // If there is less than 20000
640       calibra->AnalysePRFMarianFit(histoprf);
641       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
642         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
643       Int_t nbfit        = calibra->GetNumberFit();
644       Int_t nbE          = calibra->GetNumberEnt();
645       // enough statistics
646       if ((nbtg >                  0) && 
647           (nbfit        >= 0.95*nbE)) {
648         // create cal pad objects 
649         TObjArray object            = calibra->GetVectorFit();
650         TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
651         // store them
652         if(!Store("Calib","PRFWidth"         ,(TObject *) objPRFpad          ,&md2,0,kTRUE)){
653           Log("Error storing the calibration object for the Pad Response Function");
654           error = kTRUE;
655         }
656       }
657       calibra->ResetVectorFit();
658     }// if PRF
659   }// if fileNameEntry
660   
661   delete listhlt;
662   return error;
663   
664 }