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