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