ITS/readSSDCommonMode.C

   1 #if !defined(__CINT__) || defined(__MAKECINT__)
   2 #include "TString.h"
   3 #include "TH1.h"
   4 #include "TH2.h"
   5 #include "TFile.h"
   6 #include "TList.h"
   7 #include "TChain.h"
   8 #include "TObject.h"
   9 #include "TCanvas.h"
  10 #include "TStyle.h"
  11 #include "TSystem.h"
  12 #include "Riostream.h"
  13
  14 #include "AliITSgeomTGeo.h"
  15 #include "AliLog.h"
  16 #include "AliRawReaderRoot.h"
  17 #include "AliITSRawStreamSSD.h"
  18 #include "AliCDBManager.h"
  19 #include "AliCDBEntry.h"
  20 #endif
  21
  22 /*  $Id:  $    */
  23
  24 //============================================================//
  25 static const Int_t fgkNumOfChips = 6;      //number of SSD chips per module per side
  26 static const Int_t fgkNumOfLDCs = 8;      //number of SSD LDCs
  27 static const Int_t fgkNumOfDDLs = 16;      //number of SSD DDLs
  28 static const Int_t fgkSSDMODULES = 1698;      //total number of SSD modules
  29 static const Int_t fgkSSDLADDERSLAYER5 = 34; //ladders on layer 5
  30 static const Int_t fgkSSDLADDERSLAYER6 = 38; //ladders on layer 6
  31 static const Int_t fgkSSDMODULESPERLADDERLAYER5 = 22; //modules per ladder - layer 5
  32 static const Int_t fgkSSDMODULESPERLADDERLAYER6 = 25; //modules per ladder - layer 6
  33 static const Int_t fgkSSDMODULESLAYER5 = 748; //total number of SSD modules - layer5
  34 static const Int_t fgkSSDMODULESLAYER6 = 950; //total number of SSD modules - layer6
  35 static const Int_t fgkNumberOfPSideStrips = 768; //number of P-side strips
  36 //============================================================//
  37
  38 TList *initCM();
  39 void makeCM(const char* filename, Int_t nEvents, TList *list);
  40 void checkCM(const char* filename);
  41 void compareChipLists(TString inputFile1,
  42                       TString inputFile2,
  43                       TString outputTxt);
  44
  45 //__________________________________________________________//
  46 void readSSDCommonMode(const char* filename = "raw.root",
  47                        Int_t nEvents = -1) {
  48   //Reads the CM pseudo-channels and produces the CM map for both layers
  49   //and for p and n-side.
  50   gStyle->SetPalette(1,0);
  51
  52   TList *list = initCM();
  53   //list->ls();
  54   Printf("CM histograms: %d",list->GetEntries());
  55   makeCM(filename,nEvents,list);
  56 }
  57
  58 //__________________________________________________________//
  59 TList *initCM() {
  60   //Initializes the histograms and returns the TList object
  61   TList *list = new TList();
  62
  63   Int_t gLayer = 0,gLadder = 0, gModule = 0;
  64   Int_t gHistCounter = 0;
  65   TString gTitle;
  66   TH1F *gHistSSDCMModule[2*fgkSSDMODULES][fgkNumOfChips];
  67   for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
  68     AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule);
  69     for(Int_t iChip = 0; iChip < fgkNumOfChips; iChip++) {
  70       gTitle = "SSD_CM_PSide_Layer"; gTitle += gLayer;
  71       gTitle += "_Ladder"; gTitle += gLadder;
  72       gTitle += "_Module"; gTitle += gModule;
  73       gTitle += "_Chip"; gTitle += iChip+1;
  74       gHistSSDCMModule[gHistCounter][iChip] = new TH1F(gTitle.Data(),
  75                                                        gTitle.Data(),
  76                                                        100,-50.,50.);
  77       gHistSSDCMModule[gHistCounter][iChip]->GetXaxis()->SetTitle("CM");
  78       list->Add(gHistSSDCMModule[gHistCounter][iChip]);
  79     }
  80     gHistCounter += 1;
  81   }
  82   for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
  83     AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule);
  84     for(Int_t iChip = 0; iChip < fgkNumOfChips; iChip++) {
  85       gTitle = "SSD_CM_NSide_Layer"; gTitle += gLayer;
  86       gTitle += "_Ladder"; gTitle += gLadder;
  87       gTitle += "_Module"; gTitle += gModule;
  88       gTitle += "_Chip"; gTitle += iChip+1;
  89       gHistSSDCMModule[gHistCounter][iChip] = new TH1F(gTitle.Data(),
  90                                                        gTitle.Data(),
  91                                                        100,-50.,50.);
  92     gHistSSDCMModule[gHistCounter][iChip]->GetXaxis()->SetTitle("CM");
  93     list->Add(gHistSSDCMModule[gHistCounter][iChip]);
  94     }
  95     gHistCounter += 1;
  96   }
  97
  98   return list;
  99 }
 100
 101 //__________________________________________________________//
 102 void makeCM(const char* filename, Int_t nEvents, TList *list) {
 103   //Function to read the CM values
 104   Int_t gStripNumber = 0;
 105   Int_t gLayer = 0,gLadder = 0, gModule = 0;
 106
 107   //==================================================//
 108   AliCDBManager *fCDBManager = AliCDBManager::Instance();
 109   fCDBManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 110   Int_t runNumber = atoi(gSystem->Getenv("DATE_RUN_NUMBER"));
 111   if(!runNumber)
 112     Printf("DATE_RUN_NUMBER not defined!!!\n");
 113
 114   fCDBManager->SetRun(runNumber);
 115   AliCDBEntry *geomGRP = fCDBManager->Get("GRP/Geometry/Data");
 116   if(!geomGRP) cout<<"GRP geometry not found!!!"<<endl;;
 117   //==================================================//
 118
 119   //==================================================//
 120   TH2F *fHistPSideMeanCMMapLayer5 = new TH2F("fHistPSideMeanCMMapLayer5",
 121                                          "Layer 5 - P side;N_{module};N_{ladder}",
 122                                          22,1,23,
 123                                          34,500,534);
 124   fHistPSideMeanCMMapLayer5->GetXaxis()->SetTitleColor(1);
 125   fHistPSideMeanCMMapLayer5->GetZaxis()->SetRangeUser(0.,20.);
 126   fHistPSideMeanCMMapLayer5->SetStats(kFALSE);
 127   fHistPSideMeanCMMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 128   fHistPSideMeanCMMapLayer5->GetXaxis()->SetNdivisions(22);
 129   fHistPSideMeanCMMapLayer5->GetYaxis()->SetNdivisions(34);
 130   fHistPSideMeanCMMapLayer5->GetXaxis()->SetLabelSize(0.03);
 131   fHistPSideMeanCMMapLayer5->GetYaxis()->SetLabelSize(0.03);
 132   fHistPSideMeanCMMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 133   fHistPSideMeanCMMapLayer5->GetZaxis()->SetTitle("RMS(CM) (p-side)");
 134
 135   TH2F *fHistNSideMeanCMMapLayer5 = new TH2F("fHistNSideMeanCMMapLayer5",
 136                                          "Layer 5 - N side;N_{module};N_{ladder}",
 137                                          22,1,23,
 138                                          34,500,534);
 139   fHistNSideMeanCMMapLayer5->GetXaxis()->SetTitleColor(1);
 140   fHistNSideMeanCMMapLayer5->GetZaxis()->SetRangeUser(0.,20.);
 141   fHistNSideMeanCMMapLayer5->SetStats(kFALSE);
 142   fHistNSideMeanCMMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 143   fHistNSideMeanCMMapLayer5->GetXaxis()->SetNdivisions(22);
 144   fHistNSideMeanCMMapLayer5->GetYaxis()->SetNdivisions(34);
 145   fHistNSideMeanCMMapLayer5->GetXaxis()->SetLabelSize(0.03);
 146   fHistNSideMeanCMMapLayer5->GetYaxis()->SetLabelSize(0.03);
 147   fHistNSideMeanCMMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 148   fHistNSideMeanCMMapLayer5->GetZaxis()->SetTitle("RMS(CM) (n-side)");
 149
 150   TH2F *fHistPSideMeanCMMapLayer6 = new TH2F("fHistPSideMeanCMMapLayer6",
 151                                          "Layer 6 - P side;N_{module};N_{ladder}",
 152                                          25,1,26,
 153                                          38,600,638);
 154   fHistPSideMeanCMMapLayer6->GetXaxis()->SetTitleColor(1);
 155   fHistPSideMeanCMMapLayer6->GetZaxis()->SetRangeUser(0.,20.);
 156   fHistPSideMeanCMMapLayer6->SetStats(kFALSE);
 157   fHistPSideMeanCMMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 158   fHistPSideMeanCMMapLayer6->GetXaxis()->SetNdivisions(25);
 159   fHistPSideMeanCMMapLayer6->GetYaxis()->SetNdivisions(38);
 160   fHistPSideMeanCMMapLayer6->GetXaxis()->SetLabelSize(0.03);
 161   fHistPSideMeanCMMapLayer6->GetYaxis()->SetLabelSize(0.03);
 162   fHistPSideMeanCMMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 163   fHistPSideMeanCMMapLayer6->GetZaxis()->SetTitle("RMS(CM) (p-side)");
 164
 165   TH2F *fHistNSideMeanCMMapLayer6 = new TH2F("fHistNSideMeanCMMapLayer6",
 166                                          "Layer 6 - N side;N_{module};N_{ladder}",
 167                                          25,1,26,
 168                                          38,600,638);
 169   fHistNSideMeanCMMapLayer6->GetXaxis()->SetTitleColor(1);
 170   fHistNSideMeanCMMapLayer6->GetZaxis()->SetRangeUser(0.,20.);
 171   fHistNSideMeanCMMapLayer6->SetStats(kFALSE);
 172   fHistNSideMeanCMMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 173   fHistNSideMeanCMMapLayer6->GetXaxis()->SetNdivisions(25);
 174   fHistNSideMeanCMMapLayer6->GetYaxis()->SetNdivisions(38);
 175   fHistNSideMeanCMMapLayer6->GetXaxis()->SetLabelSize(0.03);
 176   fHistNSideMeanCMMapLayer6->GetYaxis()->SetLabelSize(0.03);
 177   fHistNSideMeanCMMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 178   fHistNSideMeanCMMapLayer6->GetZaxis()->SetTitle("RMS(CM) (n-side)");
 179
 180   //____________________________________________________________//
 181   TH2F *fHistPSideRMSCMMapLayer5 = new TH2F("fHistPSideRMSCMMapLayer5",
 182                                          "Layer 5 - P side;N_{module};N_{ladder}",
 183                                          22,1,23,
 184                                          34,500,534);
 185   fHistPSideRMSCMMapLayer5->GetXaxis()->SetTitleColor(1);
 186   fHistPSideRMSCMMapLayer5->GetZaxis()->SetRangeUser(0.,20.);
 187   fHistPSideRMSCMMapLayer5->SetStats(kFALSE);
 188   fHistPSideRMSCMMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 189   fHistPSideRMSCMMapLayer5->GetXaxis()->SetNdivisions(22);
 190   fHistPSideRMSCMMapLayer5->GetYaxis()->SetNdivisions(34);
 191   fHistPSideRMSCMMapLayer5->GetXaxis()->SetLabelSize(0.03);
 192   fHistPSideRMSCMMapLayer5->GetYaxis()->SetLabelSize(0.03);
 193   fHistPSideRMSCMMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 194   fHistPSideRMSCMMapLayer5->GetZaxis()->SetTitle("RMS(CM) (p-side)");
 195
 196   TH2F *fHistNSideRMSCMMapLayer5 = new TH2F("fHistNSideRMSCMMapLayer5",
 197                                          "Layer 5 - N side;N_{module};N_{ladder}",
 198                                          22,1,23,
 199                                          34,500,534);
 200   fHistNSideRMSCMMapLayer5->GetXaxis()->SetTitleColor(1);
 201   fHistNSideRMSCMMapLayer5->GetZaxis()->SetRangeUser(0.,20.);
 202   fHistNSideRMSCMMapLayer5->SetStats(kFALSE);
 203   fHistNSideRMSCMMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 204   fHistNSideRMSCMMapLayer5->GetXaxis()->SetNdivisions(22);
 205   fHistNSideRMSCMMapLayer5->GetYaxis()->SetNdivisions(34);
 206   fHistNSideRMSCMMapLayer5->GetXaxis()->SetLabelSize(0.03);
 207   fHistNSideRMSCMMapLayer5->GetYaxis()->SetLabelSize(0.03);
 208   fHistNSideRMSCMMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 209   fHistNSideRMSCMMapLayer5->GetZaxis()->SetTitle("RMS(CM) (n-side)");
 210
 211   TH2F *fHistPSideRMSCMMapLayer6 = new TH2F("fHistPSideRMSCMMapLayer6",
 212                                          "Layer 6 - P side;N_{module};N_{ladder}",
 213                                          25,1,26,
 214                                          38,600,638);
 215   fHistPSideRMSCMMapLayer6->GetXaxis()->SetTitleColor(1);
 216   fHistPSideRMSCMMapLayer6->GetZaxis()->SetRangeUser(0.,20.);
 217   fHistPSideRMSCMMapLayer6->SetStats(kFALSE);
 218   fHistPSideRMSCMMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 219   fHistPSideRMSCMMapLayer6->GetXaxis()->SetNdivisions(25);
 220   fHistPSideRMSCMMapLayer6->GetYaxis()->SetNdivisions(38);
 221   fHistPSideRMSCMMapLayer6->GetXaxis()->SetLabelSize(0.03);
 222   fHistPSideRMSCMMapLayer6->GetYaxis()->SetLabelSize(0.03);
 223   fHistPSideRMSCMMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 224   fHistPSideRMSCMMapLayer6->GetZaxis()->SetTitle("RMS(CM) (p-side)");
 225
 226   TH2F *fHistNSideRMSCMMapLayer6 = new TH2F("fHistNSideRMSCMMapLayer6",
 227                                          "Layer 6 - N side;N_{module};N_{ladder}",
 228                                          25,1,26,
 229                                          38,600,638);
 230   fHistNSideRMSCMMapLayer6->GetXaxis()->SetTitleColor(1);
 231   fHistNSideRMSCMMapLayer6->GetZaxis()->SetRangeUser(0.,20.);
 232   fHistNSideRMSCMMapLayer6->SetStats(kFALSE);
 233   fHistNSideRMSCMMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 234   fHistNSideRMSCMMapLayer6->GetXaxis()->SetNdivisions(25);
 235   fHistNSideRMSCMMapLayer6->GetYaxis()->SetNdivisions(38);
 236   fHistNSideRMSCMMapLayer6->GetXaxis()->SetLabelSize(0.03);
 237   fHistNSideRMSCMMapLayer6->GetYaxis()->SetLabelSize(0.03);
 238   fHistNSideRMSCMMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 239   fHistNSideRMSCMMapLayer6->GetZaxis()->SetTitle("RMS(CM) (n-side)");
 240   //==================================================//
 241
 242   TChain *chain = new TChain("RAW");
 243   chain->Add(filename);
 244   Int_t nTotalEvents = chain->GetEntries();
 245   if(nEvents == -1) nEvents = nTotalEvents;
 246
 247   AliRawReaderRoot *rawReader = new AliRawReaderRoot(filename);
 248   Int_t iEvent = 0;
 249   Int_t fSSDEvent = 0;
 250   for(iEvent = 0; iEvent < nEvents; iEvent++) {
 251     cout<<"Event: "<<iEvent+1<<"/"<<nEvents<<endl;
 252     rawReader->Select("ITSSSD",-1,-1);
 253     rawReader->Reset();
 254     rawReader->NextEvent();
 255
 256     if(rawReader->GetType() != 7) continue;
 257
 258     fSSDEvent += 1;
 259     AliITSRawStreamSSD gSSDStream(rawReader);
 260     while (gSSDStream.Next()) {
 261       if(gSSDStream.GetModuleID() < 0) continue;
 262       AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
 263       //if(gSSDStream.GetModuleID() != 500) continue;
 264       //Printf("Module id: %d - Layer: %d - Ladder: %d - Module: %d",gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
 265
 266       if(gSSDStream.GetStrip() >= 0) continue;
 267       gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;
 268       //Printf("Module id: %d - Strip: %d - strip number: %d - Signal: %lf",gSSDStream.GetModuleID(),gSSDStream.GetStrip(),gStripNumber,signal);
 269       if(TMath::Abs(gSSDStream.GetStrip()) < 7)
 270         ((TH1*)list->At((gSSDStream.GetModuleID()-500)*fgkNumOfChips+gSSDStream.GetStrip()))->Fill(gSSDStream.GetSignal());
 271       if(TMath::Abs(gSSDStream.GetStrip()) > 6)
 272         ((TH1*)list->At(fgkSSDMODULES*fgkNumOfChips+(gSSDStream.GetModuleID()-500)*fgkNumOfChips+gSSDStream.GetStrip()))->Fill(gSSDStream.GetSignal());
 273     }//streamer loop
 274   }//event loop
 275
 276   //compute the rms of the CM values
 277   TH1F *gHistCMDummy = new TH1F("gHistCMDummy","",100,-50.,50.);
 278   Double_t meanPsideCM = 0.0, meanNsideCM = 0.0;
 279   Double_t rmsPsideCM = 0.0, rmsNsideCM = 0.0;
 280   for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
 281       meanPsideCM = 0.0; meanNsideCM = 0.0;
 282     rmsPsideCM = 0.0; rmsNsideCM = 0.0;
 283     AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
 284
 285     gHistCMDummy->Clear();
 286     for(Int_t iChip = 0; iChip < fgkNumOfChips; iChip++) {
 287       //cout<<"Name: "<<dynamic_cast<TH1*>(list->At(iModule*fgkNumOfChips+iChip))->GetName()<<endl;
 288       gHistCMDummy->Add((TH1*)list->At(iModule*fgkNumOfChips+iChip));
 289     }
 290     meanPsideCM = TMath::Abs(gHistCMDummy->GetMean());
 291     rmsPsideCM = gHistCMDummy->GetRMS();
 292
 293     gHistCMDummy->Clear();
 294     for(Int_t iChip = 0; iChip < fgkNumOfChips; iChip++) {
 295       //cout<<"Name: "<<dynamic_cast<TH1*>(list->At(fgkSSDMODULES*fgkNumOfChips+iModule*fgkNumOfChips+iChip))->GetName()<<endl;
 296       gHistCMDummy->Add((TH1*)list->At(fgkSSDMODULES*fgkNumOfChips+iModule*fgkNumOfChips+iChip));
 297     }
 298     meanNsideCM = TMath::Abs(gHistCMDummy->GetMean());
 299     rmsNsideCM = gHistCMDummy->GetRMS();
 300
 301     if(meanPsideCM == 0) meanPsideCM = 0.001;
 302     if(meanNsideCM == 0) meanNsideCM = 0.001;
 303     if(rmsPsideCM == 0) rmsPsideCM = 0.001;
 304     if(rmsNsideCM == 0) rmsNsideCM = 0.001;
 305
 306     if(gLayer == 5) {
 307       fHistPSideMeanCMMapLayer5->SetBinContent(gModule,gLadder,meanPsideCM);
 308       fHistNSideMeanCMMapLayer5->SetBinContent(gModule,gLadder,meanNsideCM);
 309       fHistPSideRMSCMMapLayer5->SetBinContent(gModule,gLadder,rmsPsideCM);
 310       fHistNSideRMSCMMapLayer5->SetBinContent(gModule,gLadder,rmsNsideCM);
 311     }
 312      if(gLayer == 6) {
 313       fHistPSideMeanCMMapLayer6->SetBinContent(gModule,gLadder,meanPsideCM);
 314       fHistNSideMeanCMMapLayer6->SetBinContent(gModule,gLadder,meanNsideCM);
 315       fHistPSideRMSCMMapLayer6->SetBinContent(gModule,gLadder,rmsPsideCM);
 316       fHistNSideRMSCMMapLayer6->SetBinContent(gModule,gLadder,rmsNsideCM);
 317     }
 318     }
 319
 320   TFile *foutput = TFile::Open("SSD.CM.root","recreate");
 321   list->Write();
 322   fHistPSideMeanCMMapLayer5->Write(); fHistNSideMeanCMMapLayer5->Write();
 323   fHistPSideMeanCMMapLayer6->Write(); fHistNSideMeanCMMapLayer6->Write();
 324   fHistPSideRMSCMMapLayer5->Write(); fHistNSideRMSCMMapLayer5->Write();
 325   fHistPSideRMSCMMapLayer6->Write(); fHistNSideRMSCMMapLayer6->Write();
 326   foutput->Close();
 327 }
 328
 329 //__________________________________________________________//
 330 void drawSSDCM(const char* filename = "SSD.CM.root") {
 331   gStyle->SetPalette(1,0);
 332
 333   TFile *f = TFile::Open(filename);
 334
 335   TCanvas *c1 = new TCanvas("c1","Mean of CM values",0,0,700,650);
 336   c1->SetFillColor(10); c1->SetHighLightColor(10); c1->Divide(2,2);
 337   c1->cd(1);
 338   TH2F *fHistPSideMeanCMMapLayer5 = dynamic_cast<TH2F *>(f->Get("fHistPSideMeanCMMapLayer5"));
 339   fHistPSideMeanCMMapLayer5->Draw("colz");
 340   c1->cd(2);
 341   TH2F *fHistNSideMeanCMMapLayer5 = dynamic_cast<TH2F *>(f->Get("fHistNSideMeanCMMapLayer5"));
 342   fHistNSideMeanCMMapLayer5->Draw("colz");
 343   c1->cd(3);
 344   TH2F *fHistPSideMeanCMMapLayer6 = dynamic_cast<TH2F *>(f->Get("fHistPSideMeanCMMapLayer6"));
 345   fHistPSideMeanCMMapLayer6->Draw("colz");
 346   c1->cd(4);
 347   TH2F *fHistNSideMeanCMMapLayer6 = dynamic_cast<TH2F *>(f->Get("fHistNSideMeanCMMapLayer6"));
 348   fHistNSideMeanCMMapLayer6->Draw("colz");
 349
 350   TCanvas *c2 = new TCanvas("c2","RMS of CM values",100,100,700,650);
 351   c2->SetFillColor(10); c2->SetHighLightColor(10); c2->Divide(2,2);
 352   c2->cd(1);
 353   TH2F *fHistPSideRMSCMMapLayer5 = dynamic_cast<TH2F *>(f->Get("fHistPSideRMSCMMapLayer5"));
 354   fHistPSideRMSCMMapLayer5->Draw("colz");
 355   c2->cd(2);
 356   TH2F *fHistNSideRMSCMMapLayer5 = dynamic_cast<TH2F *>(f->Get("fHistNSideRMSCMMapLayer5"));
 357   fHistNSideRMSCMMapLayer5->Draw("colz");
 358   c2->cd(3);
 359   TH2F *fHistPSideRMSCMMapLayer6 = dynamic_cast<TH2F *>(f->Get("fHistPSideRMSCMMapLayer6"));
 360   fHistPSideRMSCMMapLayer6->Draw("colz");
 361   c2->cd(4);
 362   TH2F *fHistNSideRMSCMMapLayer6 = dynamic_cast<TH2F *>(f->Get("fHistNSideRMSCMMapLayer6"));
 363   fHistNSideRMSCMMapLayer6->Draw("colz");
 364 }
 365
 366 //__________________________________________________________//
 367 void checkCM(const char* filename) {
 368   //Reads the SSD.CM.root file as an input.
 369   //For every chip checks the mean and the rms of the CM distributions.
 370   //If the absolute value of the mean is beyond 5 ADC counts or/and the
 371   //rms is beyond 10, the corresponding histogram is added to the list
 372   //of suspicious chips. This list is written to the output file having
 373   //the name: SSD.FaultyChips.root
 374
 375   //Hardcoded check values
 376   const Double_t meanMax = 5.;
 377   const Double_t rmsMax = 10.;
 378
 379   //output list
 380   TList *listOfSuspiciousChips = new TList();
 381
 382   //Input file
 383   TFile *fInput = TFile::Open(filename);
 384
 385   Int_t gLayer = 0,gLadder = 0, gModule = 0;
 386   TString gTitle;
 387   //Double_t meanValue = 0.0, rmsValue = 0.0;
 388   TH1F *gHistSSDCMModule = 0x0;
 389   //P-side
 390   for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
 391     AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule);
 392     for(Int_t iChip = 0; iChip < fgkNumOfChips; iChip++) {
 393       gTitle = "SSD_CM_PSide_Layer"; gTitle += gLayer;
 394       gTitle += "_Ladder"; gTitle += gLadder;
 395       gTitle += "_Module"; gTitle += gModule;
 396       gTitle += "_Chip"; gTitle += iChip+1;
 397       gHistSSDCMModule = dynamic_cast<TH1F *>(fInput->Get(gTitle.Data()));
 398       if((TMath::Abs(gHistSSDCMModule->GetMean(1)) > meanMax)||
 399          (TMath::Abs(gHistSSDCMModule->GetRMS(1)) > rmsMax)) {
 400         Printf("Name: %s, Mean: %lf - rms: %lf",
 401                gHistSSDCMModule->GetName(),
 402                TMath::Abs(gHistSSDCMModule->GetMean(1)),
 403                TMath::Abs(gHistSSDCMModule->GetRMS(1)));
 404         listOfSuspiciousChips->Add(gHistSSDCMModule);
 405       }
 406     }//chip loop
 407   }//module loop
 408
 409   //N-side
 410   for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
 411     AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule);
 412     for(Int_t iChip = 0; iChip < fgkNumOfChips; iChip++) {
 413       gTitle = "SSD_CM_NSide_Layer"; gTitle += gLayer;
 414       gTitle += "_Ladder"; gTitle += gLadder;
 415       gTitle += "_Module"; gTitle += gModule;
 416       gTitle += "_Chip"; gTitle += iChip+1;
 417       gHistSSDCMModule = dynamic_cast<TH1F *>(fInput->Get(gTitle.Data()));
 418       if((TMath::Abs(gHistSSDCMModule->GetMean(1)) > meanMax)||
 419          (TMath::Abs(gHistSSDCMModule->GetRMS(1)) > rmsMax)) {
 420         Printf("Name: %s, Mean: %lf - rms: %lf",
 421                gHistSSDCMModule->GetName(),
 422                TMath::Abs(gHistSSDCMModule->GetMean(1)),
 423                TMath::Abs(gHistSSDCMModule->GetRMS(1)));
 424         listOfSuspiciousChips->Add(gHistSSDCMModule);
 425       }
 426       //Printf("Name: %s",gHistSSDCMModule->GetName());
 427     }//chip loop
 428   }//module loop
 429
 430   Printf("===============================================");
 431   Printf("%d suspicious chips were put in the list",
 432          listOfSuspiciousChips->GetEntries());
 433   Printf("===============================================");
 434   TFile *fOutput = new TFile("SSD.FaultyChips.root","recreate");
 435   listOfSuspiciousChips->Write();
 436   fOutput->Close();
 437
 438   fInput->Close();
 439 }
 440
 441 //__________________________________________________________//
 442 void compareChipLists(TString inputFile1,
 443                       TString inputFile2,
 444                       TString outputTxt){
 445   //Compare two different lists of chips and put those present in both files
 446   //in a new list
 447   //open input lists
 448   TFile *fInput1 = TFile::Open(inputFile1.Data());
 449   TList *listOfSuspiciousChips1 = new TList();
 450   listOfSuspiciousChips1=fInput1->GetListOfKeys();
 451   TFile *fInput2 = TFile::Open(inputFile2.Data());
 452   TList *listOfSuspiciousChips2 = new TList();
 453   listOfSuspiciousChips2=fInput2->GetListOfKeys();
 454
 455   Int_t Nentries1 = 0, Nentries2 = 0, k = 0;
 456   Nentries1 = listOfSuspiciousChips1->GetEntries();
 457   Nentries2 = listOfSuspiciousChips2->GetEntries();
 458
 459   //create new list
 460   TList *listOfRecurrentChips = new TList();
 461   TString Name1;
 462
 463   for(Int_t i=0; i<Nentries1; i++){
 464     TH1F *h1 = dynamic_cast <TH1F*>(fInput1->Get(listOfSuspiciousChips1->At(i)->GetName()));
 465     for(Int_t j=0; j<Nentries2; j++){
 466       TH1F *h2 = dynamic_cast <TH1F*>(fInput2->Get(listOfSuspiciousChips2->At(j)->GetName()));
 467       Name1=h1->GetName();
 468       if (!Name1.CompareTo(h2->GetName())) {
 469         cout << Name1.CompareTo(h2->GetName()) <<
 470           "   " << h2->GetName() << endl;
 471         k++;
 472         listOfRecurrentChips->Add(h1);
 473       }
 474     }//second file loop
 475   }//first file loop
 476
 477   Printf("%i Faulty chips in the first file", Nentries1);
 478   Printf("%i Faulty chips in the second file", Nentries2);
 479   Printf("%i Recurrent Faulty chips", k+1);
 480
 481   TString outputFile = "SSD.RecurrentFaultyChips."; outputFile += outputTxt;
 482   outputFile += ".root";
 483
 484   TFile *fOutput = new TFile(outputFile.Data(),"recreate");
 485   listOfRecurrentChips->Write();
 486   fOutput->Close();
 487
 488   fInput1->Close();
 489   fInput2->Close();
 490 }
 491
 492 //__________________________________________________________//
 493 void makeCM2D(const char* filename, Int_t nEvents) {
 494   //Function to read the CM values
 495   gStyle->SetPalette(1,0);
 496   Int_t gStripNumber = 0;
 497   Int_t gLayer = 0,gLadder = 0, gModule = 0;
 498
 499   //==================================================//
 500   AliCDBManager *fCDBManager = AliCDBManager::Instance();
 501   fCDBManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 502   Int_t runNumber = atoi(gSystem->Getenv("DATE_RUN_NUMBER"));
 503   if(!runNumber)
 504     Printf("DATE_RUN_NUMBER not defined!!!\n");
 505
 506   fCDBManager->SetRun(runNumber);
 507   AliCDBEntry *geomGRP = fCDBManager->Get("GRP/Geometry/Data");
 508   if(!geomGRP) cout<<"GRP geometry not found!!!"<<endl;;
 509   //==================================================//
 510
 511   //==================================================//
 512   TList *list = new TList();
 513   TH2F *gHistCM2D[fgkSSDMODULES];
 514   TString gHistoTitle, gArrayTitle;
 515   Int_t gHistCounter = 0;
 516   for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
 517     AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule);
 518     gHistoTitle = "SSD_CM_Layer"; gHistoTitle += gLayer;
 519     gHistoTitle += "_Ladder"; gHistoTitle += gLadder;
 520     gHistoTitle += "_Module"; gHistoTitle += gModule;
 521     //Printf("Title: %s",gHistoTitle.Data());
 522     gHistCM2D[gHistCounter] = new TH2F(gHistoTitle.Data(),
 523                                        gHistoTitle.Data(),
 524                                        12,0.5,12.5,
 525                                        120,-60.,60.);
 526     gHistCM2D[gHistCounter]->SetStats(kFALSE);
 527     gHistCM2D[gHistCounter]->GetXaxis()->SetTitleColor(1);
 528     gHistCM2D[gHistCounter]->GetZaxis()->SetTitle("Entries");
 529     gHistCM2D[gHistCounter]->GetYaxis()->SetTitle("CM");
 530     gHistCM2D[gHistCounter]->GetXaxis()->SetTitle("Chip number");
 531     gHistCM2D[gHistCounter]->GetXaxis()->SetNdivisions(12);
 532     list->Add(gHistCM2D[gHistCounter]);
 533     gHistCounter += 1;
 534   }
 535   //Printf("List entries: %d",list->GetEntries());
 536   //==================================================//
 537
 538   TChain *chain = new TChain("RAW");
 539   chain->Add(filename);
 540   Int_t nTotalEvents = chain->GetEntries();
 541   if(nEvents == -1) nEvents = nTotalEvents;
 542
 543   AliRawReaderRoot *rawReader = new AliRawReaderRoot(filename);
 544   Int_t iEvent = 0;
 545   Int_t fSSDEvent = 0;
 546   for(iEvent = 0; iEvent < nEvents; iEvent++) {
 547     cout<<"Event: "<<iEvent+1<<"/"<<nEvents<<endl;
 548     rawReader->Select("ITSSSD",-1,-1);
 549     rawReader->Reset();
 550     rawReader->NextEvent();
 551
 552     if(rawReader->GetType() != 7) continue;
 553
 554     fSSDEvent += 1;
 555     AliITSRawStreamSSD gSSDStream(rawReader);
 556     while (gSSDStream.Next()) {
 557       if(gSSDStream.GetModuleID() < 0) continue;
 558       AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
 559       //if(gSSDStream.GetModuleID() != 500) continue;
 560       //Printf("Module id: %d - Layer: %d - Ladder: %d - Module: %d",gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
 561
 562       if(gSSDStream.GetStrip() >= 0) continue;
 563       gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;
 564       //Printf("Module id: %d - Strip: %d - strip number: %d - Signal: %lf",gSSDStream.GetModuleID(),gSSDStream.GetStrip(),gStripNumber,gSSDStream.GetSignal());
 565       gHistCM2D[gSSDStream.GetModuleID()-500]->Fill(TMath::Abs(gSSDStream.GetStrip()),gSSDStream.GetSignal());
 566     }//streamer loop
 567   }//event loop
 568
 569   TCanvas *cLayer5[34];
 570   TCanvas *cLayer6[38];
 571   TString canvasTitle;
 572   for(Int_t iLadder = 1; iLadder < 35; iLadder++) {
 573     canvasTitle = "SSD_CM_Layer5_Ladder"; canvasTitle += iLadder;
 574     cLayer5[iLadder-1] = new TCanvas(canvasTitle.Data(),
 575                                      canvasTitle.Data());
 576     cLayer5[iLadder-1]->Divide(5,5);
 577     for(Int_t iModule = 1; iModule < 23; iModule++) {
 578       cLayer5[iLadder-1]->cd(iModule);
 579       gHistCM2D[(iLadder-1)*fgkSSDMODULESPERLADDERLAYER5 + iModule - 1]->Draw("colz");
 580     }
 581     if(iLadder == 1) cLayer5[iLadder-1]->Print("CommonModePlotsLayer5.ps(");
 582     if(iLadder == 34) cLayer5[iLadder-1]->Print("CommonModePlotsLayer5.ps)");
 583     else cLayer5[iLadder-1]->Print("CommonModePlotsLayer5.ps");
 584     //Printf("Ladder %d finished...",499+iLadder);
 585   }
 586
 587   for(Int_t iLadder = 1; iLadder < 39; iLadder++) {
 588     canvasTitle = "SSD_CM_Layer6_Ladder"; canvasTitle += iLadder;
 589     cLayer6[iLadder-1] = new TCanvas(canvasTitle.Data(),
 590                                      canvasTitle.Data());
 591     cLayer6[iLadder-1]->Divide(5,5);
 592     for(Int_t iModule = 1; iModule < 26; iModule++) {
 593       cLayer6[iLadder-1]->cd(iModule);
 594       gHistCM2D[fgkSSDMODULESLAYER5 + (iLadder-1)*fgkSSDMODULESPERLADDERLAYER6 + iModule - 1]->Draw("colz");
 595     }
 596     if(iLadder == 1) cLayer6[iLadder-1]->Print("CommonModePlotsLayer6.ps(");
 597     if(iLadder == 38) cLayer6[iLadder-1]->Print("CommonModePlotsLayer6.ps)");
 598     else cLayer6[iLadder-1]->Print("CommonModePlotsLayer6.ps");
 599     //Printf("Ladder %d finished...",599+iLadder);
 600   }
 601
 602
 603   TFile *foutput = TFile::Open("SSD.CM2D.root","recreate");
 604   list->Write();
 605   foutput->Close();
 606 }
 607