ITS/correlateOCDBforSSD.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 "TObjArray.h"
   7 #include "TObject.h"
   8 #include "TCanvas.h"
   9 #include "TStyle.h"
  10 #include "Riostream.h"
  11
  12 #include "AliITSgeomTGeo.h"
  13 #include "AliITSGainSSDv2.h"
  14 #include "AliITSBadChannelsSSDv2.h"
  15 #include "AliITSNoiseSSDv2.h"
  16 #include "AliITSPedestalSSDv2.h"
  17 #include "AliITSGainSSD.h"
  18 #include "AliITSBadChannelsSSD.h"
  19 #include "AliITSNoiseSSD.h"
  20 #include "AliITSPedestalSSD.h"
  21 #include "AliCDBManager.h"
  22 #include "AliCDBEntry.h"
  23 #endif
  24
  25
  26 //====================================================================//
  27 void Noise(AliCDBManager * man);
  28 void Pedestal(AliCDBManager * man);
  29 void GainCalibration(AliCDBManager * man);
  30 void ReadOldSSDPedestal(TObjArray *array, AliITSPedestalSSDv2 *pedestalSSD);
  31 void ReadOldSSDNoise(TObjArray *array, AliITSNoiseSSDv2 *noiseSSD);
  32 void ReadOldSSDBadChannels(TObjArray *array, AliITSBadChannelsSSDv2 *badChannelsSSD);
  33 void ReadOldSSDGain(TObjArray *array, AliITSGainSSDv2 *gainSSD);
  34 void drawNoiseDistributions(Int_t runNumber);
  35 void drawPedestalDistributions(Int_t runNumber);
  36 //====================================================================//
  37
  38 //_____________________________________________________________________//
  39 void correlateOCDBforSSD(const char* type = "alien", Int_t runNumber = 0) {
  40   //This macro allows to read the pedestal values from the reference
  41   //directory and correlate them with the bad channel list.
  42   //It also allows to correlate the noise values in the OCDB with
  43   //the bad channel list.
  44   TString gType = type;
  45
  46   AliCDBManager *man1 = AliCDBManager::Instance();
  47
  48   if(gType == "alien") {
  49     man1->SetDefaultStorage("alien://folder=/alice/data/2009/OCDB/");
  50     man1->SetSpecificStorage("ITS/Ref/PedestalSSD",
  51                              "alien://folder=/alice/data/2009/Reference/");
  52   }
  53   else if(gType == "local") {
  54     man1->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  55     man1->SetSpecificStorage("ITS/Ref/PedestalSSD",
  56                              "local://$ALICE_ROOT/");
  57   }
  58   else {
  59     cout<<"Allowed types: local or alien!!!"<<endl;
  60     abort();
  61   }
  62
  63   man1->SetRun(runNumber);
  64
  65   Pedestal(man1);
  66   Noise(man1);
  67 }
  68
  69 //_____________________________________________________________________//
  70 void drawNoiseDistributions(Int_t runNumber) {
  71   //Draws the noise distributions for each side and layer
  72   TString filename = "noiseDistributionsSSD."; filename += runNumber;
  73   filename += ".root";
  74   TFile *f = TFile::Open(filename.Data());
  75   TH1F *gHistNoisePSideLayer5 = dynamic_cast<TH1F *>(f->Get("gHistNoisePSideLayer5"));
  76   TH1F *gHistNoiseNSideLayer5 = dynamic_cast<TH1F *>(f->Get("gHistNoiseNSideLayer5"));
  77   TH1F *gHistNoisePSideLayer6 = dynamic_cast<TH1F *>(f->Get("gHistNoisePSideLayer6"));
  78   TH1F *gHistNoiseNSideLayer6 = dynamic_cast<TH1F *>(f->Get("gHistNoiseNSideLayer6"));
  79
  80   TCanvas *c1 = new TCanvas("c1","Noise distribution (P-side, Layer 5)",
  81                             0,0,400,400);
  82   c1->SetFillColor(10); c1->SetHighLightColor(10); c1->SetLogy();
  83   gHistNoisePSideLayer5->SetStats(kFALSE);
  84   gHistNoisePSideLayer5->GetXaxis()->SetRangeUser(0.0,20.);
  85   gHistNoisePSideLayer5->Draw();
  86   c1->SaveAs("Noise-PSide-Layer5.eps");
  87
  88   TCanvas *c2 = new TCanvas("c2","Noise distribution (N-side, Layer 5)",
  89                             400,0,400,400);
  90   c2->SetFillColor(10); c2->SetHighLightColor(10); c2->SetLogy();
  91   gHistNoiseNSideLayer5->SetStats(kFALSE);
  92   gHistNoiseNSideLayer5->GetXaxis()->SetRangeUser(0.0,20.);
  93   gHistNoiseNSideLayer5->Draw();
  94   c2->SaveAs("Noise-NSide-Layer5.eps");
  95
  96   TCanvas *c3 = new TCanvas("c3","Noise distribution (P-side, Layer 6)",
  97                             0,400,400,400);
  98   c3->SetFillColor(10); c3->SetHighLightColor(10); c3->SetLogy();
  99   gHistNoisePSideLayer6->SetStats(kFALSE);
 100   gHistNoisePSideLayer6->GetXaxis()->SetRangeUser(0.0,20.);
 101   gHistNoisePSideLayer6->Draw();
 102   c3->SaveAs("Noise-PSide-Layer6.eps");
 103
 104   TCanvas *c4 = new TCanvas("c4","Noise distribution (N-side, Layer 6)",
 105                             400,400,400,400);
 106   c4->SetFillColor(10); c4->SetHighLightColor(10); c4->SetLogy();
 107   gHistNoiseNSideLayer6->SetStats(kFALSE);
 108   gHistNoiseNSideLayer6->GetXaxis()->SetRangeUser(0.0,20.);
 109   gHistNoiseNSideLayer6->Draw();
 110   c4->SaveAs("Noise-NSide-Layer6.eps");
 111 }
 112
 113 //_____________________________________________________________________//
 114 void drawPedestalDistributions(Int_t runNumber) {
 115   //Draws the pedestal distributions for each side and layer
 116   TString filename = "pedestalDistributionsSSD."; filename += runNumber;
 117   filename += ".root";
 118   TFile *f = TFile::Open(filename.Data());
 119   TH1F *gHistPedestalPSideLayer5 = dynamic_cast<TH1F *>(f->Get("gHistPedestalPSideLayer5"));
 120   TH1F *gHistPedestalNSideLayer5 = dynamic_cast<TH1F *>(f->Get("gHistPedestalNSideLayer5"));
 121   TH1F *gHistPedestalPSideLayer6 = dynamic_cast<TH1F *>(f->Get("gHistPedestalPSideLayer6"));
 122   TH1F *gHistPedestalNSideLayer6 = dynamic_cast<TH1F *>(f->Get("gHistPedestalNSideLayer6"));
 123
 124   TCanvas *c1 = new TCanvas("c1","Pedestal distribution (P-side, Layer 5)",
 125                             0,0,400,400);
 126   c1->SetFillColor(10); c1->SetHighLightColor(10); c1->SetLogy();
 127   gHistPedestalPSideLayer5->SetStats(kFALSE); gHistPedestalPSideLayer5->Draw();
 128   c1->SaveAs("Pedestal-PSide-Layer5.eps");
 129
 130   TCanvas *c2 = new TCanvas("c2","Pedestal distribution (N-side, Layer 5)",
 131                             400,0,400,400);
 132   c2->SetFillColor(10); c2->SetHighLightColor(10); c2->SetLogy();
 133   gHistPedestalNSideLayer5->SetStats(kFALSE); gHistPedestalNSideLayer5->Draw();
 134   c2->SaveAs("Pedestal-NSide-Layer5.eps");
 135
 136   TCanvas *c3 = new TCanvas("c3","Pedestal distribution (P-side, Layer 6)",
 137                             0,400,400,400);
 138   c3->SetFillColor(10); c3->SetHighLightColor(10); c3->SetLogy();
 139   gHistPedestalPSideLayer6->SetStats(kFALSE); gHistPedestalPSideLayer6->Draw();
 140   c3->SaveAs("Pedestal-PSide-Layer6.eps");
 141
 142   TCanvas *c4 = new TCanvas("c4","Pedestal distribution (N-side, Layer 6)",
 143                             400,400,400,400);
 144   c4->SetFillColor(10); c4->SetHighLightColor(10); c4->SetLogy();
 145   gHistPedestalNSideLayer6->SetStats(kFALSE); gHistPedestalNSideLayer6->Draw();
 146   c4->SaveAs("Pedestal-NSide-Layer6.eps");
 147 }
 148
 149 //_____________________________________________________________________//
 150 void Pedestal(AliCDBManager * man) {
 151   //Reads the noise OCDB file
 152   const Int_t fgkSSDMODULES = 1698;
 153   static const Int_t fgkDefaultNStripsSSD = 768;
 154
 155   Int_t runNumber = man->GetRun();
 156
 157   //=========================================================//
 158   //pedestal histograms
 159   TH1F *gHistPedestalPSideLayer5 = new TH1F("gHistPedestalPSideLayer5",
 160                                             "Pedestal values (P-side, Layer5); ADC counts; Entries;",
 161                                             1000,-500,500);
 162   TH1F *gHistPedestalNSideLayer5 = new TH1F("gHistPedestalNSideLayer5",
 163                                             "Pedestal values (N-side, Layer5); ADC counts; Entries;",
 164                                             1000,-500,500);
 165   TH1F *gHistPedestalPSideLayer6 = new TH1F("gHistPedestalPSideLayer6",
 166                                             "Pedestal values (P-side, Layer6); ADC counts; Entries;",
 167                                             1000,-500,500);
 168   TH1F *gHistPedestalNSideLayer6 = new TH1F("gHistPedestalNSideLayer6",
 169                                             "Pedestal values (N-side, Layer6); ADC counts; Entries;",
 170                                             1000,-500,500);
 171
 172   //=========================================================//
 173   Int_t fLayer = 0,fLadder = 0, fModule = 0;
 174
 175   //=========================================================//
 176   AliITSBadChannelsSSDv2 *badChannelsSSD = new AliITSBadChannelsSSDv2();
 177   AliCDBEntry *entryBadChannelsSSD = man->Get("ITS/Calib/BadChannelsSSD");
 178   TObject *emptyBadChannel = (TObject *)entryBadChannelsSSD->GetObject();
 179   TString objectnameBadChannel = emptyBadChannel->GetName();
 180   if(objectnameBadChannel=="TObjArray") {
 181     TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject();
 182     ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD);
 183   }
 184   else if(objectnameBadChannel=="AliITSBadChannelsSSDv2") {
 185     cout<<"Reading the new format of the calibration file..."<<endl;
 186     badChannelsSSD = (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject();
 187   }
 188
 189   //=========================================================//
 190   AliITSPedestalSSDv2 *pedestalSSD = new AliITSPedestalSSDv2();
 191   AliCDBEntry *entryPedestalSSD = man->Get("ITS/Ref/PedestalSSD");
 192   TObject *emptyPedestal = (TObject *)entryPedestalSSD->GetObject();
 193   TString objectnamePedestal = emptyPedestal->GetName();
 194   if(objectnamePedestal=="TObjArray") {
 195     TObjArray *pedestalSSDOld = (TObjArray *)entryPedestalSSD->GetObject();
 196     ReadOldSSDPedestal(pedestalSSDOld, pedestalSSD);
 197   }
 198   else if(objectnamePedestal=="AliITSPedestalSSDv2") {
 199     cout<<"Reading the new format of the calibration file..."<<endl;
 200     pedestalSSD = (AliITSPedestalSSDv2 *)entryPedestalSSD->GetObject();
 201   }
 202
 203   Double_t pedestalPSide = 0.0, pedestalNSide = 0.0;
 204   Int_t badChannelPSide = 0, badChannelNSide = 0;
 205   for (Int_t i = 0; i < fgkSSDMODULES; i++) {
 206     AliITSgeomTGeo::GetModuleId(i+500,fLayer,fLadder,fModule);
 207     //cout<<"Pedestal for module: "<<i+500<<" - Layer: "<<fLayer<<endl;
 208     for(Int_t j = 0; j < fgkDefaultNStripsSSD; j++) {
 209       badChannelPSide = (Int_t)(badChannelsSSD->GetBadChannelP(i,j));
 210       pedestalPSide = pedestalSSD->GetPedestalP(i,j);
 211       if(badChannelPSide == 0) {
 212         //Printf("Pedestal value: %lf",pedestal);
 213         if(fLayer == 5)
 214           gHistPedestalPSideLayer5->Fill(pedestalPSide);
 215         if(fLayer == 6)
 216           gHistPedestalPSideLayer6->Fill(pedestalPSide);
 217       }
 218
 219       badChannelNSide = (Int_t)(badChannelsSSD->GetBadChannelN(i,j));
 220       pedestalNSide = pedestalSSD->GetPedestalN(i,j);
 221       if(badChannelNSide == 0) {
 222         if(fLayer == 5)
 223           gHistPedestalNSideLayer5->Fill(pedestalNSide);
 224         if(fLayer == 6)
 225           gHistPedestalNSideLayer6->Fill(pedestalNSide);
 226       }
 227     }//loop over strips
 228   }//loop over modules
 229
 230   TString output = "pedestalDistributionsSSD."; output += runNumber;
 231   output += ".root";
 232   TFile *f = TFile::Open(output.Data(),"recreate");
 233   gHistPedestalPSideLayer5->Write();
 234   gHistPedestalNSideLayer5->Write();
 235   gHistPedestalPSideLayer6->Write();
 236   gHistPedestalNSideLayer6->Write();
 237   f->Close();
 238 }
 239
 240 //_____________________________________________________________________//
 241 void Noise(AliCDBManager * man) {
 242   //Reads the noise OCDB file
 243   const Int_t fgkSSDMODULES = 1698;
 244   const Int_t fgkSSDSTRIPSPERMODULE = 1536;
 245   static const Int_t fgkDefaultNStripsSSD = 768;
 246
 247   Int_t runNumber = man->GetRun();
 248
 249   //noise histograms
 250   TH1F *gHistNoisePSideLayer5 = new TH1F("gHistNoisePSideLayer5",
 251                                          "Noise values (P-side, Layer5); ADC counts; Entries;",
 252                                          1000,0,100);
 253   TH1F *gHistNoiseNSideLayer5 = new TH1F("gHistNoiseNSideLayer5",
 254                                          "Noise values (N-side, Layer5); ADC counts; Entries;",
 255                                          1000,0,100);
 256   TH1F *gHistNoisePSideLayer6 = new TH1F("gHistNoisePSideLayer6",
 257                                          "Noise values (P-side, Layer6); ADC counts; Entries;",
 258                                          1000,0,100);
 259   TH1F *gHistNoiseNSideLayer6 = new TH1F("gHistNoiseNSideLayer6",
 260                                          "Noise values (N-side, Layer6); ADC counts; Entries;",
 261                                          1000,0,100);
 262
 263   Int_t fLayer = 0,fLadder = 0, fModule = 0;
 264   Int_t fHistCounter = 0;
 265   TString fTitle;
 266   TObjArray *array = new TObjArray();
 267   TH1D *hNoiseModule[fgkSSDMODULES];
 268   for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) {
 269     AliITSgeomTGeo::GetModuleId(i,fLayer,fLadder,fModule);
 270     fTitle = "SSD_Noise_Layer"; fTitle += fLayer;
 271     fTitle += "_Ladder"; fTitle += fLadder;
 272     fTitle += "_Module"; fTitle += fModule;
 273
 274     hNoiseModule[fHistCounter] = new TH1D(fTitle.Data(),fTitle.Data(),1540,0,1540);
 275     hNoiseModule[fHistCounter]->GetXaxis()->SetTitleColor(1);
 276     hNoiseModule[fHistCounter]->GetXaxis()->SetTitle("Strip number");
 277     hNoiseModule[fHistCounter]->GetYaxis()->SetTitle("Noise");
 278     array->AddLast(hNoiseModule[fHistCounter]);
 279     fHistCounter += 1;
 280   }
 281
 282   //=========================================================//
 283   AliITSBadChannelsSSDv2 *badChannelsSSD = new AliITSBadChannelsSSDv2();
 284   AliCDBEntry *entryBadChannelsSSD = man->Get("ITS/Calib/BadChannelsSSD");
 285   TObject *emptyBadChannel = (TObject *)entryBadChannelsSSD->GetObject();
 286   TString objectnameBadChannel = emptyBadChannel->GetName();
 287   if(objectnameBadChannel=="TObjArray") {
 288     TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject();
 289     ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD);
 290   }
 291   else if(objectnameBadChannel=="AliITSBadChannelsSSDv2") {
 292     cout<<"Reading the new format of the calibration file..."<<endl;
 293     badChannelsSSD = (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject();
 294   }
 295
 296   //=========================================================//
 297   AliITSNoiseSSDv2 *noiseSSD = new AliITSNoiseSSDv2();
 298   AliCDBEntry *entryNoiseSSD = man->Get("ITS/Calib/NoiseSSD");
 299   TObject *emptyNoise = (TObject *)entryNoiseSSD->GetObject();
 300   TString objectnameNoise = emptyNoise->GetName();
 301   if(objectnameNoise=="TObjArray") {
 302     TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject();
 303     ReadOldSSDNoise(noiseSSDOld, noiseSSD);
 304   }
 305   else if(objectnameNoise=="AliITSNoiseSSDv2") {
 306     cout<<"Reading the new format of the calibration file..."<<endl;
 307     noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject();
 308   }
 309
 310   Double_t noisePSide = 0.0, noiseNSide = 0.0;
 311   Int_t badChannelPSide = 0, badChannelNSide = 0;
 312   for (Int_t i = 0; i < fgkSSDMODULES; i++) {
 313     AliITSgeomTGeo::GetModuleId(i+500,fLayer,fLadder,fModule);
 314     //cout<<"Noise for module: "<<i+500<<" - Layer: "<<fLayer<<endl;
 315     for(Int_t j = 0; j < fgkDefaultNStripsSSD; j++) {
 316       badChannelPSide = (Int_t)(badChannelsSSD->GetBadChannelP(i,j));
 317       noisePSide = noiseSSD->GetNoiseP(i,j);
 318       hNoiseModule[i]->SetBinContent(j+1,noisePSide);
 319
 320       badChannelNSide = (Int_t)(badChannelsSSD->GetBadChannelN(i,j));
 321       noiseNSide = noiseSSD->GetNoiseN(i,j);
 322       hNoiseModule[i]->SetBinContent(fgkSSDSTRIPSPERMODULE-j,noiseNSide);
 323
 324       if(badChannelPSide == 0) {
 325         if(fLayer == 5)
 326           gHistNoisePSideLayer5->Fill(noisePSide);
 327         if(fLayer == 6)
 328           gHistNoisePSideLayer6->Fill(noisePSide);
 329       }
 330       if(badChannelNSide == 0) {
 331         if(fLayer == 5)
 332           gHistNoiseNSideLayer5->Fill(noiseNSide);
 333         if(fLayer == 6)
 334           gHistNoiseNSideLayer6->Fill(noiseNSide);
 335       }
 336     }//loop over strips
 337   }//loop over modules
 338
 339   TString output1 = "noiseSSD."; output1 += runNumber; output1 += ".root";
 340   TFile *f1 = TFile::Open(output1.Data(),"recreate");
 341   array->Write();
 342   f1->Close();
 343
 344   TString output2 = "noiseDistributionsSSD."; output2 += runNumber;
 345   output2 += ".root";
 346   TFile *f2 = TFile::Open(output2.Data(),"recreate");
 347   gHistNoisePSideLayer5->Write();
 348   gHistNoiseNSideLayer5->Write();
 349   gHistNoisePSideLayer6->Write();
 350   gHistNoiseNSideLayer6->Write();
 351   f2->Close();
 352 }
 353
 354 //_____________________________________________________________________//
 355 void GainCalibration(AliCDBManager * man) {
 356   const Int_t fgkSSDMODULES = 1698;
 357   static const Int_t fgkDefaultNStripsSSD = 768;
 358
 359   TH2F *fHistGainMapLayer5 = new TH2F("fHistGainMapLayer5",
 360                                       "Layer 5;N_{strip};N_{module}",
 361                                       1537,0,1537,
 362                                       750,499,1249);
 363   fHistGainMapLayer5->GetXaxis()->SetTitleColor(1);
 364   fHistGainMapLayer5->SetStats(kFALSE);
 365   fHistGainMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 366   TH2F *fHistGainMapLayer6 = new TH2F("fHistGainMapLayer6",
 367                                       "Layer 6;N_{strip};N_{module}",
 368                                       1537,0,1537,
 369                                       952,1249,2199);
 370   fHistGainMapLayer6->GetXaxis()->SetTitleColor(1);
 371   fHistGainMapLayer6->SetStats(kFALSE);
 372   fHistGainMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 373
 374   AliITSGainSSDv2 *gainSSD = new AliITSGainSSDv2();
 375   AliCDBEntry *entryGainSSD = man->Get("ITS/Calib/GainSSD");
 376   TObject *empty = (TObject *)entryGainSSD->GetObject();
 377   TString objectname = empty->GetName();
 378   if(objectname=="Gain") {
 379     TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject();
 380     ReadOldSSDGain(gainSSDOld, gainSSD);
 381   }
 382   else if(objectname=="AliITSGainSSDv2") {
 383     cout<<"Reading the new format of the calibration file..."<<endl;
 384     gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject();
 385   }
 386
 387   Int_t layer = 0, ladder = 0, module = 0;
 388   Double_t gain = 0;
 389   for (Int_t i = 0; i < fgkSSDMODULES; i++) {
 390   //for (Int_t i = 0; i < 1; i++) {
 391     AliITSgeomTGeo::GetModuleId(i+500,layer,ladder,module);
 392     for(Int_t j = 0; j < fgkDefaultNStripsSSD; j++) {
 393       gain = gainSSD->GetGainP(i,j);
 394       //cout<<"GainP: "<<gain<<endl;
 395       if(layer == 5)
 396         fHistGainMapLayer5->Fill(j,i+500,gain);
 397       if(layer == 6)
 398         fHistGainMapLayer6->Fill(j,i+500,gain);
 399
 400       gain = gainSSD->GetGainN(i,j);
 401       //cout<<"GainN: "<<gain<<endl;
 402       if(layer == 5)
 403         fHistGainMapLayer5->Fill(fgkDefaultNStripsSSD+j,i+500,gain);
 404       if(layer == 6)
 405         fHistGainMapLayer6->Fill(fgkDefaultNStripsSSD+j,i+500,gain);
 406     }//strip loop
 407   }//module loop
 408
 409   TCanvas *cGain = new TCanvas("cGain","Gain calibration map",0,300,600,300);
 410   cGain->SetHighLightColor(10); cGain->SetFillColor(10); cGain->Divide(2,1);
 411
 412   cGain->cd(1)->SetBottomMargin(.2); cGain->cd(1)->SetLeftMargin(.15);
 413   cGain->cd(1); fHistGainMapLayer5->Draw("colz");
 414   cGain->cd(2)->SetBottomMargin(.2); cGain->cd(2)->SetLeftMargin(.15);
 415   cGain->cd(2); fHistGainMapLayer6->Draw("colz");
 416 }
 417
 418 //_____________________________________________________________________//
 419 void ReadOldSSDNoise(TObjArray *array,
 420                      AliITSNoiseSSDv2 *noiseSSD) {
 421   const Int_t fgkSSDSTRIPSPERMODULE = 1536;
 422   const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768;
 423
 424   Int_t fNMod = array->GetEntries();
 425   cout<<"Converting old calibration object for noise..."<<endl;
 426
 427   //NOISE
 428   Double_t noise = 0.0;
 429   for (Int_t iModule = 0; iModule < fNMod; iModule++) {
 430     AliITSNoiseSSD *noiseModule = (AliITSNoiseSSD*) (array->At(iModule));
 431     for(Int_t iStrip = 0; iStrip < fgkSSDSTRIPSPERMODULE; iStrip++) {
 432       noise = (iStrip < fgkSSDPSIDESTRIPSPERMODULE) ? noiseModule->GetNoiseP(iStrip) : noiseModule->GetNoiseN(1535 - iStrip);
 433       if(iStrip < fgkSSDPSIDESTRIPSPERMODULE)
 434         noiseSSD->AddNoiseP(iModule,iStrip,noise);
 435       if(iStrip >= fgkSSDPSIDESTRIPSPERMODULE)
 436         noiseSSD->AddNoiseN(iModule,1535 - iStrip,noise);
 437     }//loop over strips
 438   }//loop over modules
 439 }
 440
 441 //_____________________________________________________________________//
 442 void ReadOldSSDPedestal(TObjArray *array,
 443                         AliITSPedestalSSDv2 *pedestalSSD) {
 444   const Int_t fgkSSDSTRIPSPERMODULE = 1536;
 445   const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768;
 446
 447   Int_t fNMod = array->GetEntries();
 448   cout<<"Converting old calibration object for pedestal..."<<endl;
 449
 450   //PEDESTAL
 451   Double_t pedestal = 0.0;
 452   for (Int_t iModule = 0; iModule < fNMod; iModule++) {
 453     AliITSPedestalSSD *pedestalModule = (AliITSPedestalSSD*) (array->At(iModule));
 454     for(Int_t iStrip = 0; iStrip < fgkSSDSTRIPSPERMODULE; iStrip++) {
 455       pedestal = (iStrip < fgkSSDPSIDESTRIPSPERMODULE) ? pedestalModule->GetPedestalP(iStrip) : pedestalModule->GetPedestalN(1535 - iStrip);
 456       if(iStrip < fgkSSDPSIDESTRIPSPERMODULE)
 457         pedestalSSD->AddPedestalP(iModule,iStrip,pedestal);
 458       if(iStrip >= fgkSSDPSIDESTRIPSPERMODULE)
 459         pedestalSSD->AddPedestalN(iModule,1535 - iStrip,pedestal);
 460     }//loop over strips
 461   }//loop over modules
 462 }
 463
 464 //_____________________________________________________________________//
 465 void ReadOldSSDBadChannels(TObjArray *array,
 466                            AliITSBadChannelsSSDv2 *badChannelsSSD) {
 467   Int_t fNMod = array->GetEntries();
 468   cout<<"Converting old calibration object for bad channels..."<<endl;
 469   for (Int_t iModule = 0; iModule < fNMod; iModule++) {
 470     //for (Int_t iModule = 0; iModule < 1; iModule++) {
 471     AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (array->At(iModule));
 472     TArrayI arrayPSide = bad->GetBadPChannelsList();
 473     for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
 474       badChannelsSSD->AddBadChannelP(iModule,
 475                                      iPCounter,
 476                                      (Char_t)arrayPSide.At(iPCounter));
 477
 478     TArrayI arrayNSide = bad->GetBadNChannelsList();
 479     for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
 480       badChannelsSSD->AddBadChannelN(iModule,
 481                                      iNCounter,
 482                                      (Char_t)arrayNSide.At(iNCounter));
 483
 484   }//loop over modules
 485 }
 486
 487 //_____________________________________________________________________//
 488 void ReadOldSSDGain(TObjArray *array,
 489                     AliITSGainSSDv2 *gainSSD) {
 490   Int_t fNMod = array->GetEntries();
 491   cout<<"Converting old calibration object for gain..."<<endl;
 492
 493   //GAIN
 494   for (Int_t iModule = 0; iModule < fNMod; iModule++) {
 495     AliITSGainSSD *gainModule = (AliITSGainSSD*) (array->At(iModule));
 496     TArrayF arrayPSide = gainModule->GetGainP();
 497     for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
 498       gainSSD->AddGainP(iModule,
 499                         iPCounter,
 500                         arrayPSide.At(iPCounter));
 501     TArrayF arrayNSide = gainModule->GetGainN();
 502     for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
 503       gainSSD->AddGainN(iModule,
 504                         iNCounter,
 505                         arrayNSide.At(iNCounter));
 506   }//loop over modules
 507 }