Include processing of Goofie points from DCS in Shuttle/preprocessor setup
[u/mrichter/AliRoot.git] / TPC / AliTPCPreprocessor.cxx
1 /**************************************************************************
2  * Copyright(c) 2007, 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
17 #include "AliTPCPreprocessor.h"
18 #include "AliShuttleInterface.h"
19
20 #include "AliCDBMetaData.h"
21 #include "AliDCSValue.h"
22 #include "AliLog.h"
23 #include "AliTPCSensorTempArray.h"
24 #include "AliTPCROC.h"
25 #include "AliTPCCalROC.h"
26 #include "AliTPCCalPad.h"
27 #include "AliTPCCalibPedestal.h"
28 #include "AliTPCCalibPulser.h"
29 #include "AliTPCCalibCE.h"
30 #include "AliTPCdataQA.h"
31 #include "TFile.h"
32 #include "TTree.h"
33 #include "TGraph.h" 
34 #include "TEnv.h"
35 #include "TParameter.h"
36
37 #include <TTimeStamp.h>
38
39 const Int_t kValCutTemp = 100;               // discard temperatures > 100 degrees
40 const Int_t kDiffCutTemp = 5;                // discard temperature differences > 5 degrees
41 const TString kPedestalRunType = "PEDESTAL";  // pedestal run identifier
42 const TString kPulserRunType = "CALIBRATION_PULSER";   // pulser run identifier
43 const TString kPhysicsRunType = "PHYSICS";   // physics run identifier
44 const TString kStandAloneRunType = "STANDALONE"; // standalone run identifier
45 const TString kStandAlonePulserRunType = "STANDALONE_PULSER"; // standalone run identifier
46 const TString kCosmicRunType = "COSMIC"; // cosmic run identifier
47 const TString kLaserRunType = "LASER";   // laser run identifier
48 const TString kDaqRunType = "DAQ"; // DAQ run identifier
49 const TString kAmandaTemp = "TPC_PT_%d_TEMPERATURE"; // Amanda string for temperature entries
50 //const Double_t kFitFraction = 0.7;                 // Fraction of DCS sensor fits required              
51 const Double_t kFitFraction = -1.0;          // Don't require minimum number of fits in commissioning run 
52
53 //
54 // This class is the SHUTTLE preprocessor for the TPC detector.
55 //
56
57 ClassImp(AliTPCPreprocessor)
58
59 //______________________________________________________________________________________________
60 AliTPCPreprocessor::AliTPCPreprocessor(AliShuttleInterface* shuttle) :
61   AliPreprocessor("TPC",shuttle),
62   fConfEnv(0), fTemp(0), fHighVoltage(0), fHighVoltageStat(0), fGoofie(0), fConfigOK(kTRUE), fROC(0)
63 {
64   // constructor
65   fROC = AliTPCROC::Instance();
66
67   // define run types to be processed
68   
69   AddRunType(kPedestalRunType);
70   AddRunType(kPulserRunType);
71   AddRunType(kPhysicsRunType);
72   AddRunType(kStandAloneRunType);
73   AddRunType(kStandAlonePulserRunType);
74   AddRunType(kCosmicRunType);
75   AddRunType(kLaserRunType);
76   AddRunType(kDaqRunType);
77   
78 }
79 //______________________________________________________________________________________________
80  AliTPCPreprocessor::AliTPCPreprocessor(const AliTPCPreprocessor&  ) :
81    AliPreprocessor("TPC",0),
82    fConfEnv(0), fTemp(0), fHighVoltage(0), fHighVoltageStat(0), fGoofie(0), fConfigOK(kTRUE), fROC(0)
83  {
84
85    Fatal("AliTPCPreprocessor", "copy constructor not implemented");
86 //
87 // //  fTemp = new AliTPCSensorTempArray(*(org.fTemp));
88  }
89
90 //______________________________________________________________________________________________
91 AliTPCPreprocessor::~AliTPCPreprocessor()
92 {
93   // destructor
94
95   delete fTemp;
96   delete fHighVoltage;
97 }
98 //______________________________________________________________________________________________
99 AliTPCPreprocessor& AliTPCPreprocessor::operator = (const AliTPCPreprocessor& )
100 {
101   Fatal("operator =", "assignment operator not implemented");
102   return *this;
103 }
104
105
106 //______________________________________________________________________________________________
107 void AliTPCPreprocessor::Initialize(Int_t run, UInt_t startTime,
108         UInt_t endTime)
109 {
110   // Creates AliTestDataDCS object -- start maps half an hour beforre actual run start
111
112   UInt_t startTimeLocal = startTime-3600;
113   UInt_t endTimeLocal = endTime+1800;
114
115   AliPreprocessor::Initialize(run, startTimeLocal, endTimeLocal);
116
117         AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run,
118                 TTimeStamp((time_t)startTime,0).AsString(),
119                 TTimeStamp((time_t)endTime,0).AsString()));
120
121   // Preprocessor configuration
122
123         AliCDBEntry* entry = GetFromOCDB("Config", "Preprocessor");
124         if (entry) fConfEnv = (TEnv*) entry->GetObject();
125         if ( fConfEnv==0 ) {
126            Log("AliTPCPreprocsessor: Preprocessor Config OCDB entry missing.\n");
127            fConfigOK = kFALSE;
128            return;
129         }
130
131   // Temperature sensors
132
133        TTree *confTree = 0;
134
135        TString tempConf = fConfEnv->GetValue("Temperature","ON");
136        tempConf.ToUpper();
137        if (tempConf != "OFF" ) {
138         entry = GetFromOCDB("Config", "Temperature");
139         if (entry) confTree = (TTree*) entry->GetObject();
140         if ( confTree==0 ) {
141            Log("AliTPCPreprocsessor: Temperature Config OCDB entry missing.\n");
142            fConfigOK = kFALSE;
143            return;
144         }
145         fTemp = new AliTPCSensorTempArray(startTimeLocal, endTimeLocal, confTree, kAmandaTemp);
146         fTemp->SetValCut(kValCutTemp);
147         fTemp->SetDiffCut(kDiffCutTemp);
148        }
149
150   // High voltage measurements
151
152       TString hvConf = fConfEnv->GetValue("HighVoltage","ON");
153       hvConf.ToUpper();
154       if (hvConf != "OFF" ) { 
155         confTree=0;
156         entry=0;
157         entry = GetFromOCDB("Config", "HighVoltage");
158         if (entry) confTree = (TTree*) entry->GetObject();
159         if ( confTree==0 ) {
160            Log("AliTPCPreprocsessor: High Voltage Config OCDB entry missing.\n");
161            fConfigOK = kFALSE;
162            return;
163         }
164         fHighVoltage = new AliDCSSensorArray(startTimeLocal, endTimeLocal, confTree);
165       }
166
167    // High voltage status values
168      
169       TString hvStatConf = fConfEnv->GetValue("HighVoltageStat","ON");
170       hvStatConf.ToUpper();
171       if (hvStatConf != "OFF" ) { 
172         confTree=0;
173         entry=0;
174         entry = GetFromOCDB("Config", "HighVoltageStat");
175         if (entry) confTree = (TTree*) entry->GetObject();
176         if ( confTree==0 ) {
177            Log("AliTPCPreprocsessor: High Voltage Status Config OCDB entry missing.\n");
178            fConfigOK = kFALSE;
179            return;
180         }
181         fHighVoltageStat = new AliDCSSensorArray(startTimeLocal, endTimeLocal, confTree);
182       }
183
184    // Goofie values
185      
186       TString goofieConf = fConfEnv->GetValue("Goofie","ON");
187       goofieConf.ToUpper();
188       if (goofieConf != "OFF" ) { 
189         confTree=0;
190         entry=0;
191         entry = GetFromOCDB("Config", "Goofie");
192         if (entry) confTree = (TTree*) entry->GetObject();
193         if ( confTree==0 ) {
194            Log("AliTPCPreprocsessor: Goofie Config OCDB entry missing.\n");
195            fConfigOK = kFALSE;
196            return;
197         }
198         fGoofie = new AliDCSSensorArray(startTimeLocal, endTimeLocal, confTree);
199       }
200
201
202 }
203
204 //______________________________________________________________________________________________
205 UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
206 {
207   // Fills data into TPC calibrations objects
208
209   // Amanda servers provide information directly through dcsAliasMap
210
211   
212   if (!fConfigOK) return 9;
213   UInt_t result = 0;
214   TObjArray *resultArray = new TObjArray();
215   TString errorHandling = fConfEnv->GetValue("ErrorHandling","ON");
216   errorHandling.ToUpper();
217   TObject * status;
218
219   UInt_t dcsResult=0;
220   if (errorHandling == "OFF" ) {
221     if (!dcsAliasMap) dcsResult=1;
222     if (dcsAliasMap->GetEntries() == 0 ) dcsResult=1;  
223     status = new TParameter<int>("dcsResult",dcsResult);
224     resultArray->Add(status);
225   } else {
226     if (!dcsAliasMap) return 9;
227     if (dcsAliasMap->GetEntries() == 0 ) return 9;
228   }
229
230
231   
232
233   TString runType = GetRunType();
234
235   // Temperature sensors are processed by AliTPCCalTemp
236
237   TString tempConf = fConfEnv->GetValue("Temperature","ON");
238   tempConf.ToUpper();
239   if (tempConf != "OFF" ) {
240     UInt_t tempResult = MapTemperature(dcsAliasMap);
241     result=tempResult;
242     status = new TParameter<int>("tempResult",tempResult);
243     resultArray->Add(status);
244   }
245
246   // High Voltage recordings
247
248
249   TString hvConf = fConfEnv->GetValue("HighVoltage","ON");
250   hvConf.ToUpper();
251   if (hvConf != "OFF" ) { 
252    UInt_t hvResult = MapHighVoltage(dcsAliasMap);
253    result+=hvResult;
254    status = new TParameter<int>("hvResult",hvResult);
255    resultArray->Add(status);
256  }
257
258   // Goofie values
259
260
261   TString goofieConf = fConfEnv->GetValue("Goofie","ON");
262   goofieConf.ToUpper();
263   if (goofieConf != "OFF" ) { 
264    UInt_t goofieResult = MapGoofie(dcsAliasMap);
265    result+=goofieResult;
266    status = new TParameter<int>("goofieResult",goofieResult);
267    resultArray->Add(status);
268  }
269
270   // Other calibration information will be retrieved through FXS files
271   //  examples:
272   //    TList* fileSourcesDAQ = GetFile(AliShuttleInterface::kDAQ, "pedestals");
273   //    const char* fileNamePed = GetFile(AliShuttleInterface::kDAQ, "pedestals", "LDC1");
274   //
275   //    TList* fileSourcesHLT = GetFile(AliShuttleInterface::kHLT, "calib");
276   //    const char* fileNameHLT = GetFile(AliShuttleInterface::kHLT, "calib", "LDC1");
277
278   // pedestal entries
279
280   if(runType == kPedestalRunType) {
281     Int_t numSources = 1;
282     Int_t pedestalSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
283     TString source = fConfEnv->GetValue("Pedestal","DAQ");
284     source.ToUpper();
285     if (source != "OFF" ) { 
286      if ( source == "HLT") pedestalSource[0] = AliShuttleInterface::kHLT;
287      if (!GetHLTStatus()) pedestalSource[0] = AliShuttleInterface::kDAQ;
288      if (source == "HLTDAQ" ) {
289          numSources=2;
290          pedestalSource[0] = AliShuttleInterface::kHLT;
291          pedestalSource[1] = AliShuttleInterface::kDAQ;
292      }
293      if (source == "DAQHLT" ) numSources=2;
294      UInt_t pedestalResult=0;
295      for (Int_t i=0; i<numSources; i++ ) {      
296        pedestalResult = ExtractPedestals(pedestalSource[i]);
297        if ( pedestalResult == 0 ) break;
298      }
299      result += pedestalResult;
300      status = new TParameter<int>("pedestalResult",pedestalResult);
301      resultArray->Add(status);
302     }
303   }
304
305   // pulser trigger processing
306
307   if(runType == kPulserRunType) {
308     Int_t numSources = 1;
309     Int_t pulserSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
310     TString source = fConfEnv->GetValue("Pulser","DAQ");
311     source.ToUpper();
312     if ( source != "OFF") { 
313      if ( source == "HLT") pulserSource[0] = AliShuttleInterface::kHLT;
314      if (!GetHLTStatus()) pulserSource[0] = AliShuttleInterface::kDAQ;
315      if (source == "HLTDAQ" ) {
316          numSources=2;
317          pulserSource[0] = AliShuttleInterface::kHLT;
318          pulserSource[1] = AliShuttleInterface::kDAQ;
319      }
320      if (source == "DAQHLT" ) numSources=2;
321      UInt_t pulserResult=0;
322      for (Int_t i=0; i<numSources; i++ ) {      
323        pulserResult = ExtractPulser(pulserSource[i]);
324        if ( pulserResult == 0 ) break;
325      }
326      result += pulserResult;
327      status = new TParameter<int>("pulserResult",pulserResult);
328      resultArray->Add(status);
329     }
330   }
331
332
333
334   // Central Electrode processing
335
336   if( runType == kPhysicsRunType || runType == kStandAloneRunType || 
337       runType == kDaqRunType ) {    
338
339 //   if (true) {                 // do CE processing for all run types
340     Int_t numSources = 1;
341     Int_t ceSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
342     TString source = fConfEnv->GetValue("CE","DAQ");
343     source.ToUpper();
344     if ( source != "OFF" ) { 
345      if ( source == "HLT") ceSource[0] = AliShuttleInterface::kHLT;
346      if (!GetHLTStatus()) ceSource[0] = AliShuttleInterface::kDAQ;
347      if (source == "HLTDAQ" ) {
348         numSources=2;
349         ceSource[0] = AliShuttleInterface::kHLT;
350         ceSource[1] = AliShuttleInterface::kDAQ;
351      }
352      if (source == "DAQHLT" ) numSources=2;
353      UInt_t ceResult=0;
354      for (Int_t i=0; i<numSources; i++ ) {      
355        ceResult = ExtractCE(ceSource[i]);
356        if ( ceResult == 0 ) break;
357      }
358      result += ceResult;
359      status = new TParameter<int>("ceResult",ceResult);
360      resultArray->Add(status);
361
362     numSources = 1;
363     Int_t qaSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
364     TString source = fConfEnv->GetValue("QA","DAQ");
365     source.ToUpper();
366     if ( source != "OFF" ) { 
367      if ( source == "HLT") qaSource[0] = AliShuttleInterface::kHLT;
368      if (!GetHLTStatus()) qaSource[0] = AliShuttleInterface::kDAQ;
369      if (source == "HLTDAQ" ) {
370         numSources=2;
371         qaSource[0] = AliShuttleInterface::kHLT;
372         qaSource[1] = AliShuttleInterface::kDAQ;
373      }
374      if (source == "DAQHLT" ) numSources=2;
375      UInt_t qaResult=0;
376      for (Int_t i=0; i<numSources; i++ ) {      
377        qaResult = ExtractQA(qaSource[i]);
378        if ( qaResult == 0 ) break;
379      }
380 //     result += qaResult;
381      if ( qaResult !=0 ) Log ("ExtractQA failed, no QA entry available.");
382      status = new TParameter<int>("qaResult",qaResult);
383      resultArray->Add(status);
384     }
385    }
386   }
387   
388   if (errorHandling == "OFF" ) {
389     AliCDBMetaData metaData;
390     metaData.SetBeamPeriod(0);
391     metaData.SetResponsible("Haavard Helstrup");
392     metaData.SetComment("Preprocessor AliTPC status.");
393     Store("Calib", "PreprocStatus", resultArray, &metaData, 0, kFALSE);
394     resultArray->Delete();
395     return 0;
396   } else { 
397     return result;
398   }
399 }
400 //______________________________________________________________________________________________
401 UInt_t AliTPCPreprocessor::MapTemperature(TMap* dcsAliasMap)
402 {
403
404    // extract DCS temperature maps. Perform fits to save space
405
406   UInt_t result=0;
407   TMap *map = fTemp->ExtractDCS(dcsAliasMap);
408   if (map) {
409     fTemp->MakeSplineFit(map);
410     Double_t fitFraction = 1.0*fTemp->NumFits()/fTemp->NumSensors(); 
411     if (fitFraction > kFitFraction ) {
412       AliInfo(Form("Temperature values extracted, fits performed.\n"));
413     } else { 
414       Log ("Too few temperature maps fitted. \n");
415       result = 9;
416     }
417   } else {
418     Log("No temperature map extracted. \n");
419     result=9;
420   }
421   delete map;
422   // Now store the final CDB file
423
424   if ( result == 0 ) {
425         AliCDBMetaData metaData;
426         metaData.SetBeamPeriod(0);
427         metaData.SetResponsible("Haavard Helstrup");
428         metaData.SetComment("Preprocessor AliTPC data base entries.");
429
430         Bool_t storeOK = Store("Calib", "Temperature", fTemp, &metaData, 0, kFALSE);
431         if ( !storeOK )  result=1;
432
433    }
434
435    return result;
436
437 }
438
439 //______________________________________________________________________________________________
440 UInt_t AliTPCPreprocessor::MapHighVoltage(TMap* dcsAliasMap)
441 {
442
443    // extract DCS HV maps. Perform fits to save space
444
445   UInt_t result=0;
446   TMap *map = fHighVoltage->ExtractDCS(dcsAliasMap);
447   if (map) {
448     fHighVoltage->MakeSplineFit(map);
449     Double_t fitFraction = 1.0*fHighVoltage->NumFits()/fHighVoltage->NumSensors(); 
450     if (fitFraction > kFitFraction ) {
451       AliInfo(Form("High voltage recordings extracted, fits performed.\n"));
452     } else { 
453       Log ("Too few high voltage recordings fitted. \n");
454       result = 9;
455     }
456   } else {
457     Log("No high voltage recordings extracted. \n");
458     result=9;
459   }
460   delete map;
461
462   TString hvStatConf = fConfEnv->GetValue("HighVoltageStat","ON");
463   hvStatConf.ToUpper();
464   if (hvStatConf != "OFF" ) { 
465     TMap *map2 = fHighVoltageStat->ExtractDCS(dcsAliasMap);
466     if (map2) {
467       fHighVoltageStat->ClearFit();
468       fHighVoltageStat->SetGraph(map2);
469     } else {
470        Log("No high voltage status recordings extracted. \n");
471       result=9;
472     }
473     delete map2;
474
475     // add status maps to high voltage sensor array
476
477     fHighVoltage->AddSensors(fHighVoltageStat);
478    }
479   // Now store the final CDB file
480
481   if ( result == 0 ) {
482         AliCDBMetaData metaData;
483         metaData.SetBeamPeriod(0);
484         metaData.SetResponsible("Haavard Helstrup");
485         metaData.SetComment("Preprocessor AliTPC data base entries.");
486
487         Bool_t storeOK = Store("Calib", "HighVoltage", fHighVoltage, &metaData, 0, kFALSE);
488         if ( !storeOK )  result=1;
489
490    }
491
492    return result;
493
494 }
495
496 //______________________________________________________________________________________________
497 UInt_t AliTPCPreprocessor::MapGoofie(TMap* dcsAliasMap)
498 {
499
500    // extract DCS Goofie maps. Do not perform fits (low update rate)
501
502   UInt_t result=0;
503
504   TMap *map = fGoofie->ExtractDCS(dcsAliasMap);
505   if (map) {
506     fGoofie->ClearFit();
507     fGoofie->SetGraph(map);
508   } else {
509     Log("No Goofie recordings extracted. \n");
510     result=9;
511   }
512   delete map;
513
514   // Now store the final CDB file
515
516   if ( result == 0 ) {
517         AliCDBMetaData metaData;
518         metaData.SetBeamPeriod(0);
519         metaData.SetResponsible("Haavard Helstrup");
520         metaData.SetComment("Preprocessor AliTPC data base entries.");
521
522         Bool_t storeOK = Store("Calib", "Goofie", fGoofie, &metaData, 0, kFALSE);
523         if ( !storeOK )  result=1;
524
525    }
526
527    return result;
528
529 }
530
531
532 //______________________________________________________________________________________________
533
534 UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
535 {
536  //
537  //  Read pedestal file from file exchage server
538  //  Keep original entry from OCDB in case no new pedestals are available
539  //
540  AliTPCCalPad *calPadPed=0;
541  AliCDBEntry* entry = GetFromOCDB("Calib", "Pedestals");
542  if (entry) calPadPed = (AliTPCCalPad*)entry->GetObject();
543  if ( calPadPed==NULL ) {
544      Log("AliTPCPreprocsessor: No previous TPC pedestal entry available.\n");
545      calPadPed = new AliTPCCalPad("PedestalsMean","PedestalsMean");
546  }
547
548  AliTPCCalPad *calPadRMS=0;
549  entry = GetFromOCDB("Calib", "PadNoise");
550  if (entry) calPadRMS = (AliTPCCalPad*)entry->GetObject();
551  if ( calPadRMS==NULL ) {
552      Log("AliTPCPreprocsessor: No previous TPC noise entry available.\n");
553      calPadRMS = new AliTPCCalPad("PedestalsRMS","PedestalsRMS");
554  }
555
556
557  UInt_t result=0;
558
559  Int_t nSectors = fROC->GetNSectors();
560  TList* list = GetFileSources(sourceFXS,"pedestals");
561  
562  if (list && list->GetEntries()>0) {
563
564 //  loop through all files from LDCs
565
566     Bool_t changed=false;
567     UInt_t index = 0;
568     while (list->At(index)!=NULL) {
569      TObjString* fileNameEntry = (TObjString*) list->At(index);
570      if (fileNameEntry!=NULL) {
571         TString fileName = GetFile(sourceFXS, "pedestals",
572                                          fileNameEntry->GetString().Data());
573         TFile *f = TFile::Open(fileName);
574         if (!f) {
575           Log ("Error opening pedestal file.");
576           result =2;
577           break;
578         }
579         AliTPCCalibPedestal *calPed;
580         f->GetObject("tpcCalibPedestal",calPed);
581         if ( !calPed ) {
582           Log ("No pedestal calibration object in file.");
583           result = 2;
584           break;
585         }
586
587         //  replace entries for the sectors available in the present file
588
589         changed=true;
590         for (Int_t sector=0; sector<nSectors; sector++) {
591            AliTPCCalROC *rocPed=calPed->GetCalRocPedestal(sector, kFALSE);
592            if ( rocPed )  calPadPed->SetCalROC(rocPed,sector);
593            AliTPCCalROC *rocRMS=calPed->GetCalRocRMS(sector, kFALSE);
594            if ( rocRMS )  calPadRMS->SetCalROC(rocRMS,sector);
595         }
596         delete calPed; 
597         f->Close();
598       }
599      ++index;
600     }  // while(list)
601 //
602 //  Store updated pedestal entry to OCDB
603 //
604     if (changed) {
605      AliCDBMetaData metaData;
606      metaData.SetBeamPeriod(0);
607      metaData.SetResponsible("Haavard Helstrup");
608      metaData.SetComment("Preprocessor AliTPC data base entries."); 
609  
610      Bool_t storeOK = Store("Calib", "Pedestals", calPadPed, &metaData, 0, kTRUE);
611      if ( !storeOK ) ++result;
612      storeOK = Store("Calib", "PadNoise", calPadRMS, &metaData, 0, kTRUE);
613      if ( !storeOK ) ++result;
614     }
615   } else {
616     Log ("Error: no entries in input file list!");
617     result = 1;
618   }
619
620   return result;
621 }
622
623 //______________________________________________________________________________________________
624
625
626 UInt_t AliTPCPreprocessor::ExtractPulser(Int_t sourceFXS)
627 {
628  //
629  //  Read pulser calibration file from file exchage server
630  //  Keep original entry from OCDB in case no new pulser calibration is available
631  //
632  TObjArray    *pulserObjects=0;
633  AliTPCCalPad *pulserTmean=0;
634  AliTPCCalPad *pulserTrms=0;
635  AliTPCCalPad *pulserQmean=0;
636  AliCDBEntry* entry = GetFromOCDB("Calib", "Pulser");
637  if (entry) pulserObjects = (TObjArray*)entry->GetObject();
638  if ( pulserObjects==NULL ) {
639      Log("AliTPCPreprocsessor: No previous TPC pulser entry available.\n");
640      pulserObjects = new TObjArray;    
641  }
642
643  pulserTmean = (AliTPCCalPad*)pulserObjects->FindObject("PulserTmean");
644  if ( !pulserTmean ) {
645     pulserTmean = new AliTPCCalPad("PulserTmean","PulserTmean");
646     pulserObjects->Add(pulserTmean);
647  }
648  pulserTrms = (AliTPCCalPad*)pulserObjects->FindObject("PulserTrms");
649  if ( !pulserTrms )  { 
650     pulserTrms = new AliTPCCalPad("PulserTrms","PulserTrms");
651     pulserObjects->Add(pulserTrms);
652  }
653  pulserQmean = (AliTPCCalPad*)pulserObjects->FindObject("PulserQmean");
654  if ( !pulserQmean )  { 
655     pulserQmean = new AliTPCCalPad("PulserQmean","PulserQmean");
656     pulserObjects->Add(pulserQmean);
657  }
658
659
660  UInt_t result=0;
661
662  Int_t nSectors = fROC->GetNSectors();
663  TList* list = GetFileSources(sourceFXS,"pulser");
664  
665  if (list && list->GetEntries()>0) {
666
667 //  loop through all files from LDCs
668
669     Bool_t changed=false;
670     UInt_t index = 0;
671     while (list->At(index)!=NULL) {
672      TObjString* fileNameEntry = (TObjString*) list->At(index);
673      if (fileNameEntry!=NULL) {
674         TString fileName = GetFile(sourceFXS, "pulser",
675                                          fileNameEntry->GetString().Data());
676         TFile *f = TFile::Open(fileName);
677         if (!f) {
678           Log ("Error opening pulser file.");
679           result =2;
680           break;
681         }
682         AliTPCCalibPulser *calPulser;
683         f->GetObject("tpcCalibPulser",calPulser);
684         if ( !calPulser ) {
685           Log ("No pulser calibration object in file.");
686           result = 2;
687           break;
688         }
689
690         //  replace entries for the sectors available in the present file
691
692         changed=true;
693         for (Int_t sector=0; sector<nSectors; sector++) {
694            AliTPCCalROC *rocTmean=calPulser->GetCalRocT0(sector);
695            if ( rocTmean )  pulserTmean->SetCalROC(rocTmean,sector);
696            AliTPCCalROC *rocTrms=calPulser->GetCalRocRMS(sector);
697            if ( rocTrms )  pulserTrms->SetCalROC(rocTrms,sector);
698            AliTPCCalROC *rocQmean=calPulser->GetCalRocQ(sector);
699            if ( rocQmean )  pulserQmean->SetCalROC(rocQmean,sector);
700         }
701        delete calPulser;
702        f->Close();
703       }
704      ++index;
705     }  // while(list)
706 //
707 //  Store updated pedestal entry to OCDB
708 //
709     if (changed) {
710      AliCDBMetaData metaData;
711      metaData.SetBeamPeriod(0);
712      metaData.SetResponsible("Haavard Helstrup");
713      metaData.SetComment("Preprocessor AliTPC data base entries.");
714
715      Bool_t storeOK = Store("Calib", "Pulser", pulserObjects, &metaData, 0, kTRUE);
716      if ( !storeOK ) ++result;
717     }  
718   } else {
719     Log ("Error: no entries in input file list!");
720     result = 1;
721   }
722
723   return result;
724 }
725
726 UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
727 {
728  //
729  //  Read Central Electrode file from file exchage server
730  //  Keep original entry from OCDB in case no new CE calibration is available
731  //
732  TObjArray    *ceObjects=0;
733  AliTPCCalPad *ceTmean=0;
734  AliTPCCalPad *ceTrms=0;
735  AliTPCCalPad *ceQmean=0;
736  TObjArray    *rocTtime=0;  
737  TObjArray    *rocQtime=0;  
738
739  AliCDBEntry* entry = GetFromOCDB("Calib", "CE");
740  if (entry) ceObjects = (TObjArray*)entry->GetObject();
741  if ( ceObjects==NULL ) {
742      Log("AliTPCPreprocsessor: No previous TPC central electrode entry available.\n");
743      ceObjects = new TObjArray;    
744  }
745
746  Int_t nSectors = fROC->GetNSectors();
747
748  ceTmean = (AliTPCCalPad*)ceObjects->FindObject("CETmean");
749  if ( !ceTmean ) {
750     ceTmean = new AliTPCCalPad("CETmean","CETmean");
751     ceObjects->Add(ceTmean);
752  }
753  ceTrms = (AliTPCCalPad*)ceObjects->FindObject("CETrms");
754  if ( !ceTrms )  { 
755     ceTrms = new AliTPCCalPad("CETrms","CETrms");
756     ceObjects->Add(ceTrms);
757  }
758  ceQmean = (AliTPCCalPad*)ceObjects->FindObject("CEQmean");
759  if ( !ceQmean )  { 
760     ceQmean = new AliTPCCalPad("CEQmean","CEQmean");
761     ceObjects->Add(ceQmean);
762  }
763  //!new from here please have a look!!!
764  rocTtime = (TObjArray*)ceObjects->FindObject("rocTtime");
765  if ( !rocTtime ) {
766      rocTtime = new TObjArray(nSectors);
767      rocTtime->SetName("rocTtime");
768      ceObjects->Add(rocTtime);
769  }
770  
771  rocQtime = (TObjArray*)ceObjects->FindObject("rocQtime");
772  if ( !rocQtime ) {
773      rocQtime = new TObjArray(nSectors);
774      rocQtime->SetName("rocQtime");
775      ceObjects->Add(rocQtime);
776  }
777
778
779  UInt_t result=0;
780
781  TList* list = GetFileSources(sourceFXS,"CE");
782  
783  if (list && list->GetEntries()>0) {
784
785 //  loop through all files from LDCs
786
787     UInt_t index = 0;
788     while (list->At(index)!=NULL) {
789      TObjString* fileNameEntry = (TObjString*) list->At(index);
790      if (fileNameEntry!=NULL) {
791         TString fileName = GetFile(sourceFXS, "CE",
792                                          fileNameEntry->GetString().Data());
793         TFile *f = TFile::Open(fileName);
794         if (!f) {
795           Log ("Error opening central electrode file.");
796           result =2;
797           break;
798         }
799         AliTPCCalibCE *calCE;
800         f->GetObject("tpcCalibCE",calCE);
801
802         //  replace entries for the sectors available in the present file
803
804         for (Int_t sector=0; sector<nSectors; sector++) {
805            AliTPCCalROC *rocTmean=calCE->GetCalRocT0(sector);
806            if ( rocTmean )  ceTmean->SetCalROC(rocTmean,sector);
807            AliTPCCalROC *rocTrms=calCE->GetCalRocRMS(sector);
808            if ( rocTrms )  ceTrms->SetCalROC(rocTrms,sector);
809            AliTPCCalROC *rocQmean=calCE->GetCalRocQ(sector);
810            if ( rocQmean )  ceQmean->SetCalROC(rocQmean,sector);
811            TGraph *grT=calCE->MakeGraphTimeCE(sector,0,2); // T time graph
812            if ( grT ) rocTtime->AddAt(grT,sector);         
813            TGraph *grQ=calCE->MakeGraphTimeCE(sector,0,3); // Q time graph
814            if ( grQ ) rocTtime->AddAt(grQ,sector);         
815         }
816        delete calCE;
817        f->Close();
818       }
819      ++index;
820     }  // while(list)
821 //
822 //  Store updated pedestal entry to OCDB
823 //
824     AliCDBMetaData metaData;
825     metaData.SetBeamPeriod(0);
826     metaData.SetResponsible("Haavard Helstrup");
827     metaData.SetComment("Preprocessor AliTPC data base entries.");
828
829     Bool_t storeOK = Store("Calib", "CE", ceObjects, &metaData, 0, kTRUE);
830     if ( !storeOK ) ++result;
831     
832   } else {
833     Log ("Error: no entries!");
834     result = 1;
835   }
836
837   return result;
838 }
839 //______________________________________________________________________________________________
840
841 UInt_t AliTPCPreprocessor::ExtractQA(Int_t sourceFXS)
842 {
843  //
844  //  Read Quality Assurance file from file exchage server
845  //
846  
847  UInt_t result=0;
848
849  TList* list = GetFileSources(sourceFXS,"QA");
850  
851  if (list && list->GetEntries()>0) {
852
853 //  only one QA objetc should be available!
854
855     AliTPCdataQA *calQA;
856
857     UInt_t nentries = list->GetEntries();  
858     UInt_t index=0;
859     if ( nentries > 1) Log ( "More than one QA entry. First one processed");      
860     TObjString* fileNameEntry = (TObjString*) list->At(index);
861     if (fileNameEntry!=NULL) {
862         TString fileName = GetFile(sourceFXS, "QA",
863                                          fileNameEntry->GetString().Data());
864         TFile *f = TFile::Open(fileName);
865         if (!f) {
866           Log ("Error opening QA file.");
867           result =2;          
868         } else {
869           f->GetObject("tpcCalibQA",calQA);
870       
871 //
872 //  Store updated pedestal entry to OCDB
873 //
874          AliCDBMetaData metaData;
875          metaData.SetBeamPeriod(0);
876          metaData.SetResponsible("Haavard Helstrup");
877          metaData.SetComment("Preprocessor AliTPC data base entries.");
878
879          Bool_t storeOK = Store("Calib", "QA", calQA, &metaData, 0, kTRUE);
880          if ( !storeOK ) ++result;
881         }
882     } else {
883     Log ("Error: no QA files on FXS!");
884     result = 2;
885     }
886   } else {
887     Log ("Error: no QA entries in FXS list!");
888     result = 1;
889   }
890   return result;
891 }
892