new macro to create the SPD calibration file
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 10 Oct 2007 17:12:48 +0000 (17:12 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 10 Oct 2007 17:12:48 +0000 (17:12 +0000)
ITS/AliITSStoreDeadSPD.C [new file with mode: 0644]

diff --git a/ITS/AliITSStoreDeadSPD.C b/ITS/AliITSStoreDeadSPD.C
new file mode 100644 (file)
index 0000000..aa351b5
--- /dev/null
@@ -0,0 +1,357 @@
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// Example of usage:                                                    //
+// 1. Fix the seed                                                      //
+// 2. Randomly store 1% dead pixels all over the SPD                    //
+// 3. Print the number of dead pixels temporarily generated             //
+// 4. Store the dead pixels in calibration objects for runNrs 1 to 10   //
+//                                                                      //
+// root [0] .L AliITSStoreDeadSPD.C                                     //
+// root [1] SetSeed(11)                                                 //
+// root [2] RandomizeDeadPixelsFrac(0.01)                               //
+// root [3] PrintNrDead()                                               //
+// root [4] StoreCalib(1,10)                                            //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+AliITSOnlineCalibrationSPDhandler* handler = NULL;
+TRandom* rnd = new TRandom();
+
+void StoreCalib(Int_t RunNrStart=0, Int_t RunNrEnd=9999999) {
+  if (handler!=NULL) {
+    handler->WriteToDB(RunNrStart,RunNrEnd);
+  }
+}
+
+void ReadCalib(UInt_t runNr) {
+  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+  else ClearDead();
+  handler->ReadFromDB(runNr);
+}
+
+void SetSeed(UInt_t seed) {
+  rnd->SetSeed(seed);
+}
+
+void PrintNrDead() {
+  if (handler!=NULL) {
+    printf("Nr of dead pixels: %d\n",handler->GetNrDead());
+  }
+}
+
+void PrintDead() {
+  if (handler!=NULL) {
+    handler->PrintDead();
+  }
+}
+
+void ClearDead() {
+  if (handler!=NULL) {
+    handler->ResetDead();
+  }
+}
+
+void RandomizeDeadPixelsFrac(Double_t fraction) {
+  if (fraction>0 && fraction<=1) {
+    UInt_t nrdeadpixels = static_cast<UInt_t>(fraction*256*160*240 + 0.5);
+    RandomizeDeadPixels(nrdeadpixels);
+  }
+}
+void RandomizeDeadPixels(UInt_t nrDead) {
+  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+  UInt_t nrDeadInserted = 0;
+  while (nrDeadInserted<nrDead) {
+    UInt_t mod = (UInt_t)(rnd->Rndm()*240);
+    UInt_t col = (UInt_t)(rnd->Rndm()*160);
+    UInt_t row = (UInt_t)(rnd->Rndm()*256);
+    if (handler->SetDeadPixelM(mod,col,row)) nrDeadInserted++;
+  }
+}
+
+void RandomizeDeadPixelsFrac(Double_t fraction, UInt_t layer) {
+  if (fraction>0 && fraction<=1) {
+    UInt_t nr_pixels;
+    UInt_t nrdeadpixels;
+    switch(layer) {
+    case 0: 
+      nr_pixels = 256*160*80;
+      nrdeadpixels = static_cast<UInt_t>(fraction*nr_pixels + 0.5);
+      RandomizeDeadPixels(nrdeadpixels,layer);
+      break;
+    case 1:
+      nr_pixels = 256*160*160;
+      nrdeadpixels = static_cast<Int_t>(fraction*nr_pixels + 0.5);
+      RandomizeDeadPixels(nrdeadpixels,layer);
+      break;
+    default:
+      return;
+    }
+  }
+}
+void RandomizeDeadPixels(UInt_t nrDead, UInt_t layer) {
+  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+  UInt_t nr_modules;
+  UInt_t mod_offset;
+  switch(layer) {
+  case 0: 
+    nr_modules=80;
+    mod_offset=0;
+    break;
+  case 1:
+    nr_modules=160;
+    mod_offset=80;
+    break;
+  default:
+    return;
+  }
+  UInt_t nrDeadInserted = 0;
+  while (nrDeadInserted<nrDead) {
+    UInt_t mod = (UInt_t)(rnd->Rndm()*nr_modules) + mod_offset;
+    UInt_t col = (UInt_t)(rnd->Rndm()*160);
+    UInt_t row = (UInt_t)(rnd->Rndm()*256);
+    if (handler->SetDeadPixelM(mod,col,row)) nrDeadInserted++;
+  }
+}
+
+void RandomizeDeadChipsFrac(Double_t fraction) {
+  if (fraction>0 && fraction<=1) {
+    UInt_t nrdeadchips = static_cast<UInt_t>(fraction*240*5 + 0.5);
+    RandomizeDeadChips(nrdeadchips);
+  }
+}
+void RandomizeDeadChips(UInt_t nrDeadChips) {
+  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+  UInt_t nrDeadChipsInserted = 0;
+  AliITSIntMap* chipMap = new AliITSIntMap();
+  while (nrDeadChipsInserted<nrDeadChips) {
+    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
+    UInt_t hs = (UInt_t)(rnd->Rndm()*6);
+    UInt_t chip = (UInt_t)(rnd->Rndm()*10);
+    if (!chipMap->Find(20*6*chip + 20*hs + eq)) {
+      for (UInt_t col=0; col<32; col++) {
+       for (UInt_t row=0; row<256; row++) {
+         handler->SetDeadPixel(eq,hs,chip,col,row); 
+       }
+      }
+      chipMap->Insert(20*6*chip + 20*hs + eq, chip);
+      nrDeadChipsInserted++;
+    }
+  }
+  delete chipMap;
+}
+
+void RandomizeDeadChipsFrac(Double_t fraction, UInt_t layer) {
+  if (fraction>0 && fraction<=1) {
+    UInt_t nr_chips;
+    UInt_t nrdeadchips;
+    switch(layer) {
+    case 0: 
+      nr_chips = 400;
+      nrdeadchips = static_cast<UInt_t>(fraction*nr_chips + 0.5);
+      RandomizeDeadChips(nrdeadchips,layer);
+      break;
+    case 1:
+      nr_chips = 800;
+      nrdeadchips = static_cast<UInt_t>(fraction*nr_chips + 0.5);
+      RandomizeDeadChips(nrdeadchips,layer);
+      break;
+    default:
+      return;
+    }
+  }
+}
+void RandomizeDeadChips(UInt_t nrDeadChips, UInt_t layer) {
+  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+  UInt_t hs_nr;
+  UInt_t hs_offset;
+  switch(layer) {
+  case 0: 
+    hs_nr=2;
+    hs_offset=0;
+    break;
+  case 1:
+    hs_nr=4;
+    hs_offset=2;
+    break;
+  default:
+    return;
+  }
+  UInt_t nrDeadChipsInserted = 0;
+  AliITSIntMap* chipMap = new AliITSIntMap();
+  while (nrDeadChipsInserted<nrDeadChips) {
+    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
+    UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
+    UInt_t chip = (UInt_t)(rnd->Rndm()*10);
+    if (!chipMap->Find(20*6*chip + 20*hs + eq)) {
+      for (UInt_t col=0; col<32; col++) {
+       for (UInt_t row=0; row<256; row++) {
+         handler->SetDeadPixel(eq,hs,chip,col,row); 
+       }
+      }
+      chipMap->Insert(20*6*chip + 20*hs + eq, chip);
+      nrDeadChipsInserted++;
+    }
+  }
+  delete chipMap;
+}
+
+void RandomizeDeadHalfStavesFrac(Double_t fraction) {
+  if (fraction>0 && fraction<=1) {
+    UInt_t nrdeadhstaves = static_cast<UInt_t>(fraction*120 + 0.5);
+    RandomizeDeadHalfStaves(nrdeadhstaves);
+  }
+}
+void RandomizeDeadHalfStaves(UInt_t nrDeadHS) {
+  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+  UInt_t nrDeadHSInserted = 0;
+  AliITSIntMap* hsMap = new AliITSIntMap();
+  while (nrDeadHSInserted<nrDeadHS) {
+    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
+    UInt_t hs = (UInt_t)(rnd->Rndm()*6);
+    if (!hsMap->Find(20*hs + eq)) {
+      for (UInt_t chip=0; chip<10; chip++) {
+       for (UInt_t col=0; col<32; col++) {
+         for (UInt_t row=0; row<256; row++) {
+           handler->SetDeadPixel(eq,hs,chip,col,row); 
+         }
+       }
+      }
+      hsMap->Insert(20*hs + eq, hs);
+      nrDeadHSInserted++;
+    }
+  }
+  delete hsMap;
+}
+
+void RandomizeDeadHalfStavesFrac(Double_t fraction, UInt_t layer) {
+  if (fraction>0 && fraction<=1) {
+    UInt_t nr_hstaves;
+    switch(layer) {
+    case 0: 
+      nr_hstaves=static_cast<UInt_t>(fraction*40 + 0.5);
+      RandomizeDeadHalfStaves(nr_hstaves,layer);
+      break;
+    case 1:
+      nr_hstaves=static_cast<UInt_t>(fraction*80 + 0.5);
+      RandomizeDeadHalfStaves(nr_hstaves,layer);
+      break;
+    default:
+      return;
+    }
+  }
+}
+void RandomizeDeadHalfStaves(UInt_t nrDeadHS, UInt_t layer) {
+  if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+  UInt_t hs_nr;
+  UInt_t hs_offset;
+  switch(layer) {
+  case 0: 
+    hs_nr=2;
+    hs_offset=0;
+    break;
+  case 1:
+    hs_nr=4;
+    hs_offset=2;
+    break;
+  default:
+    return;
+  }
+  UInt_t nrDeadHSInserted = 0;
+  AliITSIntMap* hsMap = new AliITSIntMap();
+  while (nrDeadHSInserted<nrDeadHS) {
+    UInt_t eq = (UInt_t)(rnd->Rndm()*20);
+    UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
+    if (!hsMap->Find(20*hs + eq)) {
+      for (UInt_t chip=0; chip<10; chip++) {
+       for (UInt_t col=0; col<32; col++) {
+         for (UInt_t row=0; row<256; row++) {
+           handler->SetDeadPixel(eq,hs,chip,col,row); 
+         }
+       }
+      }
+      hsMap->Insert(20*hs + eq, hs);
+      nrDeadHSInserted++;
+    }
+  }
+  delete hsMap;
+}
+
+void RandomizeDeadColumnChipsFrac(Double_t chipfraction, Double_t columnfraction) {
+  if (chipfraction>0 && chipfraction<=1 && columnfraction>0 && columnfraction<=1) {
+    if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+    UInt_t nrColChips = static_cast<UInt_t>(chipfraction*240*5 + 0.5);
+    UInt_t nrColChipsUsed = 0;
+    AliITSIntMap* colChipMap = new AliITSIntMap();
+    while (nrColChipsUsed<nrColChips) {
+      UInt_t eq = (UInt_t)(rnd->Rndm()*20);
+      UInt_t hs = (UInt_t)(rnd->Rndm()*6);
+      UInt_t chip = (UInt_t)(rnd->Rndm()*10);
+      if (!colChipMap->Find(20*6*chip + 20*hs + eq)) {
+       UInt_t nrCols = static_cast<UInt_t>(columnfraction*32 + 0.5);
+       UInt_t nrColsInserted = 0;
+       AliITSIntMap* colMap = new AliITSIntMap();
+       while (nrColsInserted<nrCols) {
+         UInt_t col = (UInt_t)(rnd->Rndm()*32);
+         if (!colMap->Find(col)) {
+           for (UInt_t row=0; row<256; row++) {
+             handler->SetDeadPixel(eq,hs,chip,col,row);
+           }
+           colMap->Insert(col,col);
+           nrColsInserted++;
+         }
+       }
+       delete colMap;
+       colChipMap->Insert(20*6*chip + 20*hs + eq, chip);
+       nrColChipsUsed++;
+      }
+    }
+    delete colChipMap;
+  }
+}
+void RandomizeDeadColumnChipsFrac(Double_t chipfraction, Double_t columnfraction, Int_t layer) {
+  if (chipfraction>0 && chipfraction<=1 && columnfraction>0 && columnfraction<=1) {
+    if (handler==NULL) handler = new AliITSOnlineCalibrationSPDhandler();
+    UInt_t hs_nr;
+    UInt_t hs_offset;
+    switch(layer) {
+    case 0: 
+      hs_nr=2;
+      hs_offset=0;
+      break;
+    case 1:
+      hs_nr=4;
+      hs_offset=2;
+      break;
+    default:
+      return;
+    }
+    UInt_t nrColChips = static_cast<UInt_t>(chipfraction*240*5 + 0.5);
+    UInt_t nrColChipsUsed = 0;
+    AliITSIntMap* colChipMap = new AliITSIntMap();
+    while (nrColChipsUsed<nrColChips) {
+      UInt_t eq = (UInt_t)(rnd->Rndm()*20);
+      UInt_t hs = (UInt_t)(rnd->Rndm()*hs_nr+hs_offset);
+      UInt_t chip = (UInt_t)(rnd->Rndm()*10);
+      if (!colChipMap->Find(20*6*chip + 20*hs + eq)) {
+       UInt_t nrCols = static_cast<UInt_t>(columnfraction*32 + 0.5);
+       UInt_t nrColsInserted = 0;
+       AliITSIntMap* colMap = new AliITSIntMap();
+       while (nrColsInserted<nrCols) {
+         UInt_t col = (UInt_t)(rnd->Rndm()*32);
+         if (!colMap->Find(col)) {
+           for (UInt_t row=0; row<256; row++) {
+             handler->SetDeadPixel(eq,hs,chip,col,row);
+           }
+           colMap->Insert(col,col);
+           nrColsInserted++;
+         }
+       }
+       delete colMap;
+       colChipMap->Insert(20*6*chip + 20*hs + eq, chip);
+       nrColChipsUsed++;
+      }
+    }
+    delete colChipMap;
+  }
+}
+