AddRunType cals added for SPD preprocessor (H. Tydesjo)
[u/mrichter/AliRoot.git] / ITS / AliITSPreprocessorSPD.cxx
1 ///////////////////////////////////////////////
2 //  Author: Henrik Tydesjo                   //
3 //  Preprocessor Class for the SPD           //
4 //                                           //
5 ///////////////////////////////////////////////
6
7 #include "AliITSPreprocessorSPD.h"
8 #include "AliITSCalibrationSPD.h"
9 #include "AliITSOnlineCalibrationSPDhandler.h"
10 #include "AliCDBEntry.h"
11 #include "AliCDBMetaData.h"
12 #include "AliShuttleInterface.h"
13 #include "AliLog.h"
14 #include <TTimeStamp.h>
15 #include <TObjString.h>
16 #include <TSystem.h>
17 #include <fstream>
18
19 /* $Id$ */
20
21 ClassImp(AliITSPreprocessorSPD)
22
23 //______________________________________________________________________________________________
24 AliITSPreprocessorSPD::AliITSPreprocessorSPD(AliShuttleInterface* shuttle) :
25   AliPreprocessor("SPD", shuttle), fIdList()
26 {
27   // constructor
28   AddRunType("DAQ_MIN_TH_SCAN");
29   AddRunType("DAQ_MEAN_TH_SCAN");
30   AddRunType("DAQ_UNIFORMITY_SCAN");
31   AddRunType("DAQ_NOISY_PIX_SCAN");
32   AddRunType("DAQ_PIX_DELAY_SCAN");
33   AddRunType("DAQ_FO_UNIF_SCAN");
34   AddRunType("PHYSICS");
35
36   fIdList.SetOwner(kTRUE);
37 }
38
39 //______________________________________________________________________________________________
40 AliITSPreprocessorSPD::~AliITSPreprocessorSPD()
41 {
42   // destructor
43 }
44
45 //______________________________________________________________________________________________
46 void AliITSPreprocessorSPD::Initialize(Int_t run, UInt_t startTime,
47         UInt_t endTime)
48 {
49   // initialize
50   AliPreprocessor::Initialize(run, startTime, endTime);
51
52   AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run,
53                TTimeStamp(startTime).AsString(),
54                TTimeStamp(endTime).AsString()));
55 }
56
57 //______________________________________________________________________________________________
58 UInt_t AliITSPreprocessorSPD::Process(TMap* /*dcsAliasMap*/)
59 {
60   // Do the actual preprocessing
61
62
63   // *** GET RUN TYPE ***
64
65   TString runType = GetRunType();
66
67
68   fIdList.Clear();
69   UInt_t nrEqForScan  = 0;
70   //  UInt_t nrEqForPhysN = 0;
71   //  UInt_t nrEqForPhysD = 0;
72
73   // ******************************************************************************************** //
74   // *** GET THE FILE IDs FOR DEBUGGING *** //
75   if (runType == "DAQ_MIN_TH_SCAN" || 
76       runType == "DAQ_MEAN_TH_SCAN" || 
77       runType == "DAQ_UNIFORMITY_SCAN" || 
78       runType == "DAQ_NOISY_PIX_SCAN" || 
79       runType == "DAQ_PIX_DELAY_SCAN" || 
80       runType == "DAQ_FO_UNIF_SCAN" || 
81       runType == "PHYSICS") {
82     TString idListId = "SPD_id_list";
83     TList* list = GetFileSources(kDAQ,idListId.Data());
84     UInt_t nrIdFiles = 0;
85     if (list) {
86       TListIter *iter = new TListIter(list);
87       while (TObjString* fileNameEntry = (TObjString*) iter->Next()) {
88         TString fileName = GetFile(kDAQ, idListId.Data(), fileNameEntry->GetString().Data());
89         if (fileName.IsNull()) {
90           Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
91           return 1;
92         }
93         nrIdFiles++;
94         ifstream idFile;
95         idFile.open(fileName.Data(), ifstream::in);
96         if (idFile.fail()) {
97           Log(Form("Could not open file (%s) for reading.",fileName.Data()));
98           return 1;
99         }
100         else {
101           while(1) {
102             Char_t id[50];
103             idFile >> id;
104             if (idFile.eof()) break;
105             // Add id to the list;
106             fIdList.AddLast(new TObjString(id));
107           }
108         }
109         idFile.close();
110       }
111       delete iter;
112     }
113     if (nrIdFiles==0) {
114       Log("Failed to retrieve any id list file.");
115       return 1;
116     }
117   }
118
119
120   // ******************************************************************************************** //
121   // *** REFERENCE DATA *** //
122
123   // Standalone runs:
124   if (runType == "DAQ_MIN_TH_SCAN" ||
125       runType == "DAQ_MEAN_TH_SCAN" ||
126       runType == "DAQ_UNIFORMITY_SCAN" ||
127       runType == "DAQ_NOISY_PIX_SCAN" ||
128       runType == "DAQ_PIX_DELAY_SCAN" ||
129       runType == "DAQ_FO_UNIF_SCAN") {
130     // Store the scan container files as reference data (0 or 1 file for each equipment)
131     for (UInt_t eq=0; eq<20; eq++) {
132       TString id = Form("SPD_ref_scan_%d",eq);
133       TList* list = GetFileSources(kDAQ,id.Data()); // (the id should be unique, so always 1 file)
134       if (list) {
135         TObjString* fileNameEntry = (TObjString*) list->First();
136         if (fileNameEntry!=NULL) {
137           nrEqForScan++;
138           TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
139           if (fileName.IsNull()) {
140             Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
141             return 1;
142           }
143           if (!RemoveIdFromList(id.Data())) {
144             Log(Form("Warning: Retrieved file with id %s, that was not in the id list!",id.Data()));
145           }
146           TString refCAT = Form("SPD_ref_scan_eq_%d",eq);
147           if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
148             Log(Form("Failed to store reference file %s.",fileName.Data()));
149             return 1;
150           }
151         }
152       }
153     }
154   }
155
156   // Physics runs (online monitoring):
157   if (runType == "PHYSICS") {
158     // Store the phys "per run" container files as reference data
159     if (!StoreRefFromTarForId("SPD_ref_phys")) return 1;
160     // Store the phys "dead" container files as reference data
161     if (!StoreRefFromTarForId("SPD_ref_phys_dead")) return 1;
162   }
163
164
165 // *** OLD CODE NOT TARED
166 //    for (UInt_t eq=0; eq<20; eq++) {
167 //      TString id = Form("SPD_ref_phys_%d",eq);
168 //      TList* list = GetFileSources(kDAQ,id.Data()); // (the id should be unique, so always 1 file)
169 //      if (list) {
170 //      TObjString* fileNameEntry = (TObjString*) list->First();
171 //      if (fileNameEntry!=NULL) {
172 //        nrEqForPhysN++;
173 //        TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
174 //        if (fileName.IsNull()) {
175 //          Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
176 //          return 1;
177 //        }
178 //        if (!RemoveIdFromList(id.Data())) {
179 //          Log(Form("Warning: Retrieved file with id %s, that was not in the id list!",id.Data()));
180 //        }
181 //        TString refCAT = Form("SPD_ref_phys_eq_%d",eq);
182 //        if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
183 //          Log(Form("Failed to store reference file %s.",fileName.Data()));
184 //          return 1;
185 //        }
186 //      }
187 //      }
188 //    }
189 // ***
190
191 // *** OLD CODE NOT TARED
192 //    // Store the phys "dead" container files as reference data (0 or 1 file for each equipment)
193 //    for (UInt_t eq=0; eq<20; eq++) {
194 //      TString id = Form("SPD_ref_phys_dead_%d",eq);
195 //      TList* list = GetFileSources(kDAQ,id.Data()); // (the id should be unique, so always 1 file)
196 //      if (list) {
197 //      TObjString* fileNameEntry = (TObjString*) list->First();
198 //      if (fileNameEntry!=NULL) {
199 //        nrEqForPhysD++;
200 //        TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
201 //        if (fileName.IsNull()) {
202 //          Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
203 //          return 1;
204 //        }
205 //        if (!RemoveIdFromList(id.Data())) {
206 //          Log(Form("Warning: Retrieved file with id %s, that was not in the id list!",id.Data()));
207 //        }
208 //        TString refCAT = Form("SPD_ref_phys_dead_eq_%d",eq);
209 //        if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
210 //          Log(Form("Failed to store reference file %s.",fileName.Data()));
211 //          return 1;
212 //        }
213 //      }
214 //      }
215 //    }
216 //  }
217 // ***
218
219   // ******************************************************************************************** //
220
221
222   // *** NOISY AND DEAD DATA *** //
223
224   // Standalone runs:
225   if (runType == "DAQ_NOISY_PIX_SCAN") {
226     // Retrieve and unpack tared calibration files from FXS
227     TString id = "SPD_scan_noisy";
228     TList* list = GetFileSources(kDAQ,id.Data());
229     if (list) {
230       UInt_t index = 0;
231       while (list->At(index)!=NULL) {
232         TObjString* fileNameEntry = (TObjString*) list->At(index);
233         TString fileName = GetFile(kDAQ, id.Data(), fileNameEntry->GetString().Data());
234         if (fileName.IsNull()) {
235           Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
236           return 1;
237         }
238         if (!RemoveIdFromList("SPD_scan_noisy")) {
239           Log(Form("Warning: Retrieved file with id %s, that was not in the id list!",id.Data()));
240         }
241         TString command = Form("tar -xf %s",fileName.Data());
242         gSystem->Exec(command.Data());
243         index++;
244       }
245     }
246     // Create new database entries
247     TObjArray* spdEntryNoisy = new TObjArray(240);
248     spdEntryNoisy->SetOwner(kTRUE);
249     for(UInt_t module=0; module<240; module++){
250       AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
251       spdEntryNoisy->Add(calObj);
252     }
253     // Add noisy from the copied FXS files
254     AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
255     TString fileLoc = ".";
256     handler->SetFileLocation(fileLoc.Data());
257     handler->ReadNoisyFromFiles();
258     for (Int_t module=0; module<240; module++) {
259       ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetNrBad( handler->GetNrNoisy(module) );
260       ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetBadList( handler->GetNoisyArray(module) );
261     }
262     delete handler;
263     // Store the new calibration objects in OCDB
264     Log("Noisy lists (scan) will be stored...");
265     AliCDBMetaData metaData;
266     metaData.SetBeamPeriod(0);
267     metaData.SetResponsible("Henrik Tydesjo");
268     metaData.SetComment("Created by SPD PreProcessor");
269     // validity for this run until infinity
270     if (!Store("Calib", "SPDNoisy", spdEntryNoisy, &metaData, 0, kTRUE)) {
271       Log("Failed to store calibration data.");
272       return 1;
273     }
274     Log("Database updated.");
275     delete spdEntryNoisy;
276   }
277
278   // Physics runs (online monitoring):
279   else if (runType == "PHYSICS") {
280
281     // Noisy pixels:
282     // Read noisy from previous calibration
283     AliCDBEntry* cdbEntry = GetFromOCDB("Calib", "SPDNoisy");
284     TObjArray* spdEntryNoisy;
285     if(cdbEntry) {
286       spdEntryNoisy = (TObjArray*)cdbEntry->GetObject();
287       if(!spdEntryNoisy) return 1;
288     }
289     else {
290       Log("Old calibration not found in database. This is required for further processing.");
291       return 1;
292     }
293     AliITSOnlineCalibrationSPDhandler* handOld = new AliITSOnlineCalibrationSPDhandler();
294     handOld->ReadNoisyFromCalibObj(spdEntryNoisy);
295     // Retrieve and unpack tared calibration files from FXS
296     TString idN = "SPD_phys_noisy";
297     TList* listN = GetFileSources(kDAQ,idN.Data());
298     if (listN) {
299       UInt_t index = 0;
300       while (listN->At(index)!=NULL) {
301         TObjString* fileNameEntry = (TObjString*) listN->At(index);
302         TString fileName = GetFile(kDAQ, idN.Data(), fileNameEntry->GetString().Data());
303         if (fileName.IsNull()) {
304           Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
305           return 1;
306         }
307         if (!RemoveIdFromList(idN.Data())) {
308           Log(Form("Warning: Retrieved file with id %s, that was not in the id list!",idN.Data()));
309         }
310         TString command = Form("tar -xf %s",fileName.Data());
311         gSystem->Exec(command.Data());
312         index++;
313       }
314     }
315     AliITSOnlineCalibrationSPDhandler* handNew = new AliITSOnlineCalibrationSPDhandler();
316     handNew->SetFileLocation(".");
317     handNew->ReadNoisyFromFiles();
318     // add the new list to the old one
319     UInt_t nrNewNoisy = handOld->AddNoisyFrom(handNew);
320     // If new noisy pixels were found: Update calibration objects
321     if (nrNewNoisy>0) {
322       for (Int_t module=0; module<240; module++) {
323         ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetNrBad( handOld->GetNrNoisy(module) );
324         ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetBadList( handOld->GetNoisyArray(module) );
325       }
326       // Store the new calibration objects in OCDB
327       Log("Noisy lists (phys) will be stored...");
328       AliCDBMetaData metaData;
329       metaData.SetBeamPeriod(0);
330       metaData.SetResponsible("Henrik Tydesjo");
331       metaData.SetComment("Created by SPD PreProcessor");  
332       // validity for this run only
333       if (!Store("Calib", "SPDNoisy", spdEntryNoisy, &metaData, 0, kFALSE)) {
334         Log("Failed to store calibration data.");
335         return 1;
336       }
337       Log("Database updated.");
338     }
339     delete handNew;
340
341     // Dead pixels:
342     // Retrieve and unpack tared calibration files from FXS
343     TString idD = "SPD_phys_dead";
344     TList* listD = GetFileSources(kDAQ,idD.Data());
345     UInt_t nrPhysDeadFiles = 0;
346     if (listD) {
347       UInt_t index = 0;
348       while (listD->At(index)!=NULL) {
349         TObjString* fileNameEntry = (TObjString*) listD->At(index);
350         TString fileName = GetFile(kDAQ, idD.Data(), fileNameEntry->GetString().Data());
351         if (fileName.IsNull()) {
352           Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
353           return 1;
354         }
355         nrPhysDeadFiles++;
356         if (!RemoveIdFromList("SPD_phys_dead")) {
357           Log(Form("Warning: Retrieved file with id %s, that was not in the id list!",idD.Data()));
358         }
359         TString command = Form("tar -xf %s",fileName.Data());
360         gSystem->Exec(command.Data());
361         index++;
362       }
363     }
364     if (nrPhysDeadFiles==0) {
365       Log(Form("Could not find files with id %s. Should be present for each run.",idD.Data()));
366       return 1;
367     }
368     // Create new database entries
369     TObjArray* spdEntryDead = new TObjArray(240);
370     spdEntryDead->SetOwner(kTRUE);
371     for(UInt_t module=0; module<240; module++){
372       AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
373       spdEntryDead->Add(calObj);
374     }
375     // Add dead from the copied FXS files
376     handOld->SetFileLocation(".");
377     handOld->ReadDeadFromFiles();
378     for (Int_t module=0; module<240; module++) {
379       ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetNrBad( handOld->GetNrDead(module) );
380       ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetBadList( handOld->GetDeadArray(module) );
381     }
382     delete handOld;
383     // Store the new calibration objects in OCDB
384     Log("Dead lists (phys) will be stored...");
385     AliCDBMetaData metaData;
386     metaData.SetBeamPeriod(0);
387     metaData.SetResponsible("Henrik Tydesjo");
388     metaData.SetComment("Created by SPD PreProcessor");
389     // validity for this run only
390     if (!Store("Calib", "SPDDead", spdEntryDead, &metaData, 0, kFALSE)) {
391       Log("Failed to store calibration data.");
392       return 1;
393     }
394     Log("Database updated.");
395     delete spdEntryDead;
396
397   }
398
399
400   // check that there are no ids left in the list:
401   if (fIdList.First()!=NULL) {
402     TString logMessage = "";
403     TListIter *iter = new TListIter(&fIdList);
404     while (TObjString *st = (TObjString*)iter->Next()) {
405       logMessage.Append(st->GetString());
406       logMessage.Append(" ");
407     }
408     delete iter;
409     Log(Form("Files with the following ids were never retrieved: %s.",logMessage.Data()));
410     return 1;
411   }
412
413   fIdList.Clear();
414
415   return 0; // 0 means success
416
417 }
418 //_________________________________________________________________________________________
419 Bool_t AliITSPreprocessorSPD::RemoveIdFromList(const Char_t *id) {
420   // removes id from the list of ids
421   Bool_t found = kFALSE;
422   TListIter *iter = new TListIter(&fIdList);
423   while (TObjString *st = (TObjString*)iter->Next()) {
424     if (st->GetString().CompareTo(id)==0) {
425       fIdList.Remove(st);
426       found = kTRUE;
427       break;
428     }
429   }
430   delete iter;
431   return found;
432 }
433 //_________________________________________________________________________________________
434 Bool_t AliITSPreprocessorSPD::StoreRefFromTarForId(const Char_t *id) {
435   // store reference files from tar file for the id given (this is just to not duplicate code)
436   TList* list = GetFileSources(kDAQ,id);
437   if (list) {
438     UInt_t index = 0;
439     while (list->At(index)!=NULL) {
440       TObjString* fileNameEntry = (TObjString*) list->At(index);
441       TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
442       if (fileName.IsNull()) {
443         Log(Form("GetFile failed to retrieve file %s.",fileNameEntry->GetString().Data()));
444         return kFALSE;
445       }
446       if (!RemoveIdFromList(id)) {
447         Log(Form("Warning: Retrieved file with id %s, that was not in the id list!",id));
448       }
449       // get the file names from the tar file
450       //      TString pwd = gSystem->pwd();
451       //      TString tempFileName = Form("%s/tempTar.txt",pwd.Data());
452       TString tempFileName = "tempTar.txt";
453       TString command = Form("tar -tf %s > %s",fileName.Data(),tempFileName.Data());
454       gSystem->Exec(command.Data());
455       TList fList;
456       ifstream tempFile;
457       tempFile.open(tempFileName.Data(), ifstream::in);
458       if (tempFile.fail()) {
459         Log(Form("Could not open file (%s) for reading.",tempFileName.Data()));
460         return kFALSE;
461       }
462       else {
463         while(1) {
464           Char_t fileN[100];
465           tempFile >> fileN;
466           if (tempFile.eof()) break;
467           fList.AddLast(new TObjString(fileN));
468         }
469       }
470       // close and remove temp file
471       tempFile.close();
472       command = Form("rm -f %s",tempFileName.Data());
473       gSystem->Exec(command.Data());
474       // unpack
475       command = Form("tar -xf %s",fileName.Data());
476       gSystem->Exec(command.Data());
477       // store each file
478       UInt_t index2 = 0;
479       while (fList.At(index2)!=NULL) {
480         TString fileName = ((TObjString*)fList.At(index2))->GetString();
481         // get eq id
482         TString eqStr = fileName.Data();
483         UInt_t len = eqStr.Length();
484         eqStr.Replace(0,len-7,"",0);
485         eqStr.ReplaceAll("_",1,"",0);
486         eqStr.ReplaceAll(".root",5,"",0);
487         Int_t eqId = eqStr.Atoi();
488         if (eqId>=0 && eqId<20) {
489           TString refCAT = Form("%s_eq_%d",id,eqId);
490           if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
491             Log(Form("Failed to store reference file %s.",fileName.Data()));
492             return kFALSE;
493           }
494         }
495         else {
496           Log(Form("Eq ID %d out of bounds for file %s",eqId,fileName.Data()));
497           fList.Clear();
498           return kFALSE;
499         }
500         index2++;
501       }
502       fList.Clear();
503       index++;
504     }
505   }
506   return kTRUE;
507 }