Adding simple example to load default debug streamer
[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), 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), 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
185 //______________________________________________________________________________________________
186 UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
187 {
188   // Fills data into TPC calibrations objects
189
190   // Amanda servers provide information directly through dcsAliasMap
191
192   
193   if (!fConfigOK) return 9;
194   UInt_t result = 0;
195   TObjArray *resultArray = new TObjArray();
196   TString errorHandling = fConfEnv->GetValue("ErrorHandling","ON");
197   errorHandling.ToUpper();
198   TObject * status;
199
200   UInt_t dcsResult=0;
201   if (errorHandling == "OFF" ) {
202     if (!dcsAliasMap) dcsResult=1;
203     if (dcsAliasMap->GetEntries() == 0 ) dcsResult=1;  
204     status = new TParameter<int>("dcsResult",dcsResult);
205     resultArray->Add(status);
206   } else {
207     if (!dcsAliasMap) return 9;
208     if (dcsAliasMap->GetEntries() == 0 ) return 9;
209   }
210
211
212   
213
214   TString runType = GetRunType();
215
216   // Temperature sensors are processed by AliTPCCalTemp
217
218   TString tempConf = fConfEnv->GetValue("Temperature","ON");
219   tempConf.ToUpper();
220   if (tempConf != "OFF" ) {
221     UInt_t tempResult = MapTemperature(dcsAliasMap);
222     result=tempResult;
223     status = new TParameter<int>("tempResult",tempResult);
224     resultArray->Add(status);
225   }
226
227   // High Voltage recordings
228
229
230   TString hvConf = fConfEnv->GetValue("HighVoltage","ON");
231   hvConf.ToUpper();
232   if (hvConf != "OFF" ) { 
233    UInt_t hvResult = MapHighVoltage(dcsAliasMap);
234    result+=hvResult;
235    status = new TParameter<int>("hvResult",hvResult);
236    resultArray->Add(status);
237  }
238
239   // Other calibration information will be retrieved through FXS files
240   //  examples:
241   //    TList* fileSourcesDAQ = GetFile(AliShuttleInterface::kDAQ, "pedestals");
242   //    const char* fileNamePed = GetFile(AliShuttleInterface::kDAQ, "pedestals", "LDC1");
243   //
244   //    TList* fileSourcesHLT = GetFile(AliShuttleInterface::kHLT, "calib");
245   //    const char* fileNameHLT = GetFile(AliShuttleInterface::kHLT, "calib", "LDC1");
246
247   // pedestal entries
248
249   if(runType == kPedestalRunType) {
250     Int_t numSources = 1;
251     Int_t pedestalSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
252     TString source = fConfEnv->GetValue("Pedestal","DAQ");
253     source.ToUpper();
254     if (source != "OFF" ) { 
255      if ( source == "HLT") pedestalSource[0] = AliShuttleInterface::kHLT;
256      if (!GetHLTStatus()) pedestalSource[0] = AliShuttleInterface::kDAQ;
257      if (source == "HLTDAQ" ) {
258          numSources=2;
259          pedestalSource[0] = AliShuttleInterface::kHLT;
260          pedestalSource[1] = AliShuttleInterface::kDAQ;
261      }
262      if (source == "DAQHLT" ) numSources=2;
263      UInt_t pedestalResult=0;
264      for (Int_t i=0; i<numSources; i++ ) {      
265        pedestalResult = ExtractPedestals(pedestalSource[i]);
266        if ( pedestalResult == 0 ) break;
267      }
268      result += pedestalResult;
269      status = new TParameter<int>("pedestalResult",pedestalResult);
270      resultArray->Add(status);
271     }
272   }
273
274   // pulser trigger processing
275
276   if(runType == kPulserRunType) {
277     Int_t numSources = 1;
278     Int_t pulserSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
279     TString source = fConfEnv->GetValue("Pulser","DAQ");
280     source.ToUpper();
281     if ( source != "OFF") { 
282      if ( source == "HLT") pulserSource[0] = AliShuttleInterface::kHLT;
283      if (!GetHLTStatus()) pulserSource[0] = AliShuttleInterface::kDAQ;
284      if (source == "HLTDAQ" ) {
285          numSources=2;
286          pulserSource[0] = AliShuttleInterface::kHLT;
287          pulserSource[1] = AliShuttleInterface::kDAQ;
288      }
289      if (source == "DAQHLT" ) numSources=2;
290      UInt_t pulserResult=0;
291      for (Int_t i=0; i<numSources; i++ ) {      
292        pulserResult = ExtractPulser(pulserSource[i]);
293        if ( pulserResult == 0 ) break;
294      }
295      result += pulserResult;
296      status = new TParameter<int>("pulserResult",pulserResult);
297      resultArray->Add(status);
298     }
299   }
300
301
302
303   // Central Electrode processing
304
305   if( runType == kPhysicsRunType || runType == kStandAloneRunType || 
306       runType == kDaqRunType ) {    
307
308 //   if (true) {                 // do CE processing for all run types
309     Int_t numSources = 1;
310     Int_t ceSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
311     TString source = fConfEnv->GetValue("CE","DAQ");
312     source.ToUpper();
313     if ( source != "OFF" ) { 
314      if ( source == "HLT") ceSource[0] = AliShuttleInterface::kHLT;
315      if (!GetHLTStatus()) ceSource[0] = AliShuttleInterface::kDAQ;
316      if (source == "HLTDAQ" ) {
317         numSources=2;
318         ceSource[0] = AliShuttleInterface::kHLT;
319         ceSource[1] = AliShuttleInterface::kDAQ;
320      }
321      if (source == "DAQHLT" ) numSources=2;
322      UInt_t ceResult=0;
323      for (Int_t i=0; i<numSources; i++ ) {      
324        ceResult = ExtractCE(ceSource[i]);
325        if ( ceResult == 0 ) break;
326      }
327      result += ceResult;
328      status = new TParameter<int>("ceResult",ceResult);
329      resultArray->Add(status);
330
331     numSources = 1;
332     Int_t qaSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
333     TString source = fConfEnv->GetValue("QA","DAQ");
334     source.ToUpper();
335     if ( source != "OFF" ) { 
336      if ( source == "HLT") qaSource[0] = AliShuttleInterface::kHLT;
337      if (!GetHLTStatus()) qaSource[0] = AliShuttleInterface::kDAQ;
338      if (source == "HLTDAQ" ) {
339         numSources=2;
340         qaSource[0] = AliShuttleInterface::kHLT;
341         qaSource[1] = AliShuttleInterface::kDAQ;
342      }
343      if (source == "DAQHLT" ) numSources=2;
344      UInt_t qaResult=0;
345      for (Int_t i=0; i<numSources; i++ ) {      
346        qaResult = ExtractQA(qaSource[i]);
347        if ( qaResult == 0 ) break;
348      }
349 //     result += qaResult;
350      if ( qaResult !=0 ) Log ("ExtractQA failed, no QA entry available.");
351      status = new TParameter<int>("qaResult",qaResult);
352      resultArray->Add(status);
353     }
354    }
355   }
356   
357   if (errorHandling == "OFF" ) {
358     AliCDBMetaData metaData;
359     metaData.SetBeamPeriod(0);
360     metaData.SetResponsible("Haavard Helstrup");
361     metaData.SetComment("Preprocessor AliTPC status.");
362     Store("Calib", "PreprocStatus", resultArray, &metaData, 0, kFALSE);
363     resultArray->Delete();
364     return 0;
365   } else { 
366     return result;
367   }
368 }
369 //______________________________________________________________________________________________
370 UInt_t AliTPCPreprocessor::MapTemperature(TMap* dcsAliasMap)
371 {
372
373    // extract DCS temperature maps. Perform fits to save space
374
375   UInt_t result=0;
376   TMap *map = fTemp->ExtractDCS(dcsAliasMap);
377   if (map) {
378     fTemp->MakeSplineFit(map);
379     Double_t fitFraction = 1.0*fTemp->NumFits()/fTemp->NumSensors(); 
380     if (fitFraction > kFitFraction ) {
381       AliInfo(Form("Temperature values extracted, fits performed.\n"));
382     } else { 
383       Log ("Too few temperature maps fitted. \n");
384       result = 9;
385     }
386   } else {
387     Log("No temperature map extracted. \n");
388     result=9;
389   }
390   delete map;
391   // Now store the final CDB file
392
393   if ( result == 0 ) {
394         AliCDBMetaData metaData;
395         metaData.SetBeamPeriod(0);
396         metaData.SetResponsible("Haavard Helstrup");
397         metaData.SetComment("Preprocessor AliTPC data base entries.");
398
399         Bool_t storeOK = Store("Calib", "Temperature", fTemp, &metaData, 0, kFALSE);
400         if ( !storeOK )  result=1;
401
402    }
403
404    return result;
405
406 }
407
408 //______________________________________________________________________________________________
409 UInt_t AliTPCPreprocessor::MapHighVoltage(TMap* dcsAliasMap)
410 {
411
412    // extract DCS HV maps. Perform fits to save space
413
414   UInt_t result=0;
415   TMap *map = fHighVoltage->ExtractDCS(dcsAliasMap);
416   if (map) {
417     fHighVoltage->MakeSplineFit(map);
418     Double_t fitFraction = 1.0*fHighVoltage->NumFits()/fHighVoltage->NumSensors(); 
419     if (fitFraction > kFitFraction ) {
420       AliInfo(Form("High voltage recordings extracted, fits performed.\n"));
421     } else { 
422       Log ("Too few high voltage recordings fitted. \n");
423       result = 9;
424     }
425   } else {
426     Log("No high voltage recordings extracted. \n");
427     result=9;
428   }
429   delete map;
430
431   TString hvStatConf = fConfEnv->GetValue("HighVoltageStat","ON");
432   hvStatConf.ToUpper();
433   if (hvStatConf != "OFF" ) { 
434     TMap *map2 = fHighVoltageStat->ExtractDCS(dcsAliasMap);
435     if (map2) {
436       fHighVoltageStat->ClearFit();
437       fHighVoltageStat->SetGraph(map2);
438     } else {
439        Log("No high voltage status recordings extracted. \n");
440       result=9;
441     }
442     delete map2;
443
444     // add status maps to high voltage sensor array
445
446     fHighVoltage->AddSensors(fHighVoltageStat);
447    }
448   // Now store the final CDB file
449
450   if ( result == 0 ) {
451         AliCDBMetaData metaData;
452         metaData.SetBeamPeriod(0);
453         metaData.SetResponsible("Haavard Helstrup");
454         metaData.SetComment("Preprocessor AliTPC data base entries.");
455
456         Bool_t storeOK = Store("Calib", "HighVoltage", fHighVoltage, &metaData, 0, kFALSE);
457         if ( !storeOK )  result=1;
458
459    }
460
461    return result;
462
463 }
464
465
466 //______________________________________________________________________________________________
467
468 UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
469 {
470  //
471  //  Read pedestal file from file exchage server
472  //  Keep original entry from OCDB in case no new pedestals are available
473  //
474  AliTPCCalPad *calPadPed=0;
475  AliCDBEntry* entry = GetFromOCDB("Calib", "Pedestals");
476  if (entry) calPadPed = (AliTPCCalPad*)entry->GetObject();
477  if ( calPadPed==NULL ) {
478      Log("AliTPCPreprocsessor: No previous TPC pedestal entry available.\n");
479      calPadPed = new AliTPCCalPad("PedestalsMean","PedestalsMean");
480  }
481
482  AliTPCCalPad *calPadRMS=0;
483  entry = GetFromOCDB("Calib", "PadNoise");
484  if (entry) calPadRMS = (AliTPCCalPad*)entry->GetObject();
485  if ( calPadRMS==NULL ) {
486      Log("AliTPCPreprocsessor: No previous TPC noise entry available.\n");
487      calPadRMS = new AliTPCCalPad("PedestalsRMS","PedestalsRMS");
488  }
489
490
491  UInt_t result=0;
492
493  Int_t nSectors = fROC->GetNSectors();
494  TList* list = GetFileSources(sourceFXS,"pedestals");
495  
496  if (list && list->GetEntries()>0) {
497
498 //  loop through all files from LDCs
499
500     Bool_t changed=false;
501     UInt_t index = 0;
502     while (list->At(index)!=NULL) {
503      TObjString* fileNameEntry = (TObjString*) list->At(index);
504      if (fileNameEntry!=NULL) {
505         TString fileName = GetFile(sourceFXS, "pedestals",
506                                          fileNameEntry->GetString().Data());
507         TFile *f = TFile::Open(fileName);
508         if (!f) {
509           Log ("Error opening pedestal file.");
510           result =2;
511           break;
512         }
513         AliTPCCalibPedestal *calPed;
514         f->GetObject("tpcCalibPedestal",calPed);
515         if ( !calPed ) {
516           Log ("No pedestal calibration object in file.");
517           result = 2;
518           break;
519         }
520
521         //  replace entries for the sectors available in the present file
522
523         changed=true;
524         for (Int_t sector=0; sector<nSectors; sector++) {
525            AliTPCCalROC *rocPed=calPed->GetCalRocPedestal(sector, kFALSE);
526            if ( rocPed )  calPadPed->SetCalROC(rocPed,sector);
527            AliTPCCalROC *rocRMS=calPed->GetCalRocRMS(sector, kFALSE);
528            if ( rocRMS )  calPadRMS->SetCalROC(rocRMS,sector);
529         }
530         delete calPed; 
531         f->Close();
532       }
533      ++index;
534     }  // while(list)
535 //
536 //  Store updated pedestal entry to OCDB
537 //
538     if (changed) {
539      AliCDBMetaData metaData;
540      metaData.SetBeamPeriod(0);
541      metaData.SetResponsible("Haavard Helstrup");
542      metaData.SetComment("Preprocessor AliTPC data base entries."); 
543  
544      Bool_t storeOK = Store("Calib", "Pedestals", calPadPed, &metaData, 0, kTRUE);
545      if ( !storeOK ) ++result;
546      storeOK = Store("Calib", "PadNoise", calPadRMS, &metaData, 0, kTRUE);
547      if ( !storeOK ) ++result;
548     }
549   } else {
550     Log ("Error: no entries in input file list!");
551     result = 1;
552   }
553
554   return result;
555 }
556
557 //______________________________________________________________________________________________
558
559
560 UInt_t AliTPCPreprocessor::ExtractPulser(Int_t sourceFXS)
561 {
562  //
563  //  Read pulser calibration file from file exchage server
564  //  Keep original entry from OCDB in case no new pulser calibration is available
565  //
566  TObjArray    *pulserObjects=0;
567  AliTPCCalPad *pulserTmean=0;
568  AliTPCCalPad *pulserTrms=0;
569  AliTPCCalPad *pulserQmean=0;
570  AliCDBEntry* entry = GetFromOCDB("Calib", "Pulser");
571  if (entry) pulserObjects = (TObjArray*)entry->GetObject();
572  if ( pulserObjects==NULL ) {
573      Log("AliTPCPreprocsessor: No previous TPC pulser entry available.\n");
574      pulserObjects = new TObjArray;    
575  }
576
577  pulserTmean = (AliTPCCalPad*)pulserObjects->FindObject("PulserTmean");
578  if ( !pulserTmean ) {
579     pulserTmean = new AliTPCCalPad("PulserTmean","PulserTmean");
580     pulserObjects->Add(pulserTmean);
581  }
582  pulserTrms = (AliTPCCalPad*)pulserObjects->FindObject("PulserTrms");
583  if ( !pulserTrms )  { 
584     pulserTrms = new AliTPCCalPad("PulserTrms","PulserTrms");
585     pulserObjects->Add(pulserTrms);
586  }
587  pulserQmean = (AliTPCCalPad*)pulserObjects->FindObject("PulserQmean");
588  if ( !pulserQmean )  { 
589     pulserQmean = new AliTPCCalPad("PulserQmean","PulserQmean");
590     pulserObjects->Add(pulserQmean);
591  }
592
593
594  UInt_t result=0;
595
596  Int_t nSectors = fROC->GetNSectors();
597  TList* list = GetFileSources(sourceFXS,"pulser");
598  
599  if (list && list->GetEntries()>0) {
600
601 //  loop through all files from LDCs
602
603     Bool_t changed=false;
604     UInt_t index = 0;
605     while (list->At(index)!=NULL) {
606      TObjString* fileNameEntry = (TObjString*) list->At(index);
607      if (fileNameEntry!=NULL) {
608         TString fileName = GetFile(sourceFXS, "pulser",
609                                          fileNameEntry->GetString().Data());
610         TFile *f = TFile::Open(fileName);
611         if (!f) {
612           Log ("Error opening pulser file.");
613           result =2;
614           break;
615         }
616         AliTPCCalibPulser *calPulser;
617         f->GetObject("tpcCalibPulser",calPulser);
618         if ( !calPulser ) {
619           Log ("No pulser calibration object in file.");
620           result = 2;
621           break;
622         }
623
624         //  replace entries for the sectors available in the present file
625
626         changed=true;
627         for (Int_t sector=0; sector<nSectors; sector++) {
628            AliTPCCalROC *rocTmean=calPulser->GetCalRocT0(sector);
629            if ( rocTmean )  pulserTmean->SetCalROC(rocTmean,sector);
630            AliTPCCalROC *rocTrms=calPulser->GetCalRocRMS(sector);
631            if ( rocTrms )  pulserTrms->SetCalROC(rocTrms,sector);
632            AliTPCCalROC *rocQmean=calPulser->GetCalRocQ(sector);
633            if ( rocQmean )  pulserQmean->SetCalROC(rocQmean,sector);
634         }
635        delete calPulser;
636        f->Close();
637       }
638      ++index;
639     }  // while(list)
640 //
641 //  Store updated pedestal entry to OCDB
642 //
643     if (changed) {
644      AliCDBMetaData metaData;
645      metaData.SetBeamPeriod(0);
646      metaData.SetResponsible("Haavard Helstrup");
647      metaData.SetComment("Preprocessor AliTPC data base entries.");
648
649      Bool_t storeOK = Store("Calib", "Pulser", pulserObjects, &metaData, 0, kTRUE);
650      if ( !storeOK ) ++result;
651     }  
652   } else {
653     Log ("Error: no entries in input file list!");
654     result = 1;
655   }
656
657   return result;
658 }
659
660 UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
661 {
662  //
663  //  Read Central Electrode file from file exchage server
664  //  Keep original entry from OCDB in case no new CE calibration is available
665  //
666  TObjArray    *ceObjects=0;
667  AliTPCCalPad *ceTmean=0;
668  AliTPCCalPad *ceTrms=0;
669  AliTPCCalPad *ceQmean=0;
670  TObjArray    *rocTtime=0;  
671  TObjArray    *rocQtime=0;  
672
673  AliCDBEntry* entry = GetFromOCDB("Calib", "CE");
674  if (entry) ceObjects = (TObjArray*)entry->GetObject();
675  if ( ceObjects==NULL ) {
676      Log("AliTPCPreprocsessor: No previous TPC central electrode entry available.\n");
677      ceObjects = new TObjArray;    
678  }
679
680  Int_t nSectors = fROC->GetNSectors();
681
682  ceTmean = (AliTPCCalPad*)ceObjects->FindObject("CETmean");
683  if ( !ceTmean ) {
684     ceTmean = new AliTPCCalPad("CETmean","CETmean");
685     ceObjects->Add(ceTmean);
686  }
687  ceTrms = (AliTPCCalPad*)ceObjects->FindObject("CETrms");
688  if ( !ceTrms )  { 
689     ceTrms = new AliTPCCalPad("CETrms","CETrms");
690     ceObjects->Add(ceTrms);
691  }
692  ceQmean = (AliTPCCalPad*)ceObjects->FindObject("CEQmean");
693  if ( !ceQmean )  { 
694     ceQmean = new AliTPCCalPad("CEQmean","CEQmean");
695     ceObjects->Add(ceQmean);
696  }
697  //!new from here please have a look!!!
698  rocTtime = (TObjArray*)ceObjects->FindObject("rocTtime");
699  if ( !rocTtime ) {
700      rocTtime = new TObjArray(nSectors);
701      rocTtime->SetName("rocTtime");
702      ceObjects->Add(rocTtime);
703  }
704  
705  rocQtime = (TObjArray*)ceObjects->FindObject("rocQtime");
706  if ( !rocQtime ) {
707      rocQtime = new TObjArray(nSectors);
708      rocQtime->SetName("rocQtime");
709      ceObjects->Add(rocQtime);
710  }
711
712
713  UInt_t result=0;
714
715  TList* list = GetFileSources(sourceFXS,"CE");
716  
717  if (list && list->GetEntries()>0) {
718
719 //  loop through all files from LDCs
720
721     UInt_t index = 0;
722     while (list->At(index)!=NULL) {
723      TObjString* fileNameEntry = (TObjString*) list->At(index);
724      if (fileNameEntry!=NULL) {
725         TString fileName = GetFile(sourceFXS, "CE",
726                                          fileNameEntry->GetString().Data());
727         TFile *f = TFile::Open(fileName);
728         if (!f) {
729           Log ("Error opening central electrode file.");
730           result =2;
731           break;
732         }
733         AliTPCCalibCE *calCE;
734         f->GetObject("tpcCalibCE",calCE);
735
736         //  replace entries for the sectors available in the present file
737
738         for (Int_t sector=0; sector<nSectors; sector++) {
739            AliTPCCalROC *rocTmean=calCE->GetCalRocT0(sector);
740            if ( rocTmean )  ceTmean->SetCalROC(rocTmean,sector);
741            AliTPCCalROC *rocTrms=calCE->GetCalRocRMS(sector);
742            if ( rocTrms )  ceTrms->SetCalROC(rocTrms,sector);
743            AliTPCCalROC *rocQmean=calCE->GetCalRocQ(sector);
744            if ( rocQmean )  ceQmean->SetCalROC(rocQmean,sector);
745            TGraph *grT=calCE->MakeGraphTimeCE(sector,0,2); // T time graph
746            if ( grT ) rocTtime->AddAt(grT,sector);         
747            TGraph *grQ=calCE->MakeGraphTimeCE(sector,0,3); // Q time graph
748            if ( grQ ) rocTtime->AddAt(grQ,sector);         
749         }
750        delete calCE;
751        f->Close();
752       }
753      ++index;
754     }  // while(list)
755 //
756 //  Store updated pedestal entry to OCDB
757 //
758     AliCDBMetaData metaData;
759     metaData.SetBeamPeriod(0);
760     metaData.SetResponsible("Haavard Helstrup");
761     metaData.SetComment("Preprocessor AliTPC data base entries.");
762
763     Bool_t storeOK = Store("Calib", "CE", ceObjects, &metaData, 0, kTRUE);
764     if ( !storeOK ) ++result;
765     
766   } else {
767     Log ("Error: no entries!");
768     result = 1;
769   }
770
771   return result;
772 }
773 //______________________________________________________________________________________________
774
775 UInt_t AliTPCPreprocessor::ExtractQA(Int_t sourceFXS)
776 {
777  //
778  //  Read Quality Assurance file from file exchage server
779  //
780  
781  UInt_t result=0;
782
783  TList* list = GetFileSources(sourceFXS,"QA");
784  
785  if (list && list->GetEntries()>0) {
786
787 //  only one QA objetc should be available!
788
789     AliTPCdataQA *calQA;
790
791     UInt_t nentries = list->GetEntries();  
792     UInt_t index=0;
793     if ( nentries > 1) Log ( "More than one QA entry. First one processed");      
794     TObjString* fileNameEntry = (TObjString*) list->At(index);
795     if (fileNameEntry!=NULL) {
796         TString fileName = GetFile(sourceFXS, "QA",
797                                          fileNameEntry->GetString().Data());
798         TFile *f = TFile::Open(fileName);
799         if (!f) {
800           Log ("Error opening QA file.");
801           result =2;          
802         } else {
803           f->GetObject("tpcCalibQA",calQA);
804       
805 //
806 //  Store updated pedestal entry to OCDB
807 //
808          AliCDBMetaData metaData;
809          metaData.SetBeamPeriod(0);
810          metaData.SetResponsible("Haavard Helstrup");
811          metaData.SetComment("Preprocessor AliTPC data base entries.");
812
813          Bool_t storeOK = Store("Calib", "QA", calQA, &metaData, 0, kTRUE);
814          if ( !storeOK ) ++result;
815         }
816     } else {
817     Log ("Error: no QA files on FXS!");
818     result = 2;
819     }
820   } else {
821     Log ("Error: no QA entries in FXS list!");
822     result = 1;
823   }
824   return result;
825 }
826