Update of the noise procedure
[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 // Authors:                                                               //
29 //   R. Bailhache (R.Bailhache@gsi.de)                                    //
30 //   W. Monange   (w.monange@gsi.de)                                      //
31 //   F. Kramer    (kramer@ikf.uni-frankfurt.de)                           //
32 //                                                                        //
33 ////////////////////////////////////////////////////////////////////////////
34
35 #include <TFile.h>
36 #include <TProfile2D.h>
37 #include <TStopwatch.h>
38 #include <TObjString.h>
39 #include <TString.h>
40 #include <TList.h>
41 #include <TCollection.h>
42 #include <TSAXParser.h>
43
44 #include "AliCDBMetaData.h"
45 #include "AliLog.h"
46
47 #include "AliTRDPreprocessor.h"
48 #include "AliTRDSensorArray.h"
49 #include "AliTRDCalibraFit.h"
50 #include "AliTRDCalibraMode.h"
51 #include "AliTRDCalibPadStatus.h"
52 #include "AliTRDSaxHandler.h"
53 #include "Cal/AliTRDCalDet.h"
54 #include "Cal/AliTRDCalPad.h"
55 #include "Cal/AliTRDCalPadStatus.h"
56 #include "Cal/AliTRDCalDCS.h"
57 #include "Cal/AliTRDCalSingleChamberStatus.h"
58 #include "Cal/AliTRDCalROC.h"
59
60
61 ClassImp(AliTRDPreprocessor)
62
63 //______________________________________________________________________________________________
64 AliTRDPreprocessor::AliTRDPreprocessor(AliShuttleInterface *shuttle)
65   :AliPreprocessor("TRD", shuttle)
66   ,fVdriftHLT(0)
67 {
68   //
69   // Constructor
70   //
71
72  AddRunType("PHYSICS");
73  AddRunType("STANDALONE");
74  AddRunType("PEDESTAL");
75
76 }
77
78 //______________________________________________________________________________________________
79 AliTRDPreprocessor::~AliTRDPreprocessor()
80 {
81   //
82   // Destructor
83   //
84
85 }
86
87 //______________________________________________________________________________________________
88 void AliTRDPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
89 {
90   //
91   // Initialization routine for the TRD preprocessor
92   //
93
94   AliPreprocessor::Initialize(run,startTime,endTime);
95
96 }
97
98 //______________________________________________________________________________________________
99 UInt_t AliTRDPreprocessor::Process(TMap* dcsAliasMap)
100 {
101   //
102   // Process DCS and calibration part for HLT
103   //
104
105   TString runType = GetRunType();
106   Log(Form("runtype %s\n",runType.Data()));
107   
108   // always process the configuration data
109 /*  Int_t resultDCSC = */ProcessDCSConfigData(); // for testing!
110   // if there was an error, return with its code
111 //  if (resultDCSC != 0) return resultDCSC; // for testing!
112
113   if (runType=="PEDESTAL"){
114     if(ExtractPedestals()) return 1;
115     return 0;
116   } 
117
118   if ((runType=="PHYSICS") || (runType=="STANDALONE")){
119     // HLT if On
120     //TString runPar = GetRunParameter("HLTStatus");
121     //if(runPar=="1") {
122     if(GetHLTStatus()) {
123       /*if(*/ExtractHLT()/*) return 1*/; // for testing!
124     } 
125     // DAQ if HLT failed
126     if(!fVdriftHLT) {
127       /*if(*/ExtractDriftVelocityDAQ()/*) return 1*/; // for testing!
128     }
129     // DCS
130     if(ProcessDCS(dcsAliasMap)) return 1;
131   }
132   
133   return 0;  
134   
135 }
136
137 //______________________________________________________________________________
138 Bool_t AliTRDPreprocessor::ProcessDCS()
139 {
140   //
141   // Default process DCS method
142   //
143
144   TString runType = GetRunType();
145   if ((runType == "PHYSICS") || (runType == "STANDALONE")) {
146     return kTRUE;
147   }
148   return kFALSE;
149
150 }
151
152 //______________________________________________________________________________
153 Bool_t AliTRDPreprocessor::ProcessDCS(TMap *dcsAliasMap)
154 {
155   //
156   // Process DCS method
157   //
158
159   Bool_t error = kFALSE;
160
161   AliCDBMetaData metaData;
162   metaData.SetBeamPeriod(0);
163   metaData.SetResponsible("Wilfried Monange/Raphaelle Bailhache");
164   metaData.SetComment("TRD calib test");
165
166   Log("****** DCS ******\n");
167         
168   TObjArray * list=AliTRDSensorArray::GetList ();
169         
170   if (list == 0x0) {
171     Log ("Error during AliTRDSensorArray::GetList");
172     Log ("DCS will not be processing");
173     return kTRUE;
174   }
175
176   Int_t nEntries = list->GetEntries ();
177   Log (Form ("%d alias loaded", nEntries));
178                 
179   Bool_t * results=new Bool_t [nEntries];
180   Int_t  * nGraph=new Int_t [nEntries];
181                 
182   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
183                         
184     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
185                         
186     oneTRDDCS->SetStartTime (TTimeStamp (fStartTime));
187     oneTRDDCS->SetEndTime (TTimeStamp (fEndTime));
188                         
189     Log(Form("Processing DCS : \"%s\"", oneTRDDCS->GetStoreName ().Data ()));
190                         
191     TMap * map;
192
193     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
194                 
195     nGraph [iAlias] = map->GetEntries ();
196                 
197     if (nGraph [iAlias] == 0) {
198       Log("No TGraph for this dcsDatapointAlias : not stored");
199       results [iAlias] = kFALSE;
200       error  = kTRUE;
201       continue;
202     }
203                 
204     oneTRDDCS->SetGraph(map);
205     results[iAlias]=Store("Calib", oneTRDDCS->GetStoreName().Data(), oneTRDDCS, &metaData, 0, kTRUE); 
206     delete map;         
207
208     //results [iAlias] = StoreReferenceData("Calib", oneTRDDCS->GetStoreName ().Data (), oneTRDDCS, &metaData); 
209
210     if (!results[iAlias]) {
211       AliError("Problem during StoreRef DCS");
212       error=kTRUE;
213     }
214
215     //BEGIN TEST (should not be removed ...)
216     /*
217     oneTRDDCS->ClearGraph();
218     oneTRDDCS->ClearFit();
219     oneTRDDCS->SetDiffCut2 (0.1);
220     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
221     oneTRDDCS->SetGraph (map);
222     Store("Calib", ("cut_"+oneTRDDCS->GetStoreName()).Data(), oneTRDDCS, &metaData, 0, kTRUE); 
223     delete map;
224
225
226     if(iAlias==1 || iAlias==19) continue;
227     
228     oneTRDDCS->ClearGraph();
229     oneTRDDCS->ClearFit();
230     oneTRDDCS->SetDiffCut2(0);
231     map=oneTRDDCS->ExtractDCS(dcsAliasMap);
232     oneTRDDCS->MakeSplineFit(map);
233     Store("Calib", ("fit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE); 
234     delete map;
235
236      
237     oneTRDDCS->ClearGraph(); 
238     oneTRDDCS->ClearFit();
239     oneTRDDCS->SetDiffCut2 (0.1);
240     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
241     oneTRDDCS->MakeSplineFit(map);
242     Store("Calib", ("cutfit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE); 
243     delete map;
244     */    
245     //END TEST
246
247   }
248                 
249   Log ("         Summury of DCS :\n");
250   Log (Form("%30s %10s %10s", "dcsDatapointAlias", "Stored ?", "# graph"));
251   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
252     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
253     Log (Form ("%30s %10s %4d", 
254                oneTRDDCS->GetStoreName ().Data (),
255                results[iAlias] ? "ok" : "X",
256                nGraph [iAlias]));
257   }
258   Log ("*********** End of DCS **********");
259   
260   delete results;
261   delete nGraph;
262
263   return error;
264
265 }
266
267 //______________________________________________________________________________________________
268 Bool_t AliTRDPreprocessor::ExtractPedestals()
269 {
270   //
271   // Pedestal running on LDCs at the DAQ
272   //
273
274   //
275   // The reference data are stored in:
276   // PadStatus1 for sm-00-01-02-09-10-11
277   // PadStatus2 for sm-03-04-05-12-13-14
278   // PadStatus3 for sm-06-07-08-15-16-17
279   // PadStatus0 if nothing found..means problems
280   //
281
282   Bool_t error = kFALSE;
283
284   // Init a AliTRDCalibPadStatus
285   AliTRDCalibPadStatus calPedSum = AliTRDCalibPadStatus();
286
287   AliCDBMetaData metaData;
288   metaData.SetBeamPeriod(0);
289   metaData.SetResponsible("Raphaelle Bailhache");
290   metaData.SetComment("TRD calib test");
291   
292   // Sum the contributions of the LDCs
293   TList * listpad = GetFileSources(kDAQ,"PADSTATUS");
294   if (!listpad) {
295     Log("No list found for the PEDESTRAL Run");
296     return kTRUE;
297   }
298   
299   // loop through all files from LDCs  
300   UInt_t index = 0;
301   while (listpad->At(index)!=NULL) {
302     TObjString* fileNameEntry = (TObjString*) listpad->At(index);
303     if (fileNameEntry != NULL)
304       {
305         TString fileName = GetFile(kDAQ, "PADSTATUS",
306                                    fileNameEntry->GetString().Data());
307         if(fileName.Length() ==0){
308           Log(Form("Error by retrieving the file %d for the pedestal",(Int_t)index));
309           delete listpad;
310           return kTRUE;
311         }
312         
313         TFile *f = TFile::Open(fileName);
314         AliTRDCalibPadStatus *calPed;
315         f->GetObject("calibpadstatus",calPed);
316         
317         if(calPed){
318           
319           Int_t ldc = 0; 
320
321           // analyse
322           //calPed->AnalyseHisto();
323                   
324           // Add to the calPedSum
325           for (Int_t idet=0; idet<540; idet++) {
326             AliTRDCalROC *rocMean  = calPed->GetCalRocMean(idet, kFALSE);
327             if ( rocMean )  {
328               calPedSum.SetCalRocMean(rocMean,idet);
329               ldc = (Int_t) (idet / 30);
330             }
331             AliTRDCalROC *rocRMS = calPed->GetCalRocRMS(idet, kFALSE);
332             if ( rocRMS )  {
333               calPedSum.SetCalRocRMS(rocRMS,idet);
334             }
335             AliTRDCalROC *rocMeand  = calPed->GetCalRocMeand(idet, kFALSE);
336             if ( rocMeand )  {
337               calPedSum.SetCalRocMeand(rocMeand,idet);
338             }
339             AliTRDCalROC *rocRMSd = calPed->GetCalRocRMSd(idet, kFALSE);
340             if ( rocRMSd )  {
341               calPedSum.SetCalRocRMSd(rocRMSd,idet);
342             }
343           }// det loop
344
345           if((ldc==0) || (ldc==1) || (ldc==2) || (ldc==9) || (ldc==10) || (ldc==11)) ldc = 1;
346           if((ldc==3) || (ldc==4) || (ldc==5) || (ldc==12) || (ldc==13) || (ldc==14)) ldc = 2;
347           if((ldc==6) || (ldc==7) || (ldc==8) || (ldc==15) || (ldc==16) || (ldc==17)) ldc = 3;
348         
349           // store as reference data
350           TString name("PadStatus");
351           name += ldc;
352           if(!StoreReferenceData("DAQData",(const char *)name,(TObject *) calPed,&metaData)){
353             Log(Form("Error storing AliTRDCalibPadStatus object %d as reference data",(Int_t)index));
354             error = kTRUE;
355           }
356
357         } // calPed
358       } // fileNameEntry
359     ++index;
360   }// while (list)
361
362   Log(Form("%d elements found in the list for the pedestal",(Int_t)index));
363   if(index==0){
364     delete listpad;
365     return kTRUE;
366   }
367
368   //
369   // Create pedestal 
370   //
371     
372   // Create Pad Status
373   AliTRDCalPadStatus *calPadStatus = calPedSum.CreateCalPadStatus();
374   // Create Noise 
375   //Make the AliTRDCalPad
376   AliTRDCalPad *calPad2 = calPedSum.CreateCalPad();
377   //Make the AliTRDCalDet correspondant
378   AliTRDCalDet *calDet = calPedSum.CreateCalDet();
379  
380   //
381   // Take the noise and Pad status from the previous OCDB
382   //
383
384   AliTRDCalPad *calPadPrevious=0;
385   AliCDBEntry* entry = GetFromOCDB("Calib", "PadNoise");
386   if (entry) calPadPrevious = (AliTRDCalPad*)entry->GetObject();
387   if ( calPadPrevious==NULL ) {
388      Log("AliTRDPreprocsessor: No previous TRD pad noise entry available.\n");
389      calPadPrevious = new AliTRDCalPad("PadNoise", "PadNoise");
390   }
391
392   AliTRDCalPadStatus *calPadStatusPrevious=0;
393   entry = GetFromOCDB("Calib", "PadStatus");
394   if (entry) calPadStatusPrevious = (AliTRDCalPadStatus*)entry->GetObject();
395   if ( calPadStatusPrevious==NULL ) {
396     Log("AliTRDPreprocsessor: No previous TRD pad status entry available.\n");
397     calPadStatusPrevious = new AliTRDCalPadStatus("padstatus", "padstatus");
398     for (Int_t idet=0; idet<540; ++idet)
399       {
400         AliTRDCalSingleChamberStatus *calROC = calPadStatusPrevious->GetCalROC(idet);
401         for(Int_t k = 0; k < calROC->GetNchannels(); k++){
402           calROC->SetStatus(k,AliTRDCalPadStatus::kMasked);
403         }
404       }
405   }
406
407   
408   // Loop over detectors for check
409   for (Int_t det=0; det<AliTRDgeometry::kNdet; ++det)  {
410     
411     // noise
412     AliTRDCalROC *calROCPreviousNoise = calPadPrevious->GetCalROC(det);
413     AliTRDCalROC *calROCNoise         = calPad2->GetCalROC(det);
414
415     // padstatus
416     AliTRDCalSingleChamberStatus *calROCPreviousStatus = calPadStatusPrevious->GetCalROC(det);
417     AliTRDCalSingleChamberStatus *calROCStatus         = calPadStatus->GetCalROC(det);
418     
419     
420     // loop over first half and second half chamber
421     for(Int_t half = 0; half < 2; half++){
422
423       Bool_t data         = AreThereDataPedestal(calROCStatus,(Bool_t)half);
424       printf("There are data for the detector %d the half %d: %d\n",det,half,data);
425       if(!data){
426         // look if data in the OCDB
427         Bool_t dataPrevious = AreThereDataPedestal(calROCPreviousStatus,(Bool_t)half);
428         // if no data at all, set to default value
429         if(!dataPrevious){
430           SetDefaultStatus(*calROCStatus,(Bool_t)half);
431           SetDefaultNoise(*calROCNoise,(Bool_t)half);
432         }
433         else{
434           // if data, set to previous value
435           SetStatus(*calROCStatus,calROCPreviousStatus,(Bool_t)half);
436           SetNoise(*calROCNoise,calROCPreviousNoise,(Bool_t)half);
437         }
438       }
439     }
440   }
441   
442   //
443   // Store  
444   //  
445
446   AliCDBMetaData md3; 
447   md3.SetObjectClassName("AliTRDCalPadStatus");
448   md3.SetResponsible("Raphaelle Bailhache");
449   md3.SetBeamPeriod(1);
450   md3.SetComment("TRD calib test");
451   if(!Store("Calib","PadStatus"    ,(TObject *)calPadStatus, &md3, 0, kTRUE)){
452     Log("Error storing the pedestal");
453     delete listpad;
454     return kTRUE;
455   }
456
457   AliCDBMetaData md4; 
458   md4.SetObjectClassName("AliTRDCalPad");
459   md4.SetResponsible("Raphaelle Bailhache");
460   md4.SetBeamPeriod(1);
461   md4.SetComment("TRD calib test");
462   if(!Store("Calib","PadNoise"    ,(TObject *)calPad2, &md4, 0, kTRUE)){
463     Log("Error storing the pedestal");
464     delete listpad;
465     return kTRUE;
466   }
467   
468   AliCDBMetaData md5; 
469   md5.SetObjectClassName("AliTRDCalDet");
470   md5.SetResponsible("Raphaelle Bailhache");
471   md5.SetBeamPeriod(1);
472   md5.SetComment("TRD calib test");
473   if(!Store("Calib","DetNoise"    ,(TObject *)calDet, &md5, 0, kTRUE)){
474     Log("Error storing the pedestal");
475     delete listpad;
476     return kTRUE;
477   }  
478
479   delete listpad;
480   return error; 
481   
482 }
483 //__________________________________________________________________
484 Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus *calROCStatus, Bool_t second){
485
486   //
487   // Data for this half chamber
488   //
489
490   Bool_t data         = kFALSE;
491   Int_t nCols         = calROCStatus->GetNcols();
492   Int_t nCol0         = 0;
493   Int_t nColE         = (Int_t) nCols/2 - 2;
494   if(second) {
495     nCol0 = nColE + 4;
496     nColE = nCols;
497   }
498   for(Int_t col = nCol0; col < nColE; col++){
499     for(Int_t row = 0; row < calROCStatus->GetNrows(); row++){
500       //printf("ismasked %d\n",(Int_t)calROCStatus->IsMasked(col,row));
501       if(!calROCStatus->IsMasked(col,row)) {
502         data = kTRUE;
503         continue;
504       }
505     }
506     if(data) continue;
507   }
508
509   return data;
510   
511 }
512 //__________________________________________________________________
513 void AliTRDPreprocessor::SetDefaultStatus(AliTRDCalSingleChamberStatus &calROCStatus, Bool_t second){
514
515   //
516   // default status for this half chamber
517   //
518
519   Int_t nCols         = calROCStatus.GetNcols();
520   Int_t nCol0         = 0;
521   Int_t nColE         = (Int_t) nCols/2;
522   if(second) {
523     nCol0 = nColE;
524     nColE = nCols;
525   }
526   for(Int_t col = nCol0; col < nColE; col++){
527     for(Int_t row = 0; row < calROCStatus.GetNrows(); row++){
528       calROCStatus.SetStatus(col,row,0);
529     }
530   }
531 }
532 //__________________________________________________________________
533 void AliTRDPreprocessor::SetStatus(AliTRDCalSingleChamberStatus &calROCStatus, AliTRDCalSingleChamberStatus *calROCStatusPrevious,Bool_t second){
534
535   //
536   // previous status for this half chamber
537   //
538
539   Int_t nCols         = calROCStatus.GetNcols();
540   Int_t nCol0         = 0;
541   Int_t nColE         = (Int_t) nCols/2;
542   if(second) {
543     nCol0 = nColE;
544     nColE = nCols;
545   }
546   for(Int_t col = nCol0; col < nColE; col++){
547     for(Int_t row = 0; row < calROCStatus.GetNrows(); row++){
548       calROCStatus.SetStatus(col,row,calROCStatusPrevious->GetStatus(col,row));
549     }
550   }
551 }
552 //__________________________________________________________________
553 void AliTRDPreprocessor::SetDefaultNoise(AliTRDCalROC &calROCNoise, Bool_t second){
554
555   //
556   // default noise for this half chamber
557   //
558
559   Int_t nCols         = calROCNoise.GetNcols();
560   Int_t nCol0         = 0;
561   Int_t nColE         = (Int_t) nCols/2;
562   if(second) {
563     nCol0 = nColE;
564     nColE = nCols;
565   }
566   for(Int_t col = nCol0; col < nColE; col++){
567     for(Int_t row = 0; row < calROCNoise.GetNrows(); row++){
568       calROCNoise.SetValue(col,row,0.12);
569     }
570   }
571 }
572 //__________________________________________________________________
573 void AliTRDPreprocessor::SetNoise(AliTRDCalROC &calROCNoise, AliTRDCalROC *calROCNoisePrevious, Bool_t second){
574
575   //
576   // previous noise for this half chamber
577   //
578
579   Int_t nCols         = calROCNoise.GetNcols();
580   Int_t nCol0         = 0;
581   Int_t nColE         = (Int_t) nCols/2;
582   if(second) {
583     nCol0 = nColE;
584     nColE = nCols;
585   }
586   for(Int_t col = nCol0; col < nColE; col++){
587     for(Int_t row = 0; row < calROCNoise.GetNrows(); row++){
588       calROCNoise.SetValue(col,row,calROCNoisePrevious->GetValue(col,row));
589     }
590   }
591 }
592 //______________________________________________________________________________________________
593 Bool_t AliTRDPreprocessor::ExtractDriftVelocityDAQ()
594 {
595   //
596   // Drift velocity DA running on monitoring servers at the DAQ
597   //
598
599   Bool_t error = kFALSE; 
600
601   // Objects for HLT and DAQ zusammen
602   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
603   AliCDBMetaData metaData;
604   metaData.SetBeamPeriod(0);
605   metaData.SetResponsible("Raphaelle Bailhache");
606   metaData.SetComment("TRD calib test");
607   // Store the infos for the detector
608   AliCDBMetaData md1; 
609   md1.SetObjectClassName("AliTRDCalDet");
610   md1.SetResponsible("Raphaelle Bailhache");
611   md1.SetBeamPeriod(0);
612   md1.SetComment("TRD calib test");
613   // Store the infos for the pads
614   AliCDBMetaData md2; 
615   md2.SetObjectClassName("AliTRDCalPad");
616   md2.SetResponsible("Raphaelle Bailhache");
617   md2.SetBeamPeriod(0);
618   md2.SetComment("TRD calib test");
619
620   // Take the file from the DAQ file exchange server
621   TList *listdaq = GetFileSources(kDAQ,"VDRIFT");
622   if (!listdaq) {
623     Log("No list found for vdrift (DAQ)");
624     return kTRUE;
625   }
626   
627   if(listdaq->GetSize() !=1){
628     Log(Form("Problem on the size of the list: %d (DAQ)",listdaq->GetSize()));
629     delete listdaq;
630     return kTRUE;
631   }
632   
633   TObjString* fileNameEntry = (TObjString*) listdaq->At(0);
634   if(fileNameEntry != NULL){
635     TString fileName = GetFile(kDAQ, "VDRIFT",
636                                fileNameEntry->GetString().Data());
637     if(fileName.Length() ==0){
638       Log("Error retrieving the file vdrift (DAQ)");
639       delete listdaq;
640       return kTRUE;
641     }
642     TFile *filedaq = TFile::Open(fileName);
643     TProfile2D *histodriftvelocity = (TProfile2D *) filedaq->Get("PH2d");
644     if (histodriftvelocity) {
645       
646       // store as reference data
647       if(!StoreReferenceData("DAQData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
648         Log("Error storing 2D Profile for vdrift from the DAQ");
649         error = kTRUE;
650       }
651       
652       // analyse
653       
654       Log("Take the PH reference data. Now we will try to fit\n");
655       calibra->SetMinEntries(2000); // If there is less than 2000
656       calibra->AnalysePH(histodriftvelocity);
657       
658       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
659         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
660       Int_t nbfit        = calibra->GetNumberFit();
661       Int_t nbE        = calibra->GetNumberEnt();
662       
663       // if enough statistics store the results
664       if ((nbtg >                  0) && 
665           (nbfit        >= 0.95*nbE)) {
666         // create the cal objects
667         TObjArray object      = calibra->GetVectorFit();
668         AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
669         TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
670         object              = calibra->GetVectorFit2();
671         AliTRDCalDet *objtime0det         = calibra->CreateDetObjectT0(&object,kTRUE);
672         TObject *objtime0pad         = calibra->CreatePadObjectT0();
673         calibra->ResetVectorFit();
674         // store
675         if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
676           Log("Error storing the calibration object for the chamber vdrift (DAQ)");
677           error = kTRUE;
678         }
679         if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
680           Log("Error storing the calibration object for the chamber t0 (DAQ)");
681           error = kTRUE;
682         }
683         if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
684           Log("Error storing the calibration object for the local drift velocity (DAQ)");
685           error = kTRUE;
686         }
687         if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
688           Log("Error storing the calibration object for the local time0 (DAQ)");
689           error = kTRUE;
690         }
691       }
692       else{
693         Log("Not enough statistics for the average pulse height (DAQ)");
694       }
695     } // histo here
696   }// if fileNameEntry
697   
698   delete listdaq; 
699   return error; 
700   
701 }
702
703 //______________________________________________________________________________________________
704 Bool_t AliTRDPreprocessor::ExtractHLT()
705 {
706   //
707   // Gain, vdrift and PRF calibration running on HLT
708   // return kTRUE if NULL pointer to the list
709   //
710
711   Bool_t error = kFALSE;
712
713   // Objects for HLT and DAQ zusammen
714   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
715   AliCDBMetaData metaData;
716   metaData.SetBeamPeriod(0);
717   metaData.SetResponsible("Raphaelle Bailhache");
718   metaData.SetComment("TRD calib test");
719   // Store the infos for the detector
720   AliCDBMetaData md1; 
721   md1.SetObjectClassName("AliTRDCalDet");
722   md1.SetResponsible("Raphaelle Bailhache");
723   md1.SetBeamPeriod(0);
724   md1.SetComment("TRD calib test");
725   // Store the infos for the pads
726   AliCDBMetaData md2; 
727   md2.SetObjectClassName("AliTRDCalPad");
728   md2.SetResponsible("Raphaelle Bailhache");
729   md2.SetBeamPeriod(0);
730   md2.SetComment("TRD calib test");
731   
732   // Take the file from the HLT file exchange server
733   TList *listhlt = GetFileSources(kHLT,"GAINDRIFTPRF");
734   if (!listhlt) {
735     Log("No list found for the HLT");
736     return kTRUE;
737   }
738
739   if(listhlt->GetSize() != 1) {
740     Log(Form("Problem on the size of the list: %d (HLT)",listhlt->GetSize()));
741     delete listhlt;
742     return kTRUE;
743   }
744   
745   TObjString* fileNameEntry = (TObjString*) listhlt->At(0);
746   if(fileNameEntry != NULL){
747     TString fileName = GetFile(kHLT, "GAINDRIFTPRF",
748                                fileNameEntry->GetString().Data());
749     if(fileName.Length() ==0){
750       Log("Error retrieving the file (HLT)");
751       delete listhlt;
752       return kTRUE;
753     }
754     // Take the file
755     TFile *filehlt = TFile::Open(fileName);
756     
757     // gain
758     TH2I *histogain = (TH2I *) filehlt->Get("CH2d");
759     histogain->SetDirectory(0);
760     if (histogain) {
761       // store the reference data
762       if(!StoreReferenceData("HLTData","Gain",(TObject *) histogain,&metaData)){
763         Log("Error storing 2D histos for gain");
764         error = kTRUE;
765       }
766       // analyse
767       Log("Take the CH reference data. Now we will try to fit\n");
768       calibra->SetMinEntries(1000); // If there is less than 1000 entries in the histo: no fit
769       calibra->AnalyseCH(histogain);
770       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
771         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
772       Int_t nbfit       = calibra->GetNumberFit();
773       Int_t nbE         = calibra->GetNumberEnt();
774       // enough statistics
775       if ((nbtg >                  0) && 
776           (nbfit        >= 0.95*nbE)) {
777         // create the cal objects
778         TObjArray object           = calibra->GetVectorFit();
779         AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object);
780         TObject *objgainpad        = calibra->CreatePadObjectGain();
781         // store them
782         if(!Store("Calib","ChamberGainFactor",(TObject *) objgaindet         ,&md1,0,kTRUE)){
783           Log("Error storing the calibration object for the chamber gain");
784           error = kTRUE;
785         }
786         if(!Store("Calib","LocalGainFactor"  ,(TObject *) objgainpad         ,&md2,0,kTRUE)){
787           Log("Error storing the calibration object for the local gain factor");
788           error = kTRUE;
789         }
790       }
791       calibra->ResetVectorFit();
792     }// if histogain
793     
794     // vdrift
795     fVdriftHLT = kFALSE;
796     TProfile2D *histodriftvelocity = (TProfile2D *) filehlt->Get("PH2d");
797     histodriftvelocity->SetDirectory(0);
798     if (histodriftvelocity) {
799       // store the reference data
800       if(!StoreReferenceData("HLTData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
801         Log("Error storing 2D Profile for average pulse height (HLT)");
802         error = kTRUE;
803       }
804       // analyse
805       Log("Take the PH reference data. Now we will try to fit\n");
806       calibra->SetMinEntries(1000*20); // If there is less than 20000
807       calibra->AnalysePH(histodriftvelocity);
808       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
809         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
810       Int_t nbfit        = calibra->GetNumberFit();
811       Int_t nbE          = calibra->GetNumberEnt();
812       // enough statistics
813       if ((nbtg >                  0) && 
814           (nbfit        >= 0.95*nbE)) {
815         // create the cal objects
816         TObjArray object  = calibra->GetVectorFit();
817         AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
818         TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
819         object              = calibra->GetVectorFit2();
820         AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
821         TObject *objtime0pad       = calibra->CreatePadObjectT0();
822         // store them
823         if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
824           Log("Error storing the calibration object for the chamber vdrift (HLT)");
825           error = kTRUE;                
826         }
827         if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
828           Log("Error storing the calibration object for the chamber t0 (HLT)");
829           error = kTRUE;
830         }
831         if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
832           Log("Error storing the calibration object for the local drift velocity (HLT)");
833           error = kTRUE;
834         }
835         if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
836           Log("Error storing the calibration object for the local time0 (HLT)");
837           error = kTRUE;
838         }
839         fVdriftHLT = kTRUE;
840       }
841       calibra->ResetVectorFit();
842     }// if TProfile2D
843     
844     // prf
845     TProfile2D *histoprf = (TProfile2D *) filehlt->Get("PRF2d");
846     histoprf->SetDirectory(0);
847     if (histoprf) {
848       // store reference data
849       if(!StoreReferenceData("HLTData","PRF",(TObject *) histoprf,&metaData)){
850         Log("Error storing the 2D Profile for Pad Response Function");
851         error = kTRUE;
852       }
853       // analyse
854       Log("Take the PRF reference data. Now we will try to fit\n");
855       calibra->SetMinEntries(600); // If there is less than 20000
856       calibra->AnalysePRFMarianFit(histoprf);
857       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
858         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
859       Int_t nbfit        = calibra->GetNumberFit();
860       Int_t nbE          = calibra->GetNumberEnt();
861       // enough statistics
862       if ((nbtg >                  0) && 
863           (nbfit        >= 0.95*nbE)) {
864         // create cal pad objects 
865         TObjArray object            = calibra->GetVectorFit();
866         TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
867         // store them
868         if(!Store("Calib","PRFWidth"         ,(TObject *) objPRFpad          ,&md2,0,kTRUE)){
869           Log("Error storing the calibration object for the Pad Response Function");
870           error = kTRUE;
871         }
872       }
873       calibra->ResetVectorFit();
874     }// if PRF
875   }// if fileNameEntry
876   
877   delete listhlt;
878   return error;
879   
880 }
881
882 //_____________________________________________________________________________
883 UInt_t AliTRDPreprocessor::ProcessDCSConfigData()
884 {
885   // 
886   // process the configuration of FEE, PTR and GTU
887   // reteive XML file from the DCS FXS
888   // parse it and store TObjArrays in the CDB
889   // return 0 for success, otherwise:
890   // 5: could not get the file from the FXS
891   // 6: ERROR in XML validation: something wrong with the file
892   // 7: ERROR while creating calibration objects in the handler
893   // 8: error while storing data in the CDB
894   // > 100: SaxHandler error code
895   //
896
897   Log("Processing the DCS config summary file.");
898
899   // get the XML file
900   const char * xmlFile = GetFile(kDCS,"CONFIGSUMMARY","");
901   if (xmlFile == NULL) {
902     return 5;
903     Log(Form("File %s not found!",xmlFile));
904   }
905
906   // create parser and parse
907   TSAXParser saxParser;
908   AliTRDSaxHandler saxHandler;
909   saxParser.ConnectToHandler("AliTRDSaxHandler", &saxHandler);
910   saxParser.ParseFile(xmlFile);
911
912   // report errors if present
913   if (saxParser.GetParseCode() == 0) {
914     Log("XML file validation OK");
915   } else {
916     Log(Form("ERROR in XML file validation. Parsecode: %s", saxParser.GetParseCode()));
917     return 6;
918   }
919   if (saxHandler.GetHandlerStatus() != 0) {
920     Log(Form("ERROR while creating calibration objects. Error code: %s", saxHandler.GetHandlerStatus()));
921     return 7;
922   }
923
924   // get the calibration object storing the data from the handler
925   AliTRDCalDCS* fCalDCSObj = saxHandler.GetCalDCSObj();
926
927   // store the DCS calib data in the CDB
928   AliCDBMetaData metaData1;
929   metaData1.SetBeamPeriod(0);
930   metaData1.SetResponsible("Frederick Kramer");
931   metaData1.SetComment("DCS configuration data in one AliTRDCalDCS object.");
932   if (!Store("Calib", "DCSCONFIG", fCalDCSObj, &metaData1, 0, kTRUE)) {
933     Log("problems while storing DCS config data object");
934     return 8;
935   }
936
937   return 0;
938 }
939