New plots for trending injector efficiencies (Melinda)
[u/mrichter/AliRoot.git] / ITS / patchSSDBadChannelsMap.C
1 //\r
2 // Macro adds ether ladder, module or channel to the SSD bad channels map.\r
3 // Input parameter: file name with original SSD bad channels map (optional),  \r
4 //                  equipment identifier (DDL),\r
5 //                  Slot number, ADC number (optional) and channel number (optional)\r
6 // Author: Oleksandr.Borysov@cern.ch\r
7 //\r
8 \r
9 \r
10 #if !defined(__CINT__) || defined(__MAKECINT__)\r
11 #include <time.h>\r
12 #include <Riostream.h>\r
13 #include "TStyle.h"\r
14 #include "TFile.h"\r
15 #include "TCanvas.h"\r
16 #include "TH2F.h"\r
17 #include "TString.h"\r
18 #include "AliLog.h"\r
19 #include "AliRawReaderRoot.h"\r
20 #include "AliITSRawStreamSSDv1.h"\r
21 #include "AliITSBadChannelsSSDv2.h"\r
22 #include "AliITSModuleDaSSD.h"\r
23 #include "AliITSHandleDaSSD.h"\r
24 #endif\r
25 \r
26 \r
27 #define EQUIPMENTTODDLMASK        0xFF\r
28 #define NUMBEROFSSDMODULESPERSLOT 12\r
29 #define MAXSSDDDLID               15\r
30 #define MINSSDMODULEID            500\r
31 \r
32 Bool_t readBCMap(const Char_t *filename, AliITSBadChannelsSSDv2*& bcl);\r
33 Int_t addModuleBCMap(AliITSBadChannelsSSDv2 *bcl, const Int_t EqId, const Int_t SlotId, const Int_t adc);\r
34 Int_t addLadderBCMap(AliITSBadChannelsSSDv2 *bcl, const Int_t EqId, const Int_t SlotId);\r
35 Int_t  addChannelBCMap(AliITSBadChannelsSSDv2 *bcl, const Int_t EqId, const Int_t SlotId, const Int_t adc, const Int_t strp);\r
36 void  Usage (void);\r
37 void drawBadChannelMapDAQDB(const char* filename);\r
38  \r
39 //class gives an access to the protected array with SSD_DDL_Map in case the geometry is not initialized\r
40 class AliITSRawStreamSSDtmp : public AliITSRawStreamSSDv1 {\r
41 public:\r
42   AliITSRawStreamSSDtmp(AliRawReader* rawReader): AliITSRawStreamSSDv1(rawReader) {\r
43     Setv11HybridDDLMapping();\r
44     AliInfo("Using SSD DDL Map initialized by AliITSRawStreamSSDv1::Setv11HybridDDLMapping()");\r
45   }\r
46   virtual ~AliITSRawStreamSSDtmp() {};\r
47   Int_t GetModId(Int_t iDDL, Int_t iModule) {return fgkDDLModuleMap[iDDL][iModule];}\r
48   ClassDef(AliITSRawStreamSSDtmp, 0)\r
49 };\r
50 \r
51 //_________________________________________________________//\r
52 Int_t patchSSDBadChannelsMap(const Char_t *fname = 0, \r
53                              const Int_t EqId = -1, \r
54                              const Int_t SlotId = -1, \r
55                              const Int_t adc = -1, \r
56                              const Int_t strp = -1) {\r
57   //Macro to patch the bad channel list\r
58   TString    bcfname, pathstr;\r
59   AliITSBadChannelsSSDv2  *bc = 0;\r
60   if (EqId < 0) { Usage(); cerr << "Equipment number (that is DDL) must be specified! Exit.\n"; return 0; } \r
61   else if ((EqId & EQUIPMENTTODDLMASK) > MAXSSDDDLID) { \r
62     cerr << "Icorrect equipment number (that is DDL)! Exit.\n"; \r
63     return -1;\r
64   }  \r
65   if (SlotId < 1 || SlotId > 9) { \r
66     cerr << "Slot number must be specified (in the range 1 - 9)! Exit.\n"; \r
67         Usage();   \r
68     return -2; \r
69   }\r
70   if (!fname || fname[0]==0) {\r
71     cout << "File name with bad channels map is not specified, an empty map is used!\n";\r
72     bc = new AliITSBadChannelsSSDv2();\r
73     if (!bc) { cerr << "Error creating the AliITSBadChannelsSSDv2 object! Exit.\n"; return -1; }\r
74     pathstr = "";\r
75   }\r
76   else {\r
77         pathstr.Form(fname);\r
78     if (!readBCMap(fname, bc)) {\r
79       cerr << "Error reading file " << fname << " with Static Bad Channels Map! Exit.\n";\r
80       return -3;\r
81     }\r
82   }  \r
83   if (adc < 0) addLadderBCMap(bc, EqId, SlotId);\r
84   else if ((adc < 6) || (adc > 7 && (adc - 2) < NUMBEROFSSDMODULESPERSLOT) ) {\r
85     if (strp < 0) addModuleBCMap(bc, EqId, SlotId, adc);\r
86     else if (strp < AliITSModuleDaSSD::GetStripsPerModuleConst()) addChannelBCMap(bc, EqId, SlotId, adc, strp);\r
87          else {\r
88                 cerr << "Incorrect number for Strip. Exit\n";\r
89                 Usage(); \r
90             if (bc) delete bc;\r
91             return -5;\r
92         }\r
93   }\r
94   else {\r
95     cerr << "Incorrect number for ADC. Exit\n";\r
96     if (bc) delete bc;\r
97     return -4;\r
98   }\r
99   bcfname = pathstr(0, pathstr.Last('/')+1);\r
100   bcfname.Append(Form("ssdbcmap_%i.root", time(NULL)));\r
101   TFile *bcfile = new TFile (bcfname.Data(),"RECREATE");\r
102   if (bcfile->IsZombie()) {\r
103     cerr << "Error open file " << bcfname.Data() << " for writing new bad channels map!\n";\r
104     if (bc) delete bc;\r
105     return -1;\r
106   }\r
107   bcfile->WriteTObject(bc);\r
108   bcfile->Close();\r
109   delete bcfile;\r
110   cout << "New SSD bad channels map was saved in file " << bcfname.Data() << endl;\r
111   if (bc) delete bc;\r
112   return 0;\r
113 }\r
114 \r
115 //_________________________________________________________//\r
116 Bool_t readBCMap(const Char_t *filename, AliITSBadChannelsSSDv2*& bcl) {\r
117   // Reads Static Bad Channels Map from the file\r
118   TFile *bcfile;\r
119   if (!filename) {\r
120     cout << "No file name is specified for Static Bad Channels Map!\n";\r
121     return kFALSE;\r
122   } \r
123   cout << "Reading SSD Bad Channels Map from the file " << filename << endl;\r
124   bcfile = new TFile(filename, "READ");\r
125   if (bcfile->IsZombie()) {\r
126     cerr << "Error reading file " << filename << " with Static Bad Channels Map!\n";\r
127     return kFALSE;\r
128   }\r
129   bcfile->GetObject("AliITSBadChannelsSSDv2;1", bcl);\r
130   if (!bcl) {\r
131     cout << "Error bcl == NULL!\n";\r
132     bcfile->Close();\r
133     delete bcfile;\r
134     return kFALSE;\r
135   }\r
136   bcfile->Close();\r
137   delete bcfile;\r
138   return kTRUE;\r
139 }\r
140 \r
141 //_________________________________________________________//\r
142 Int_t addModuleBCMap(AliITSBadChannelsSSDv2 *bcl, \r
143                      const Int_t EqId, const Int_t SlotId, const Int_t adc) {\r
144   // Add module to bad channels map.\r
145   const Char_t     isbad = 3;\r
146   Int_t            ddl, mn, modid;\r
147   AliRawReaderRoot       *rwr = 0;\r
148   AliITSRawStreamSSDtmp  *rst = 0;\r
149   rwr = new AliRawReaderRoot();\r
150   rst = new AliITSRawStreamSSDtmp(rwr);\r
151   ddl = EqId & EQUIPMENTTODDLMASK;\r
152   mn = (SlotId - 1) * NUMBEROFSSDMODULESPERSLOT + (adc<8 ? adc : adc-2);\r
153   modid = rst->GetModId(ddl, mn);\r
154   modid -= MINSSDMODULEID;\r
155   if (modid < 0) return 0;\r
156   for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetPNStripsPerModule(); strind++) {\r
157       bcl->AddBadChannelP(modid, strind, isbad);\r
158       bcl->AddBadChannelN(modid, strind, isbad);\r
159   }\r
160   delete rst;\r
161   delete rwr;\r
162   cout << "Module added:  ModId = " << modid + MINSSDMODULEID << "; Ddl/Ad/Adc: " << ddl \r
163        << " / " << SlotId << " / " << adc << endl;\r
164   return 0;\r
165 }\r
166 \r
167 //_________________________________________________________//\r
168 Int_t addLadderBCMap(AliITSBadChannelsSSDv2 *bcl, \r
169                      const Int_t EqId, const Int_t SlotId) {\r
170   // Add ladder to bad channels map.\r
171   for (Int_t adc = 0; adc < NUMBEROFSSDMODULESPERSLOT; adc++)\r
172     addModuleBCMap(bcl, EqId, SlotId, (adc<6 ? adc : adc+2));\r
173   return 0;\r
174 }\r
175 \r
176 //_________________________________________________________//\r
177 Int_t  addChannelBCMap(AliITSBadChannelsSSDv2 *bcl, \r
178                        const Int_t EqId, const Int_t SlotId, \r
179                        const Int_t adc, const Int_t strp) {\r
180   // Add strip to bad channels map.\r
181   const Char_t     isbad = 3;\r
182   Int_t            ddl, mn, modid;         \r
183   AliRawReaderRoot       *rwr = 0;\r
184   AliITSRawStreamSSDtmp  *rst = 0;\r
185   rwr = new AliRawReaderRoot();\r
186   rst = new AliITSRawStreamSSDtmp(rwr);\r
187   ddl = EqId & EQUIPMENTTODDLMASK;\r
188   mn = (SlotId - 1) * NUMBEROFSSDMODULESPERSLOT + (adc<8 ? adc : adc-2);\r
189   modid = rst->GetModId(ddl, mn);  \r
190   modid -= MINSSDMODULEID;\r
191   if (modid < 0) { cout << "There is no module with given Equipment, Slot, adc.\n" ; return 0; }\r
192   if (strp < AliITSModuleDaSSD::GetPNStripsPerModule() ) {\r
193     bcl->AddBadChannelP(modid, strp, isbad);\r
194   } else {\r
195     bcl->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strp), isbad);\r
196   }\r
197   delete rst;\r
198   delete rwr;\r
199   cout << "Channel added (ModId/Ddl/Ad/Adc/Strip): " << modid + MINSSDMODULEID << " / " << ddl << " / " << SlotId \r
200        << " / " << adc << " / " << strp << endl;\r
201   return 0;\r
202 }\r
203 \r
204 //_________________________________________________________//\r
205 void  Usage (void) { \r
206   //Usage function\r
207   cout << "Usage: PatchSSDBadChannelsMap(bc_fname /* can be \"\" */, EqipmentId, SlotId, adc /*optional*/, strip /*optional*/)\n"; \r
208 }\r
209 \r
210 //_______________________________________//\r
211 void drawBadChannelMapDAQDB(const char* filename) {\r
212   //Draws the 2D plots of the bad channels maps\r
213   const Int_t fgkSSDMODULES = 1698;\r
214   static const Int_t fgkDefaultNStripsSSD = 768;\r
215   gStyle->SetPalette(1,0);\r
216 \r
217   TH2F *fHistDAQDBPSideBadChannelMapLayer5 = new TH2F("fHistDAQDBPSideBadChannelMapLayer5",\r
218                                                       "Layer 5;N_{module};N_{ladder}",\r
219                                                       22,1,23,\r
220                                                       34,500,534);\r
221   fHistDAQDBPSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);\r
222   fHistDAQDBPSideBadChannelMapLayer5->SetStats(kFALSE);\r
223   fHistDAQDBPSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);\r
224   fHistDAQDBPSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);\r
225   fHistDAQDBPSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);\r
226   fHistDAQDBPSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);\r
227   fHistDAQDBPSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);\r
228   fHistDAQDBPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);\r
229   fHistDAQDBPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]");\r
230 \r
231   TH2F *fHistDAQDBNSideBadChannelMapLayer5 = new TH2F("fHistDAQDBNSideBadChannelMapLayer5",\r
232                                                       "Layer 5;N_{module};N_{ladder}",\r
233                                                       22,1,23,\r
234                                                       34,500,534);\r
235   fHistDAQDBNSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);\r
236   fHistDAQDBNSideBadChannelMapLayer5->SetStats(kFALSE);\r
237   fHistDAQDBNSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);\r
238   fHistDAQDBNSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);\r
239   fHistDAQDBNSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);\r
240   fHistDAQDBNSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);\r
241   fHistDAQDBNSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);\r
242   fHistDAQDBNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);\r
243   fHistDAQDBNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]");\r
244   \r
245   TH2F *fHistDAQDBPSideBadChannelMapLayer6 = new TH2F("fHistDAQDBPSideBadChannelMapLayer6",\r
246                                                       "Layer 6;N_{module};N_{ladder}",\r
247                                                       25,1,26,\r
248                                                       38,600,638);\r
249   fHistDAQDBPSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);\r
250   fHistDAQDBPSideBadChannelMapLayer6->SetStats(kFALSE);\r
251   fHistDAQDBPSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);\r
252   fHistDAQDBPSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);\r
253   fHistDAQDBPSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);\r
254   fHistDAQDBPSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);\r
255   fHistDAQDBPSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);\r
256   fHistDAQDBPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);\r
257   fHistDAQDBPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]");\r
258 \r
259   TH2F *fHistDAQDBNSideBadChannelMapLayer6 = new TH2F("fHistDAQDBNSideBadChannelMapLayer6",\r
260                                                       "Layer 6;N_{module};N_{ladder}",\r
261                                                       25,1,26,\r
262                                                       38,600,638);\r
263   fHistDAQDBNSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);\r
264   fHistDAQDBNSideBadChannelMapLayer6->SetStats(kFALSE);\r
265   fHistDAQDBNSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);\r
266   fHistDAQDBNSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);\r
267   fHistDAQDBNSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);\r
268   fHistDAQDBNSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);\r
269   fHistDAQDBNSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);\r
270   fHistDAQDBNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);\r
271   fHistDAQDBNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]");\r
272 \r
273   //===============================//\r
274   TFile *f = TFile::Open(filename);\r
275   if(!f) {\r
276     Printf("File poiter not valid");\r
277     return;\r
278   }\r
279 \r
280   if(!f->IsOpen()) {\r
281     Printf("The file was not found");\r
282     return;\r
283   }\r
284   //===============================//\r
285 \r
286   AliITSBadChannelsSSDv2 *badChannelsSSD = new AliITSBadChannelsSSDv2();\r
287   badChannelsSSD = dynamic_cast<AliITSBadChannelsSSDv2 *>(f->Get("AliITSBadChannelsSSDv2"));\r
288 \r
289   //_____________________________________________________________________________//\r
290   Int_t nPSideChannelsTotal = 0, nNSideChannelsTotal = 0;\r
291   Int_t nBadPSideChannelsTotal = 0, nBadNSideChannelsTotal = 0;\r
292   Int_t nBadPSideChannels = 0, nBadNSideChannels = 0;\r
293   Int_t layer = 0, ladder = 0, module = 0;\r
294   Int_t nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;\r
295   Int_t nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;\r
296   //_____________________________________________________________________________//\r
297 \r
298   for(Int_t i = 0; i < fgkSSDMODULES; i++) {\r
299     //for(Int_t i = 0; i < 1; i++) {\r
300     AliITSgeomTGeo::GetModuleId(i+500,layer,ladder,module);\r
301     nBadPSideChannels = 0, nBadNSideChannels = 0;\r
302     nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;\r
303     nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;\r
304 \r
305     Int_t badChannel = 0;\r
306     for(Int_t j = 0; j < fgkDefaultNStripsSSD; j++) {\r
307       badChannel = (Int_t)(badChannelsSSD->GetBadChannelP(i,j));\r
308       //cout<<"Module: "<<i+500<< " Strip: "<<j<<" - "<<badChannel<<endl;\r
309       if(badChannel != 0) {\r
310         if(layer == 5)\r
311           nPSideChannelsLayer5 += 1;\r
312         if(layer == 6)\r
313           nPSideChannelsLayer6 += 1;\r
314         nBadPSideChannels += 1;\r
315       }\r
316       badChannel = (Int_t)(badChannelsSSD->GetBadChannelN(i,j));\r
317       //cout<<"Module: "<<i+500<< " Strip: "<<fgkDefaultNStripsSSD+j+1<<" - "<<badChannel<<endl;\r
318       if(badChannel != 0) {\r
319         if(layer == 5)                                                    \r
320           nNSideChannelsLayer5 += 1;\r
321         if(layer == 6)\r
322           nNSideChannelsLayer6 += 1;\r
323         nBadNSideChannels += 1;\r
324       }\r
325     }\r
326     if(layer == 5) {\r
327       if(nPSideChannelsLayer5 > 0)\r
328         fHistDAQDBPSideBadChannelMapLayer5->Fill(module,499+ladder,\r
329                                                  100.*nPSideChannelsLayer5/fgkDefaultNStripsSSD);\r
330       else fHistDAQDBPSideBadChannelMapLayer5->Fill(module,499+ladder,0.0001);\r
331       if(nNSideChannelsLayer5 > 0)\r
332         fHistDAQDBNSideBadChannelMapLayer5->Fill(module,499+ladder,\r
333                                                  100.*nNSideChannelsLayer5/fgkDefaultNStripsSSD);\r
334       else fHistDAQDBNSideBadChannelMapLayer5->Fill(module,499+ladder,0.0001);\r
335     }//layer 5\r
336     if(layer == 6) {\r
337       if(nPSideChannelsLayer6 > 0) \r
338         fHistDAQDBPSideBadChannelMapLayer6->Fill(module,599+ladder,\r
339                                                  100.*nPSideChannelsLayer6/fgkDefaultNStripsSSD);\r
340       else fHistDAQDBPSideBadChannelMapLayer6->Fill(module,599+ladder,0.0001);\r
341       if(nNSideChannelsLayer6 > 0) \r
342         fHistDAQDBNSideBadChannelMapLayer6->Fill(module,599+ladder,\r
343                                                  100.*nNSideChannelsLayer6/fgkDefaultNStripsSSD);\r
344       else fHistDAQDBNSideBadChannelMapLayer6->Fill(module,599+ladder,0.0001);\r
345     }//layer 6\r
346       \r
347     nBadPSideChannelsTotal += nBadPSideChannels;\r
348     nBadNSideChannelsTotal += nBadNSideChannels;\r
349     nPSideChannelsTotal += fgkDefaultNStripsSSD;\r
350     nNSideChannelsTotal += fgkDefaultNStripsSSD;\r
351   }\r
352 \r
353   cout<<"================================="<<endl;\r
354   cout<<"Bad p-Side channels: "<<100.*nBadPSideChannelsTotal/nPSideChannelsTotal<<endl;\r
355   cout<<"Bad n-Side channels: "<<100.*nBadNSideChannelsTotal/nNSideChannelsTotal<<endl;\r
356   cout<<"================================="<<endl;\r
357 \r
358   TCanvas *cBadChannelDAQDB = new TCanvas("cBadChannelDAQDB",\r
359                                           "Bad channel list - DAQ DB",\r
360                                           0,0,900,900);\r
361   cBadChannelDAQDB->SetHighLightColor(10); cBadChannelDAQDB->SetFillColor(10); \r
362   cBadChannelDAQDB->Divide(2,2);\r
363 \r
364   cBadChannelDAQDB->cd(1)->SetBottomMargin(.2); \r
365   cBadChannelDAQDB->cd(1)->SetLeftMargin(.15);\r
366   cBadChannelDAQDB->cd(1)->SetRightMargin(.2);\r
367   cBadChannelDAQDB->cd(1)->SetGridx(); cBadChannelDAQDB->cd(1)->SetGridy();\r
368   cBadChannelDAQDB->cd(1); fHistDAQDBPSideBadChannelMapLayer5->Draw("colz"); \r
369   cBadChannelDAQDB->cd(2)->SetBottomMargin(.2); \r
370   cBadChannelDAQDB->cd(2)->SetLeftMargin(.15);\r
371   cBadChannelDAQDB->cd(2)->SetRightMargin(.2);\r
372   cBadChannelDAQDB->cd(2)->SetGridx(); cBadChannelDAQDB->cd(2)->SetGridy();\r
373   cBadChannelDAQDB->cd(2); fHistDAQDBPSideBadChannelMapLayer6->Draw("colz");\r
374   cBadChannelDAQDB->cd(3)->SetBottomMargin(.2); \r
375   cBadChannelDAQDB->cd(3)->SetLeftMargin(.15);\r
376   cBadChannelDAQDB->cd(3)->SetRightMargin(.2);\r
377   cBadChannelDAQDB->cd(3)->SetGridx(); cBadChannelDAQDB->cd(3)->SetGridy();\r
378   cBadChannelDAQDB->cd(3); fHistDAQDBNSideBadChannelMapLayer5->Draw("colz"); \r
379   cBadChannelDAQDB->cd(4)->SetBottomMargin(.2); \r
380   cBadChannelDAQDB->cd(4)->SetLeftMargin(.15);\r
381   cBadChannelDAQDB->cd(4)->SetRightMargin(.2);\r
382   cBadChannelDAQDB->cd(4)->SetGridx(); cBadChannelDAQDB->cd(4)->SetGridy();\r
383   cBadChannelDAQDB->cd(4); fHistDAQDBNSideBadChannelMapLayer6->Draw("colz");\r
384 \r
385   return;\r
386 }\r