8a2365f000e6c9db93876b606c62de754cd7e8eb
[u/mrichter/AliRoot.git] / TRD / Macros / DumpOCDBtoTree.C
1 ////////////////////////////////////////////
2 // Author: Ionut Cristian Arsene          //          
3 // email:  iarsene@mail.cern.ch           //
4 ////////////////////////////////////////////
5 // Use this macro to create ROOT trees with time dependent information from the TRD OCDB
6 //
7 // Usage:
8 //
9 // void DumpOCDBtoTree(const Char_t* outFilename,
10 //                     const Char_t* runListFilename,
11 //                     Int_t firstRun = -1, Int_t lastRun = -1,
12 //                     const Char_t* storage = "alien://folder=/alice/data/2010/OCDB/",
13 //                     Bool_t getHVInfo = kTRUE,
14 //                     Bool_t getCalibrationInfo = kFALSE,
15 //                     Bool_t getGasInfo = kFALSE,
16 //                     Bool_t getStatusInfo = kFALSE,
17 //                     Bool_t getGoofieInfo = kFALSE,
18 //                     Bool_t getDCSInfo = kFALSE,
19 //                     Bool_t getGRPInfo = kTRUE)
20 //
21 //    * runListFilename   - name of an ascii file containing run numbers
22 //    * outFilename       - name of the root file where the TRD OCDB information tree to be stored
23 //    * firstRun, lastRun - lowest and highest run numbers (from the ascii file) to be dumped
24 //                          if these numbers are not specified (-1) all run numbers in the input ascii file will
25 //                          be used. If the run list file is not specified then all runs in this interval
26 //                          will be queried
27 //    * getHVInfo         - flag to switch on/off HV information (HV anode and drift currents/voltages)
28 //    * getCalibrationInfo- flag to switch on/off calibration information (gain, pedestal, T0, vdrift, pad status)
29 //    * getGasInfo        - flag to switch on/off gas related information (gas composition, overpressure, temperature)
30 //    * getStatusInfo     - flag to switch on/off status information (trd_chamberStatus)
31 //    * getGoofieInfo     - flag to switch on/off goofie information (gain, HV, pressure, temperature, drift velocity,
32 //                          gas composition)
33 //    * getDCSInfo        - flag to switch on/off DCS information
34 //    * getGRPInfo        - flag to switch on/off GRP information --> there will be no time information in the output tree
35 //    * storage           - path of the OCDB database (if it is on alien, be sure to have a valid/active token)
36
37
38 #include <iostream>
39 #include <fstream>
40 #include <string>
41 #include <exception>
42 #include "TVectorD.h"
43 #include "TTreeStream.h"
44 #include "TObjString.h"
45 #include "TTimeStamp.h"
46 #include "TH1.h"
47 #include "TMath.h"
48 #include "TObjArray.h"
49 #include "TFile.h"
50 #include "TSystem.h"
51 #include "TGrid.h"
52 #include "AliCDBManager.h"
53 #include "AliCDBEntry.h"
54 #include "AliTRDcalibDB.h"
55 #include "AliGRPObject.h"
56 #include "AliDCSSensor.h"
57 #include "AliTRDSensorArray.h"
58 #include "AliTRDCalDet.h"
59 #include "AliTRDCalPad.h"
60 #include "AliTRDCalROC.h"
61 #include "AliTRDCalPadStatus.h"
62 #include "AliTRDCalChamberStatus.h"
63 #include "AliTRDCalSingleChamberStatus.h"
64 #include "AliTRDCalDCS.h"
65 #include "AliTRDCalDCSFEE.h"
66 using namespace std;
67
68 // global variables
69 // histograms used for extracting the mean and RMS of calibration parameters
70 TH1F *gRunWiseHisto;
71 TH1F *gSuperModuleWiseHisto;
72 TH1F *gChamberWiseHisto;
73
74 // global constants
75 const Int_t gkSuperModuleStatus[18] = {1, 1, 0, 0, 0, 0, 0, 1, 1,   // (1-installed)
76                                        1, 1, 0, 0, 0, 0, 0, 0, 1};  
77
78 void MakeRunListFromOCDB(const Char_t* directory, const Char_t* outfile, Bool_t fromAlien=kFALSE);
79 void ProcessTRDSensorArray(AliTRDSensorArray*, TTimeStamp, TVectorD&);
80 void ProcessTRDCalibArray(AliTRDCalDet*, AliTRDCalPad*, TString, Double_t&, Double_t&,
81                           TVectorD&, TVectorD&, TVectorD&, TVectorD&);
82 void ProcessTRDstatus(AliTRDCalChamberStatus*, AliTRDCalPadStatus*, Float_t&, TVectorD&, TVectorD&);
83 void ProcessTRDCalDCSFEE(AliTRDCalDCS*, AliTRDCalDCS*, Int_t&, Int_t&, Int_t&, Int_t&, Int_t&, Int_t&, Bool_t&, 
84                          TVectorD&, TVectorD&);
85
86 //__________________________________________________________________________________________
87 void DumpOCDBtoTree(const Char_t* outFilename,
88                     const Char_t* runListFilename,
89                     Int_t firstRun = -1, Int_t lastRun = -1,
90                     const Char_t* storage = "alien://folder=/alice/data/2010/OCDB/",
91                     Bool_t getHVInfo = kTRUE,
92                     Bool_t getCalibrationInfo = kFALSE,
93                     Bool_t getGasInfo = kFALSE,
94                     Bool_t getStatusInfo = kFALSE,
95                     Bool_t getGoofieInfo = kFALSE,
96                     Bool_t getDCSInfo = kFALSE,
97                     Bool_t getGRPInfo = kTRUE) {
98   //
99   // Main function to steer the extraction of TRD OCDB information
100   //
101
102
103   TTimeStamp jobStartTime;
104   // if the storage is on alien than we need to do some extra stuff
105   TString storageString(storage);
106   if(storageString.Contains("alien://")) {
107     TGrid::Connect("alien://");
108   }
109   // initialize the OCDB manager
110   AliCDBManager *manager = AliCDBManager::Instance();
111   manager->SetDefaultStorage(storage);
112     
113   // initialize the tree
114   TTreeSRedirector *treeStreamer = new TTreeSRedirector(outFilename);
115   
116   // initialize the histograms used for extracting the mean and RMS
117   gRunWiseHisto = new TH1F("runHisto", "runHisto", 200, -10.0, 10.0);
118   gSuperModuleWiseHisto = new TH1F("smHisto", "smHisto", 200, -10.0, 10.0);
119   gChamberWiseHisto = new TH1F("chamberHisto", "chamberHisto", 200, -10.0, 10.0);
120
121   // open the ascii file with run numbers
122   ifstream in;
123   if(runListFilename[0]!='\0')
124     in.open(runListFilename);
125
126   // if a run list file was not specified then use the run range
127   Int_t currRun;
128   if(runListFilename[0]=='\0' && firstRun!=-1 && lastRun!=-1)
129     currRun = firstRun-1;  
130
131   TVectorD runs;
132   TVectorD rejectedRuns;
133   TTimeStamp loopStartTime;
134
135   // loop over runs
136   while(1) {
137     // check if we still have run numbers in the file or provided range
138     if(runListFilename[0]=='\0' && firstRun!=-1 && lastRun!=-1) {
139       currRun++;
140       if(currRun>lastRun) break;
141     }
142     if(runListFilename[0]!='\0') {
143       if(in.eof()) break;
144       if(!(in>>currRun)) continue;
145       if(currRun < (firstRun==-1 ? 0 : firstRun) ||
146          currRun > (lastRun==-1 ? 999999999 : lastRun))
147         continue;
148     }
149
150     cout << "run = " << currRun << endl;
151     // check if the run was processed already
152     Bool_t runProcessed = kFALSE;
153     for(Int_t iRun=0; iRun<runs.GetNoElements(); iRun++) {
154       if(runs[iRun]==currRun) runProcessed = kTRUE;
155     }
156     if(runProcessed) {
157       cout << "Run processed already" << endl;
158       continue;
159     }
160
161     manager->SetRun(currRun);
162
163     // Get the GRP data. Only runs with a corresponding GRP entry in the OCDB 
164     // will be processed.
165     time_t startTime = 0;
166     time_t endTime = 0;
167     TObjString runType("UNKNOWN");
168     AliDCSSensor *cavern_pressure = 0x0;
169     AliDCSSensor *surface_pressure = 0x0;
170     UInt_t detectorMask = 0;
171     AliCDBEntry *entry = (getGRPInfo ? manager->Get("GRP/GRP/Data") : 0);
172     if(entry) {
173       entry->SetOwner(kFALSE);
174     }
175     AliGRPObject* grpObject = 0;
176     if(entry) 
177       grpObject = dynamic_cast<AliGRPObject*>(entry->GetObject());
178     else {
179       if(getGRPInfo) {
180         // add the run number to the list of rejected runs
181         rejectedRuns.ResizeTo(rejectedRuns.GetNoElements()+1);
182         rejectedRuns[rejectedRuns.GetNoElements()-1] = currRun;
183         continue;
184       }
185     }
186     if(grpObject) {
187       startTime = grpObject->GetTimeStart();
188       endTime = grpObject->GetTimeEnd();
189       runType = grpObject->GetRunType().Data();
190       cavern_pressure = grpObject->GetCavernAtmosPressure();
191       surface_pressure = grpObject->GetSurfaceAtmosPressure();
192       detectorMask = grpObject->GetDetectorMask();
193       TTimeStamp start(grpObject->GetTimeStart());
194       TTimeStamp end(grpObject->GetTimeEnd());
195       cout << "Start time: " << start.GetDate()/10000 << "/" 
196            << (start.GetDate()/100)-(start.GetDate()/10000)*100 << "/" 
197            << start.GetDate()%100 << "   "
198            << start.GetTime()/10000 << ":"
199            << (start.GetTime()/100)-(start.GetTime()/10000)*100 << ":" 
200            << start.GetTime()%100 << endl;
201       cout << "End time: " << end.GetDate()/10000 << "/" 
202            << (end.GetDate()/100)-(end.GetDate()/10000)*100 << "/" 
203            << end.GetDate()%100 << "   "
204            << end.GetTime()/10000 << ":"
205            << (end.GetTime()/100)-(end.GetTime()/10000)*100 << ":"
206            << end.GetTime()%100 << endl;
207       cout << "Run type = " << grpObject->GetRunType().Data() << endl;
208     }
209     else {
210       if(getGRPInfo) {
211         cout << "No GRP info available --> skiping this run!" << endl;
212         // add the run number to the list of rejected runs
213         rejectedRuns.ResizeTo(rejectedRuns.GetNoElements()+1);
214         rejectedRuns[rejectedRuns.GetNoElements()-1] = currRun;
215         continue;
216       }
217     }
218
219     // remove runs with zero time duration
220     if(getGRPInfo && startTime==endTime) {
221       if(grpObject) delete grpObject;
222       // add the run number to the list of rejected runs
223       rejectedRuns.ResizeTo(rejectedRuns.GetNoElements()+1);
224       rejectedRuns[rejectedRuns.GetNoElements()-1] = currRun;
225       continue;
226     }
227
228     // time step for time dependent information (change this if you need something else)
229     UInt_t dTime = TMath::Max((endTime-startTime)/20, Long_t(5*60));
230
231     // get monitoring information
232     AliTRDSensorArray *anodeISensors = 0;
233     AliTRDSensorArray *anodeUSensors = 0;
234     AliTRDSensorArray *driftISensors = 0;
235     AliTRDSensorArray *driftUSensors = 0;
236     AliTRDSensorArray *temperatureSensors = 0;
237     AliTRDSensorArray *chamberStatusSensors = 0;
238     AliTRDSensorArray *overpressureSensors = 0;
239     AliTRDSensorArray *gasCO2Sensors = 0;
240     AliTRDSensorArray *gasH2OSensors = 0;
241     AliTRDSensorArray *gasO2Sensors = 0;
242     //  AliTRDSensorArray *adcClkPhaseSensors = 0;
243
244     if(getHVInfo) {
245       // anode hv currents (per chamber)
246       entry = manager->Get("TRD/Calib/trd_hvAnodeImon");
247       if(entry) {
248         entry->SetOwner(kTRUE);
249         anodeISensors = (AliTRDSensorArray*)entry->GetObject();
250       }
251
252       // anode hv voltages (per chamber)
253       entry = manager->Get("TRD/Calib/trd_hvAnodeUmon");
254       if(entry) {
255         entry->SetOwner(kTRUE);
256         anodeUSensors = (AliTRDSensorArray*)entry->GetObject();
257       }
258
259       // drift hv currents (per chamber)
260       entry = manager->Get("TRD/Calib/trd_hvDriftImon");
261       if(entry) {
262         entry->SetOwner(kTRUE);
263         driftISensors = (AliTRDSensorArray*)entry->GetObject();
264       }
265     
266       // drift hv voltages (per chamber)
267       entry = manager->Get("TRD/Calib/trd_hvDriftUmon");
268       if(entry) {
269         entry->SetOwner(kTRUE);
270         driftUSensors = (AliTRDSensorArray*)entry->GetObject();
271       }
272     }  // end if(getHVInfo)
273
274     if(getStatusInfo) {
275       // chamber status (from sensors)
276       entry = manager->Get("TRD/Calib/trd_chamberStatus");
277       if(entry) {
278         entry->SetOwner(kTRUE);
279         chamberStatusSensors = (AliTRDSensorArray*)entry->GetObject();
280       }
281     }   // end if(getStatusInfo)
282
283     if(getGasInfo) {
284       // temperatures from chamber sensors (per chamber)
285       entry = manager->Get("TRD/Calib/trd_envTemp");
286       if(entry) {
287         entry->SetOwner(kTRUE);
288         temperatureSensors = (AliTRDSensorArray*)entry->GetObject();
289       }
290     
291       // gas overpressure (per whole TRD)
292       entry = manager->Get("TRD/Calib/trd_gasOverpressure");
293       if(entry) {
294         entry->SetOwner(kTRUE);
295         overpressureSensors = (AliTRDSensorArray*)entry->GetObject();
296       }
297     
298       // gas CO2 fraction (whole TRD)
299       entry = manager->Get("TRD/Calib/trd_gasCO2");
300       if(entry) {
301         entry->SetOwner(kTRUE);
302         gasCO2Sensors = (AliTRDSensorArray*)entry->GetObject();
303       }
304     
305       // gas H2O fraction (whole TRD)
306       entry = manager->Get("TRD/Calib/trd_gasH2O");
307       if(entry) {
308         entry->SetOwner(kTRUE);
309         gasH2OSensors = (AliTRDSensorArray*)entry->GetObject();
310       }
311       
312       // gas O2 fraction (whole TRD)
313       entry = manager->Get("TRD/Calib/trd_gasO2");
314       if(entry) {
315         entry->SetOwner(kTRUE);
316         gasO2Sensors = (AliTRDSensorArray*)entry->GetObject();
317       }
318     
319       // ADC Clk phase (whole TRD)
320 /*
321       entry = manager->Get("TRD/Calib/trd_adcClkPhase");
322       if(entry) {
323         entry->SetOwner(kTRUE);
324         adcClkPhaseSensors = (AliTRDSensorArray*)entry->GetObject();
325       }
326 */
327     }  // end if getGasInfo
328
329
330     // get calibration information
331     // process gains
332     AliTRDCalDet *chamberGainFactor = 0;
333     AliTRDCalPad *padGainFactor = 0;
334     Double_t runMeanGain=0.0, runRMSGain=0.0;
335     TVectorD chamberMeanGain(AliTRDcalibDB::kNdet);
336     TVectorD chamberRMSGain(AliTRDcalibDB::kNdet);
337     TVectorD smMeanGain(AliTRDcalibDB::kNsector);
338     TVectorD smRMSGain(AliTRDcalibDB::kNsector);
339     TString parName("Gain");
340     if(getCalibrationInfo) {
341       entry = manager->Get("TRD/Calib/ChamberGainFactor");
342       if(entry) {
343         entry->SetOwner(kFALSE);
344         chamberGainFactor = (AliTRDCalDet*)entry->GetObject();
345       }
346       entry = manager->Get("TRD/Calib/LocalGainFactor");
347       if(entry) {
348         entry->SetOwner(kFALSE);
349         padGainFactor = (AliTRDCalPad*)entry->GetObject();
350       }
351       ProcessTRDCalibArray(chamberGainFactor, padGainFactor, 
352                            parName,
353                            runMeanGain, runRMSGain,
354                            chamberMeanGain, chamberRMSGain,
355                            smMeanGain, smRMSGain);
356     }
357
358     // process pedestals
359     AliTRDCalDet *chamberNoise = 0;
360     AliTRDCalPad *padNoise = 0;
361     Double_t runMeanNoise=0.0, runRMSNoise=0.0;
362     TVectorD chamberMeanNoise(AliTRDcalibDB::kNdet);
363     TVectorD chamberRMSNoise(AliTRDcalibDB::kNdet);
364     TVectorD smMeanNoise(AliTRDcalibDB::kNsector);
365     TVectorD smRMSNoise(AliTRDcalibDB::kNsector);
366     parName = "Noise";
367     if(getCalibrationInfo) {
368       entry = manager->Get("TRD/Calib/DetNoise");
369       if(entry) {
370         entry->SetOwner(kFALSE);
371         chamberNoise = (AliTRDCalDet*)entry->GetObject();
372       }
373       entry = manager->Get("TRD/Calib/PadNoise");
374       if(entry) {
375         entry->SetOwner(kFALSE);
376         padNoise = (AliTRDCalPad*)entry->GetObject();
377       }
378       ProcessTRDCalibArray(chamberNoise, padNoise, 
379                            parName,
380                            runMeanNoise, runRMSNoise,
381                            chamberMeanNoise, chamberRMSNoise,
382                            smMeanNoise, smRMSNoise);
383     }
384
385     // process drift velocity
386     AliTRDCalDet *chamberVdrift = 0;
387     AliTRDCalPad *padVdrift = 0;
388     Double_t runMeanVdrift=0.0, runRMSVdrift=0.0;
389     TVectorD chamberMeanVdrift(AliTRDcalibDB::kNdet);
390     TVectorD chamberRMSVdrift(AliTRDcalibDB::kNdet);
391     TVectorD smMeanVdrift(AliTRDcalibDB::kNsector);
392     TVectorD smRMSVdrift(AliTRDcalibDB::kNsector);
393     parName = "Vdrift";
394     if(getCalibrationInfo) {
395       entry = manager->Get("TRD/Calib/ChamberVdrift");
396       if(entry) {
397         entry->SetOwner(kFALSE);
398         chamberVdrift = (AliTRDCalDet*)entry->GetObject();
399       }
400       entry = manager->Get("TRD/Calib/LocalVdrift");
401       if(entry) {
402         entry->SetOwner(kFALSE);
403         padVdrift = (AliTRDCalPad*)entry->GetObject();
404       }
405       ProcessTRDCalibArray(chamberVdrift, padVdrift, 
406                            parName,
407                            runMeanVdrift, runRMSVdrift,
408                            chamberMeanVdrift, chamberRMSVdrift,
409                            smMeanVdrift, smRMSVdrift);
410     }
411     
412     // process T0
413     AliTRDCalDet *chamberT0 = 0;
414     AliTRDCalPad *padT0 = 0;
415     Double_t runMeanT0=0.0, runRMST0=0.0;
416     TVectorD chamberMeanT0(AliTRDcalibDB::kNdet);
417     TVectorD chamberRMST0(AliTRDcalibDB::kNdet);
418     TVectorD smMeanT0(AliTRDcalibDB::kNsector);
419     TVectorD smRMST0(AliTRDcalibDB::kNsector);
420     parName = "T0";
421     if(getCalibrationInfo) {
422       entry = manager->Get("TRD/Calib/ChamberT0");
423       if(entry) {
424         entry->SetOwner(kFALSE);
425         chamberT0 = (AliTRDCalDet*)entry->GetObject();
426       }
427       entry = manager->Get("TRD/Calib/LocalT0");
428       if(entry) {
429         entry->SetOwner(kFALSE);
430         padT0 = (AliTRDCalPad*)entry->GetObject();
431       }
432       ProcessTRDCalibArray(chamberT0, padT0, 
433                            parName,
434                            runMeanT0, runRMST0,
435                            chamberMeanT0, chamberRMST0,
436                            smMeanT0, smRMST0);
437     }    
438
439     // process pad and chamber status
440     AliTRDCalChamberStatus* chamberStatus = 0;
441     AliTRDCalPadStatus *padStatus = 0;
442     Float_t runBadPadFraction=0.0;
443     TVectorD chamberBadPadFraction(AliTRDcalibDB::kNdet);
444     TVectorD chamberStatusValues(AliTRDcalibDB::kNdet);
445     if(getCalibrationInfo) {
446       entry = manager->Get("TRD/Calib/ChamberStatus");
447       if(entry) {
448         entry->SetOwner(kFALSE);
449         chamberStatus = (AliTRDCalChamberStatus*)entry->GetObject();
450       }
451       entry = manager->Get("TRD/Calib/PadStatus");
452       if(entry) {
453         entry->SetOwner(kFALSE);
454         padStatus = (AliTRDCalPadStatus*)entry->GetObject();
455       }
456       ProcessTRDstatus(chamberStatus, padStatus, 
457                        runBadPadFraction, chamberBadPadFraction,
458                        chamberStatusValues);
459     }
460
461     // get Goofie information
462     AliTRDSensorArray *goofieGainSensors = 0x0;
463     AliTRDSensorArray *goofieHvSensors = 0x0;
464     AliTRDSensorArray *goofiePressureSensors = 0x0;
465     AliTRDSensorArray *goofieTempSensors = 0x0;
466     AliTRDSensorArray *goofieVelocitySensors = 0x0;
467     AliTRDSensorArray *goofieCO2Sensors = 0x0;
468     AliTRDSensorArray *goofieN2Sensors = 0x0;
469
470     if(getGoofieInfo) {
471       // goofie gain
472       entry = manager->Get("TRD/Calib/trd_goofieGain");
473       if(entry) {
474         entry->SetOwner(kTRUE);
475         goofieGainSensors = (AliTRDSensorArray*)entry->GetObject();
476       }
477       // goofie HV
478       entry = manager->Get("TRD/Calib/trd_goofieHv");
479       if(entry) {
480         entry->SetOwner(kTRUE);
481         goofieHvSensors = (AliTRDSensorArray*)entry->GetObject();
482       }
483       // goofie pressure
484       entry = manager->Get("TRD/Calib/trd_goofiePressure");
485       if(entry) {
486         entry->SetOwner(kTRUE);
487         goofiePressureSensors = (AliTRDSensorArray*)entry->GetObject();
488       }
489       // goofie temperature
490       entry = manager->Get("TRD/Calib/trd_goofieTemp");
491       if(entry) {
492         entry->SetOwner(kTRUE);
493         goofieTempSensors = (AliTRDSensorArray*)entry->GetObject();
494       }
495       // goofie drift velocity
496       entry = manager->Get("TRD/Calib/trd_goofieVelocity");
497       if(entry) {
498         entry->SetOwner(kTRUE);
499         goofieVelocitySensors = (AliTRDSensorArray*)entry->GetObject();
500       }
501       // goofie CO2
502       entry = manager->Get("TRD/Calib/trd_goofieCO2");
503       if(entry) {
504         entry->SetOwner(kTRUE);
505         goofieCO2Sensors = (AliTRDSensorArray*)entry->GetObject();
506       }
507       // goofie N2
508       entry = manager->Get("TRD/Calib/trd_goofieN2");
509       if(entry) {
510         entry->SetOwner(kTRUE);
511         goofieN2Sensors = (AliTRDSensorArray*)entry->GetObject();
512       }
513     }   // end if getGoofieInfo
514
515     // process the DCS FEE arrays
516     Int_t nSB1 = 0; Int_t nSB2 = 0; Int_t nSB3 = 0; Int_t nSB4 = 0; Int_t nSB5 = 0; 
517     Int_t nChanged = 0;
518     Bool_t sorAndEor = kFALSE;
519     TVectorD statusArraySOR(AliTRDcalibDB::kNdet);
520     TVectorD statusArrayEOR(AliTRDcalibDB::kNdet);
521     Int_t dcsFeeGlobalNTimeBins = -1;
522     Int_t dcsFeeGlobalConfigTag = -1;
523     Int_t dcsFeeGlobalSingleHitThres = -1;
524     Int_t dcsFeeGlobalThreePadClustThres = -1;
525     Int_t dcsFeeGlobalSelectiveNoSZ = -1;
526     Int_t dcsFeeGlobalTCFilterWeight = -1;
527     Int_t dcsFeeGlobalTCFilterShortDecPar = -1;
528     Int_t dcsFeeGlobalTCFilterLongDecPar = -1;
529     Int_t dcsFeeGlobalModeFastStatNoise = -1;
530     TObjString dcsFeeGlobalConfigVersion("");
531     TObjString dcsFeeGlobalConfigName("");
532     TObjString dcsFeeGlobalFilterType("");
533     TObjString dcsFeeGlobalReadoutParam("");
534     TObjString dcsFeeGlobalTestPattern("");
535     TObjString dcsFeeGlobalTrackletMode("");
536     TObjString dcsFeeGlobalTrackletDef("");
537     TObjString dcsFeeGlobalTriggerSetup("");
538     TObjString dcsFeeGlobalAddOptions("");
539     if(getDCSInfo) {
540       TObjArray *objArrayCDB = 0;
541       AliTRDCalDCS* calDCSsor = 0x0;
542       AliTRDCalDCS* calDCSeor = 0x0;
543       entry = manager->Get("TRD/Calib/DCS");
544       if(entry) {
545         entry->SetOwner(kTRUE);
546         objArrayCDB = (TObjArray*)entry->GetObject();
547         if(objArrayCDB) {
548           objArrayCDB->SetOwner(kTRUE);
549           calDCSsor = (AliTRDCalDCS*)objArrayCDB->At(0);
550           calDCSeor = (AliTRDCalDCS*)objArrayCDB->At(1);
551         }
552       }
553       ProcessTRDCalDCSFEE(calDCSsor, calDCSeor, 
554                           nSB1, nSB2, nSB3, nSB4, nSB5, 
555                           nChanged, sorAndEor, statusArraySOR, statusArrayEOR);
556       
557       if(calDCSsor || calDCSeor) {
558         AliTRDCalDCS *caldcs = 0;
559         if(calDCSsor) caldcs = calDCSsor;
560         else caldcs = calDCSeor;
561         dcsFeeGlobalNTimeBins = caldcs->GetGlobalNumberOfTimeBins();
562         dcsFeeGlobalConfigTag = caldcs->GetGlobalConfigTag();
563         dcsFeeGlobalSingleHitThres = caldcs->GetGlobalSingleHitThres();
564         dcsFeeGlobalThreePadClustThres = caldcs->GetGlobalThreePadClustThres();
565         dcsFeeGlobalSelectiveNoSZ = caldcs->GetGlobalSelectiveNoZS();
566         dcsFeeGlobalTCFilterWeight = caldcs->GetGlobalTCFilterWeight();
567         dcsFeeGlobalTCFilterShortDecPar = caldcs->GetGlobalTCFilterShortDecPar();
568         dcsFeeGlobalTCFilterLongDecPar = caldcs->GetGlobalTCFilterLongDecPar();
569         dcsFeeGlobalModeFastStatNoise = caldcs->GetGlobalModeFastStatNoise();
570         dcsFeeGlobalConfigVersion = caldcs->GetGlobalConfigVersion().Data();
571         dcsFeeGlobalConfigName = caldcs->GetGlobalConfigName().Data();
572         dcsFeeGlobalFilterType = caldcs->GetGlobalFilterType().Data();
573         dcsFeeGlobalReadoutParam = caldcs->GetGlobalReadoutParam().Data();
574         dcsFeeGlobalTestPattern = caldcs->GetGlobalTestPattern().Data();
575         dcsFeeGlobalTrackletMode = caldcs->GetGlobalTrackletMode().Data();
576         dcsFeeGlobalTrackletDef = caldcs->GetGlobalTrackletDef().Data();
577         dcsFeeGlobalTriggerSetup = caldcs->GetGlobalTriggerSetup().Data();
578         dcsFeeGlobalAddOptions = caldcs->GetGlobalAddOptions().Data();
579       }
580       if(objArrayCDB) objArrayCDB->RemoveAll();
581     }   // end if(getDCSInfo)
582        
583
584     // loop over time steps
585     for(UInt_t iTime = (getGRPInfo ? startTime : 0); iTime<=(getGRPInfo ? endTime : 0); iTime += (getGRPInfo ? dTime : 1)) {
586       // time stamp
587       TTimeStamp iStamp(iTime);
588       cout << "time step  " << iStamp.GetDate()/10000 << "/" 
589            << (iStamp.GetDate()/100)-(iStamp.GetDate()/10000)*100 << "/" 
590            << iStamp.GetDate()%100 << "   "
591            << iStamp.GetTime()/10000 << ":"
592            << (iStamp.GetTime()/100)-(iStamp.GetTime()/10000)*100 << ":" 
593            << iStamp.GetTime()%100 << endl;
594       
595       // cavern pressure
596       Float_t pressure = -99.;
597       Bool_t inside=kFALSE;
598       if(cavern_pressure) 
599         pressure = cavern_pressure->Eval(iStamp,inside);
600             
601       // surface pressure
602       Float_t surfacePressure = -99.;
603       if(surface_pressure) 
604         surfacePressure = surface_pressure->Eval(iStamp,inside);
605             
606       // anode I sensors
607       TVectorD anodeIValues(AliTRDcalibDB::kNdet);
608       if(anodeISensors) 
609         ProcessTRDSensorArray(anodeISensors, iStamp, anodeIValues);
610             
611       // anode U sensors
612       TVectorD anodeUValues(AliTRDcalibDB::kNdet);
613       if(anodeUSensors) 
614         ProcessTRDSensorArray(anodeUSensors, iStamp, anodeUValues);
615             
616       // drift I sensors
617       TVectorD driftIValues(AliTRDcalibDB::kNdet);
618       if(driftISensors) 
619         ProcessTRDSensorArray(driftISensors, iStamp, driftIValues);
620       
621       // drift U sensors
622       TVectorD driftUValues(AliTRDcalibDB::kNdet);
623       if(driftUSensors) 
624         ProcessTRDSensorArray(driftUSensors, iStamp, driftUValues);
625       
626       // chamber temperatures
627       TVectorD envTempValues(AliTRDcalibDB::kNdet);
628       if(temperatureSensors) 
629         ProcessTRDSensorArray(temperatureSensors, iStamp, envTempValues);
630
631       // chamber status sensors
632       TVectorD statusValues(AliTRDcalibDB::kNdet);
633       if(chamberStatusSensors)
634         ProcessTRDSensorArray(chamberStatusSensors, iStamp, statusValues);
635
636       // gas overpressure
637       TVectorD overpressureValues(overpressureSensors ? overpressureSensors->NumSensors() : 0);
638       if(overpressureSensors)
639         ProcessTRDSensorArray(overpressureSensors, iStamp, overpressureValues);
640       
641       // gas CO2
642       TVectorD gasCO2Values(gasCO2Sensors ? gasCO2Sensors->NumSensors() : 0);
643       if(gasCO2Sensors)
644         ProcessTRDSensorArray(gasCO2Sensors, iStamp, gasCO2Values);
645       
646       // gas H2O
647       TVectorD gasH2OValues(gasH2OSensors ? gasH2OSensors->NumSensors() : 0);
648       if(gasH2OSensors)
649         ProcessTRDSensorArray(gasH2OSensors, iStamp, gasH2OValues);
650       
651       // gas O2
652       TVectorD gasO2Values(gasO2Sensors ? gasO2Sensors->NumSensors() : 0);
653       if(gasO2Sensors)
654         ProcessTRDSensorArray(gasO2Sensors, iStamp, gasO2Values);
655       
656       // ADC Clk phase
657       //TVectorD adcClkPhaseValues(adcClkPhaseSensors ? adcClkPhaseSensors->NumSensors() : 0);
658       //if(adcClkPhaseSensors)
659 //      ProcessTRDSensorArray(adcClkPhaseSensors, iStamp, adcClkPhaseValues);
660
661       // goofie gain
662       TVectorD goofieGainValues(goofieGainSensors ? goofieGainSensors->NumSensors() : 0);
663       if(goofieGainSensors)
664         ProcessTRDSensorArray(goofieGainSensors, iStamp, goofieGainValues);
665
666       // goofie HV
667       TVectorD goofieHvValues(goofieHvSensors ? goofieHvSensors->NumSensors() : 0);
668       if(goofieHvSensors)
669         ProcessTRDSensorArray(goofieHvSensors, iStamp, goofieHvValues);
670
671       // goofie pressure
672       TVectorD goofiePressureValues(goofiePressureSensors ? goofiePressureSensors->NumSensors() : 0);
673       if(goofiePressureSensors)
674         ProcessTRDSensorArray(goofiePressureSensors, iStamp, goofiePressureValues);
675       
676       // goofie temperature
677       TVectorD goofieTempValues(goofieTempSensors ? goofieTempSensors->NumSensors() : 0);
678       if(goofieTempSensors) 
679         ProcessTRDSensorArray(goofieTempSensors, iStamp, goofieTempValues);
680       
681       // goofie drift velocity
682       TVectorD goofieVelocityValues(goofieVelocitySensors ? goofieVelocitySensors->NumSensors() : 0);
683       if(goofieVelocitySensors) 
684         ProcessTRDSensorArray(goofieVelocitySensors, iStamp, goofieVelocityValues);
685       
686       // goofie CO2
687       TVectorD goofieCO2Values(goofieCO2Sensors ? goofieCO2Sensors->NumSensors() : 0);
688       if(goofieCO2Sensors) 
689         ProcessTRDSensorArray(goofieCO2Sensors, iStamp, goofieCO2Values);
690       
691       // goofie N2
692       TVectorD goofieN2Values(goofieN2Sensors ? goofieN2Sensors->NumSensors() : 0);
693       if(goofieN2Sensors) 
694         ProcessTRDSensorArray(goofieN2Sensors, iStamp, goofieN2Values);
695       
696             
697       // fill the tree
698       (*treeStreamer)<< "trdTree"
699                      << "run=" << currRun
700                      << "time=" << iTime
701                      << "runType.=" << &runType;
702       if(getGRPInfo) {
703         (*treeStreamer)<< "trdTree"
704                        << "startTimeGRP=" << startTime
705                        << "endTimeGRP=" << endTime
706                        << "cavernPressure=" << pressure
707                        << "surfacePressure=" << surfacePressure
708                        << "detectorMask=" << detectorMask;
709       }
710       if(getHVInfo) {
711         (*treeStreamer)<< "trdTree"
712                        << "hvAnodeI.=" << &anodeIValues
713                        << "hvAnodeU.=" << &anodeUValues
714                        << "hvDriftI.=" << &driftIValues
715                        << "hvDriftU.=" << &driftUValues;
716       }
717       if(getStatusInfo) {
718         (*treeStreamer)<< "trdTree"
719                        << "sensorStatusValues.=" << &statusValues;
720       }
721       if(getGasInfo) {
722         (*treeStreamer)<< "trdTree"
723                        << "envTemp.=" << &envTempValues
724                        << "gasOverPressure.=" << &overpressureValues
725                        << "gasCO2.=" << &gasCO2Values
726                        << "gasH2O.=" << &gasH2OValues
727                        << "gasO2.=" << &gasO2Values;
728                        //<< "adcClkPhase.=" << &adcClkPhaseValues;
729       }
730       if(getGoofieInfo) {
731         (*treeStreamer)<< "trdTree"
732                        << "goofieGain.=" << &goofieGainValues
733                        << "goofieHV.=" << &goofieHvValues
734                        << "goofiePressure.=" << &goofiePressureValues
735                        << "goofieTemp.=" << &goofieTempValues
736                        << "goofieVelocity.=" << &goofieVelocityValues
737                        << "goofieCO2.=" << &goofieCO2Values
738                        << "goofieN2.=" << &goofieN2Values;
739       }
740       if(getCalibrationInfo) {
741         (*treeStreamer)<< "trdTree"
742                        << "runMeanGain=" << runMeanGain
743                        << "runRMSGain=" << runRMSGain
744                        << "smMeanGain.=" << &smMeanGain
745                        << "smRMSGain.=" << &smRMSGain
746                        << "chamberMeanGain.=" << &chamberMeanGain
747                        << "chamberRMSGain.=" << &chamberRMSGain
748                        << "runMeanNoise=" << runMeanNoise
749                        << "runRMSNoise=" << runRMSNoise
750                        << "smMeanNoise.=" << &smMeanNoise
751                        << "smRMSNoise.=" << &smRMSNoise
752                        << "chamberMeanNoise.=" << &chamberMeanNoise
753                        << "chamberRMSNoise.=" << &chamberRMSNoise
754                        << "runMeanVdrift=" << runMeanVdrift
755                        << "runRMSVdrift=" << runRMSVdrift
756                        << "smMeanVdrift.=" << &smMeanVdrift
757                        << "smRMSVdrift.=" << &smRMSVdrift
758                        << "chamberMeanVdrift.=" << &chamberMeanVdrift
759                        << "chamberRMSVdrift.=" << &chamberRMSVdrift
760                        << "runMeanT0=" << runMeanT0
761                        << "runRMST0=" << runRMST0
762                        << "smMeanT0.=" << &smMeanT0
763                        << "smRMST0.=" << &smRMST0
764                        << "chamberMeanT0.=" << &chamberMeanT0
765                        << "chamberRMST0.=" << &chamberRMST0
766                        << "runBadPadFraction=" << runBadPadFraction
767                        << "chamberBadPadFraction.=" << &chamberBadPadFraction
768                        << "chamberStatusValues.=" << &chamberStatusValues;
769       }
770       if(getDCSInfo) {
771         (*treeStreamer)<< "trdTree" 
772                        << "dcsFeeGlobalNTimeBins=" << dcsFeeGlobalNTimeBins
773                        << "dcsFeeGlobalConfigTag=" << dcsFeeGlobalConfigTag
774                        << "dcsFeeGlobalSingleHitThres=" << dcsFeeGlobalSingleHitThres
775                        << "dcsFeeGlobalThreePadClustThres=" << dcsFeeGlobalThreePadClustThres
776                        << "dcsFeeGlobalSelectiveNoSZ=" << dcsFeeGlobalSelectiveNoSZ
777                        << "dcsFeeGlobalTCFilterWeight=" << dcsFeeGlobalTCFilterWeight
778                        << "dcsFeeGlobalTCFilterShortDecPar=" << dcsFeeGlobalTCFilterShortDecPar
779                        << "dcsFeeGlobalTCFilterLongDecPar=" << dcsFeeGlobalTCFilterLongDecPar
780                        << "dcsFeeGlobalModeFastStatNoise=" << dcsFeeGlobalModeFastStatNoise
781           //                 << "dcsFeeGlobalConfigVersion.=" << &dcsFeeGlobalConfigVersion
782           //                 << "dcsFeeGlobalConfigName.=" << &dcsFeeGlobalConfigName
783           //                 << "dcsFeeGlobalFilterType.=" << &dcsFeeGlobalFilterType
784           //                 << "dcsFeeGlobalReadoutParam.=" << &dcsFeeGlobalReadoutParam
785           //                 << "dcsFeeGlobalTestPattern.=" << &dcsFeeGlobalTestPattern
786           //                 << "dcsFeeGlobalTrackletMode.=" << &dcsFeeGlobalTrackletMode
787           //                 << "dcsFeeGlobalTrackletDef.=" << &dcsFeeGlobalTrackletDef
788           //                 << "dcsFeeGlobalTriggerSetup.=" << &dcsFeeGlobalTriggerSetup
789           //                 << "dcsFeeGlobalAddOptions.=" << &dcsFeeGlobalAddOptions
790                        << "statusDCSFEESOR.=" << &statusArraySOR
791                        << "statusDCSFEEEOR.=" << &statusArrayEOR
792                        << "SORandEOR=" << sorAndEor
793                        << "nChanged=" << nChanged
794                        << "nSB1=" << nSB1
795                        << "nSB2=" << nSB2
796                        << "nSB3=" << nSB3
797                        << "nSB4=" << nSB4
798                        << "nSB5=" << nSB5;
799       }
800       (*treeStreamer)<< "trdTree"
801                      << "\n";
802     }  // end loop over time steps
803
804     // add the run number to the list of runs
805     runs.ResizeTo(runs.GetNoElements()+1);
806     runs[runs.GetNoElements()-1] = currRun;
807
808     // do some cleaning
809     if(grpObject) delete grpObject;
810     if(anodeISensors) anodeISensors->Clear();
811     if(anodeUSensors) anodeUSensors->Clear();
812     if(driftISensors) driftISensors->Clear();
813     if(driftUSensors) driftUSensors->Clear();
814     if(temperatureSensors) temperatureSensors->Clear();
815     if(overpressureSensors) overpressureSensors->Clear();
816     if(gasCO2Sensors) gasCO2Sensors->Clear();
817     if(gasH2OSensors) gasH2OSensors->Clear();
818     if(gasO2Sensors) gasO2Sensors->Clear();
819     //if(adcClkPhaseSensors) adcClkPhaseSensors->Clear();
820     if(goofieGainSensors) goofieGainSensors->Clear();
821     if(goofieHvSensors) goofieHvSensors->Clear();
822     if(goofiePressureSensors) goofiePressureSensors->Clear();
823     if(goofieTempSensors) goofieTempSensors->Clear();
824     if(goofieVelocitySensors) goofieVelocitySensors->Clear();
825     if(goofieCO2Sensors) goofieCO2Sensors->Clear();
826     if(goofieN2Sensors) goofieN2Sensors->Clear();
827     if(chamberGainFactor) delete chamberGainFactor;
828     if(padGainFactor) delete padGainFactor;
829     if(chamberNoise) delete chamberNoise;
830     if(padNoise) delete padNoise;
831     if(chamberVdrift) delete chamberVdrift;
832     if(padVdrift) delete padVdrift;
833     if(chamberT0) delete chamberT0;
834     if(padT0) delete padT0;
835     if(chamberStatus) delete chamberStatus;
836     if(padStatus) delete padStatus;
837   } // end while (loop over runs)
838   TTimeStamp loopEndTime;
839
840   treeStreamer->GetFile()->cd();
841   runs.Write("runs");
842   delete treeStreamer;
843
844   // output some job informations
845   TTimeStamp jobEndTime;
846   cout << "=============================================" << endl;
847   cout << "Job launched at          :  " << jobStartTime.AsString() << endl;
848   cout << "Loop over runs started at:  " << loopStartTime.AsString() << endl;
849   cout << "Loop over runs ended at  :  " << loopEndTime.AsString() << endl;
850   cout << "Job ended at             :  " << jobEndTime.AsString() << endl;
851   cout << "Initialization duration  :  " 
852        << loopStartTime.GetSec() - jobStartTime.GetSec() << " seconds" << endl;
853   cout << "Loop over runs duration  :  " 
854        << loopEndTime.GetSec() - loopStartTime.GetSec() << " seconds" << endl;
855   cout << "Post loop                :  "
856        << jobEndTime.GetSec() - loopEndTime.GetSec() << " seconds" << endl;
857   cout << "Running time per processed run:  "
858        << (loopEndTime.GetSec()-loopStartTime.GetSec())/(runs.GetNoElements()>0 ? Double_t(runs.GetNoElements()) : 1.0)
859        << " sec./run" << endl;
860   cout << "Running time per input run:  "
861        << (loopEndTime.GetSec()-loopStartTime.GetSec())/((rejectedRuns.GetNoElements()+runs.GetNoElements())>0 ? Double_t(runs.GetNoElements()+rejectedRuns.GetNoElements()) : 1.0)
862        << " sec./run" << endl;
863
864   // print the runs that had problems
865   cout << "number of rejected runs: " << rejectedRuns.GetNoElements() << endl;
866   cout << "rejected run numbers" << endl;
867   cout << "********************" << endl;
868   for(Int_t iRun=0; iRun<rejectedRuns.GetNoElements(); iRun++) {
869     cout << rejectedRuns[iRun] << "    ";
870     if(iRun%10==0) cout << endl;
871   }
872   cout << "=============================================" << endl;
873   return;
874 }
875
876 //__________________________________________________________________________________________
877 void ProcessTRDSensorArray(AliTRDSensorArray *sensorArray, TTimeStamp timeStamp, TVectorD &values) {
878   // Fill a vector with sensor values for a given time stamp
879   // The sensor->Eval() method makes interpolation inside the covered time interval
880   // and returns the value at the closest time limit (start or end) outside the covered time range
881   AliDCSSensor *sensor;
882   Bool_t inside=kFALSE;
883   for(Int_t i=0; i<sensorArray->NumSensors(); i++) {
884     sensor = sensorArray->GetSensorNum(i);
885     if(sensor && sensor->GetGraph()) 
886       values[i] = sensor->Eval(timeStamp,inside);
887     else
888       values[i] = -99.;
889   }
890   return;
891 }
892
893 //__________________________________________________________________________________________
894 void ProcessTRDCalibArray(AliTRDCalDet* chamberCalib, AliTRDCalPad *padCalib,
895                           TString parName,
896                           Double_t &runValue, Double_t &runRMS,
897                           TVectorD &chamberValues, TVectorD &chamberValuesRMS,
898                           TVectorD &superModuleValues, TVectorD &superModuleValuesRMS) {
899   // Process the calibrations for a given run.
900   // Calculates the run and chamber wise averages
901   //
902
903   // check if the calibration parameter is multiplicative or additive
904   Bool_t multiplicative = kTRUE;
905   if(!parName.CompareTo("T0")) multiplicative = kFALSE;
906
907   // first iteration (calculate all averages and RMS without discrimination on the SM average)
908   gRunWiseHisto->Reset();
909   for(Int_t iSM = 0; iSM<AliTRDcalibDB::kNsector; iSM++) {   // loop over supermodules
910     // reset the super module histogram
911     gSuperModuleWiseHisto->Reset();
912     // check if SM is installed
913     if(!gkSuperModuleStatus[iSM]) continue;
914     for(Int_t iChamber=iSM*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; 
915         iChamber < (iSM+1)*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; 
916         iChamber++) {  // loop over chambers in this supermodule
917       // get the chamber value
918       Float_t chamberValue = chamberCalib->GetValue(iChamber);
919       // get the ROC object
920       AliTRDCalROC *chamberROC = padCalib->GetCalROC(iChamber);
921       if(!chamberROC) 
922         continue;
923       gChamberWiseHisto->Reset();
924       for(Int_t iChannel = 0; iChannel < chamberROC->GetNchannels(); iChannel++){ // loop over channels
925         // calculate the calibration parameter for this pad
926         Float_t padValue;
927         if(multiplicative)
928           padValue = chamberValue * chamberROC->GetValue(iChannel);
929         else
930           padValue = chamberValue + chamberROC->GetValue(iChannel);
931         // fill the run, SM and chamber wise histograms
932         gChamberWiseHisto->Fill(padValue);
933         // if the parameter is Noise then check if the pad value is not a default one
934         // Default value is now 1.2!!!! Check with Raphaelle for more informations
935         if(parName.Contains("Noise") &&
936            TMath::Abs(padValue-1.2)<0.00001) continue;
937         gSuperModuleWiseHisto->Fill(padValue);
938         gRunWiseHisto->Fill(padValue);
939       }  // end loop over channels
940       // get the chamber wise mean and RMS
941       chamberValues[iChamber] = gChamberWiseHisto->GetMean();
942       chamberValuesRMS[iChamber] = gChamberWiseHisto->GetRMS();
943     }  // end loop over chambers
944     // SM wise mean and RMS
945     superModuleValues[iSM] = gSuperModuleWiseHisto->GetMean();
946     superModuleValuesRMS[iSM] = gSuperModuleWiseHisto->GetRMS();
947   }  // end loop over supermodules
948   // run wise mean and RMS
949   runValue = gRunWiseHisto->GetMean();
950   runRMS = gRunWiseHisto->GetRMS();
951
952   // Noise and Gain are finished processing
953   if(parName.Contains("Noise") || parName.Contains("Gain"))
954     return;
955   // second iteration (calculate SM and run wise averages and RMS for Vdrift and T0)
956   // The pads with calib parameter equal to the SM average are discarded (default value)
957   gRunWiseHisto->Reset();
958   for(Int_t iSM = 0; iSM<AliTRDcalibDB::kNsector; iSM++) {   // loop over supermodules
959     gSuperModuleWiseHisto->Reset();
960     // eliminate the uninstalled super modules
961     if(!gkSuperModuleStatus[iSM]) continue;
962     for(Int_t iChamber=iSM*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; 
963         iChamber < (iSM+1)*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; 
964         iChamber++) {  // loop over chambers
965       // the chamber value
966       Float_t chamberValue = chamberCalib->GetValue(iChamber);
967       AliTRDCalROC *chamberROC = padCalib->GetCalROC(iChamber);
968       if(!chamberROC) 
969         continue;
970       
971       for(Int_t iChannel = 0; iChannel < chamberROC->GetNchannels(); iChannel++){ // loop over channels in a chamber
972         // get the pad value
973         Float_t padValue;
974         if(multiplicative)
975           padValue = chamberValue * chamberROC->GetValue(iChannel);
976         else
977           padValue = chamberValue + chamberROC->GetValue(iChannel);
978         // eliminate from the average and RMS calculation all pads which
979         // have the calib parameter equal with the SM average
980         if((parName.Contains("Vdrift") || parName.Contains("T0")) && 
981            TMath::Abs(padValue-superModuleValues[iSM])<0.00001) continue;
982         gSuperModuleWiseHisto->Fill(padValue);
983         gRunWiseHisto->Fill(padValue);
984       }   // end loop over channels
985     }   // end loop over chambers 
986     superModuleValues[iSM] = gSuperModuleWiseHisto->GetMean();
987     superModuleValuesRMS[iSM] = gSuperModuleWiseHisto->GetRMS();
988   }   // end loop over super modules
989   runValue = gRunWiseHisto->GetMean();
990   runRMS = gRunWiseHisto->GetRMS();
991   return;
992 }
993
994 //__________________________________________________________________________________________
995 void ProcessTRDstatus(AliTRDCalChamberStatus* chamberStatus, AliTRDCalPadStatus* padStatus,
996                       Float_t &runBadPadFraction, TVectorD &chamberBadPadFraction,
997                       TVectorD &chamberStatusValues) {
998   // Process the pad status. Calculates the fraction of pads with non 0 status
999   // run and chamber wise
1000   //
1001   Int_t runPadStatusNot0 = 0;
1002   Int_t runPadStatusAll = 0;
1003
1004   Int_t superModuleStatus[18] = {1, 1, 0, 0, 0, 0, 0, 1, 1,
1005                                  1, 1, 0, 0, 0, 0, 0, 0, 1};  
1006
1007   // loop over chambers
1008   for(Int_t iChamber=0; iChamber < AliTRDcalibDB::kNdet; iChamber++) {
1009     // check if the chamber is in an installed sector;
1010     Int_t sm = AliTRDgeometry::GetSector(iChamber);
1011     if(!superModuleStatus[sm]) continue;
1012
1013     chamberStatusValues[iChamber] = chamberStatus->GetStatus(iChamber);
1014     AliTRDCalSingleChamberStatus *singleChamberStatus = padStatus->GetCalROC(iChamber);
1015     if(!singleChamberStatus)
1016       continue;
1017     Int_t chamberPadStatusNot0 = 0;
1018     Int_t chamberPadStatusAll = 0;
1019     // loop over channels in a chamber
1020     for(Int_t iChannel = 0; iChannel < singleChamberStatus->GetNchannels(); iChannel++) {
1021       if(singleChamberStatus->GetStatus(iChannel) > 0) {
1022         chamberPadStatusNot0++;
1023         runPadStatusNot0++;
1024       }
1025       chamberPadStatusAll++;
1026       runPadStatusAll++;
1027     }
1028     chamberBadPadFraction[iChamber] = (chamberPadStatusAll>0 ? 
1029                                        Float_t(chamberPadStatusNot0)/Float_t(chamberPadStatusAll) : -99.);
1030   }
1031   runBadPadFraction = (runPadStatusAll>0 ? Float_t(runPadStatusNot0)/Float_t(runPadStatusAll) : -99.);
1032   return;
1033 }
1034
1035 //__________________________________________________________________________________________
1036 void ProcessTRDCalDCSFEE(AliTRDCalDCS *caldcsSOR, AliTRDCalDCS *caldcsEOR, 
1037                          Int_t &nsb1, Int_t &nsb2, Int_t &nsb3, Int_t &nsb4, Int_t &nsb5,
1038                          Int_t &nChanged, Bool_t &sorAndEor, 
1039                          TVectorD &statusArraySOR, TVectorD &statusArrayEOR) {
1040   //
1041   // Process the DCS information
1042   //
1043   sorAndEor = kTRUE;
1044   if(!caldcsSOR && !caldcsEOR) {
1045     sorAndEor = kFALSE;
1046     return;
1047   }
1048   else if(caldcsSOR && !caldcsEOR) {
1049     sorAndEor = kFALSE;
1050   }
1051   else if(!caldcsSOR && caldcsEOR) {
1052     caldcsSOR = caldcsEOR;
1053     sorAndEor = kFALSE;
1054   }
1055
1056   nsb1 = 0; nsb2 = 0; nsb3 = 0; nsb4 = 0; nsb5 = 0; nChanged = 0;
1057   for(Int_t iROC=0; iROC<AliTRDcalibDB::kNdet && iROC<caldcsSOR->GetFEEArr()->GetSize(); iROC++) {
1058     AliTRDCalDCSFEE *dcsSorFee = caldcsSOR->GetCalDCSFEEObj(iROC);
1059     AliTRDCalDCSFEE *dcsEorFee = caldcsEOR->GetCalDCSFEEObj(iROC);
1060     if(dcsSorFee) {
1061       statusArraySOR[iROC] = dcsSorFee->GetStatusBit();
1062       if(statusArraySOR[iROC] == 1) nsb1++;
1063       if(statusArraySOR[iROC] == 2) nsb2++;
1064       if(statusArraySOR[iROC] == 3) nsb3++;
1065       if(statusArraySOR[iROC] == 4) nsb4++;
1066       if(statusArraySOR[iROC] == 5) nsb5++;
1067     }
1068     if(dcsEorFee) {
1069       statusArrayEOR[iROC] = dcsEorFee->GetStatusBit();
1070     }
1071     if(sorAndEor) {
1072       if((statusArraySOR[iROC]-statusArrayEOR[iROC]) != 0) nChanged++;
1073     } 
1074   }
1075   return;
1076 }
1077
1078 //__________________________________________________________________________________________
1079 void MakeRunListFromOCDB(const Char_t* directory, const Char_t* outfile, Bool_t fromAlien) {
1080   //
1081   // For a given OCDB path dump the list of available run numbers
1082   //
1083   if(fromAlien)
1084     gSystem->Exec(Form("alien_ls %s > temp.txt", directory));
1085   else
1086     gSystem->Exec(Form("ls %s > temp.txt", directory));
1087
1088   ifstream inBuffer("temp.txt");
1089   if(!inBuffer.is_open()) {
1090     cout << "File temp.txt not opened! Exiting" << endl;
1091     return;
1092   }
1093   ofstream outBuffer(outfile);
1094   if(!outBuffer.is_open()) {
1095     cout << "File runList.txt cannot be opened! Exiting" << endl;
1096     return;
1097   }
1098
1099   while(!inBuffer.eof()) {
1100     char inputLine[128];
1101     inBuffer.getline(inputLine, 128, '\n');
1102     int runLow, runHigh;
1103     const char* tempLine = inputLine;
1104     sscanf(tempLine, "Run%d_%d_v1_s0.root", &runLow, &runHigh);
1105     outBuffer << runLow << endl;
1106   }
1107
1108   inBuffer.close();
1109   outBuffer.close();
1110   gSystem->Exec("rm temp.txt");
1111   return;
1112 }