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