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