ITS/patchSSDBadChannelsMap.C

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