Account for Readout Cycles in the RemoveDeadPixels, fix in readDigits
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 6 Apr 2013 20:44:44 +0000 (20:44 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 6 Apr 2013 20:44:44 +0000 (20:44 +0000)
ITS/UPGRADE/AliITSUSensMap.cxx
ITS/UPGRADE/AliITSUSensMap.h
ITS/UPGRADE/AliITSUSimulation.cxx
ITS/UPGRADE/AliITSUSimulation.h
ITS/UPGRADE/AliITSUSimulationPix.cxx
ITS/UPGRADE/readDigits.C

index 87d0107..0e09fd9 100644 (file)
@@ -108,10 +108,10 @@ void AliITSUSensMap::Clear(Option_t*)
 }
 
 //______________________________________________________________________
-void AliITSUSensMap::DeleteItem(UInt_t col,UInt_t row)
+void AliITSUSensMap::DeleteItem(UInt_t col,UInt_t row,Int_t cycle)
 {
   // Delete a particular AliITSUSensMapItems.
-  SetUniqueID( GetIndex(col,row) );
+  SetUniqueID( GetIndex(col,row,cycle) );
   TObject* fnd = fBTree->FindObject(this);
   if (!fnd) return;
   Disable(fnd);
@@ -129,30 +129,6 @@ void AliITSUSensMap::DeleteItem(TObject* obj)
 }
 
 //______________________________________________________________________
-void AliITSUSensMap::GetCell(UInt_t index,UInt_t &i,UInt_t &j,UInt_t &cycle) const 
-{
-  // returns the i,j index numbers from the linearized index computed
-  // with GetIndex
-  if(index>=fDimCol*fDimRow*fDimCycle){
-    Warning("GetCell","Index out of range 0<=index=%d<%d",index,fDimCol*fDimRow*fDimCycle);
-    i=-1;j=-1,cycle=-1;
-    return;
-  } // end if
-  cycle = index/(fDimCol*fDimRow);
-  index %= (fDimCol*fDimRow);
-  //
-#ifdef _ROWWISE_SORT_
-  i = index%fDimCol;   // sorted in row, then in column
-  j = index/fDimCol;
-#else
-  i = index/fDimRow;   // sorted in column, then in row
-  j = index%fDimRow;
-#endif  
-  //
-  return;
-}
-
-//______________________________________________________________________
 void  AliITSUSensMap::SetDimensions(UInt_t dimCol,UInt_t dimRow,UInt_t dimCycle) 
 {
   // set dimensions for current sensor
@@ -162,3 +138,4 @@ void  AliITSUSensMap::SetDimensions(UInt_t dimCol,UInt_t dimRow,UInt_t dimCycle)
   fDimCycle=dimCycle;
   if (fDimCol*fDimRow*fDimCycle>kMaxPackDim) AliFatal(Form("Dimension %dx%dx%d cannot be packed to UInt_t",fDimCol,fDimRow,fDimCycle));
 }
+
index e93e37a..16d8357 100644 (file)
@@ -17,7 +17,6 @@
 // ***********************************************************************
 #include <TClonesArray.h>
 #include <TBtree.h>
-
 #define _ROWWISE_SORT_
 
 class AliITSUSensMap: public TObject 
@@ -32,16 +31,17 @@ class AliITSUSensMap: public TObject
   AliITSUSensMap(const AliITSUSensMap &source);
   AliITSUSensMap& operator=(const AliITSUSensMap &source);
   void Clear(Option_t* option = "");
-  void DeleteItem(UInt_t col,UInt_t row);
+  void DeleteItem(UInt_t col,UInt_t row, Int_t cycle);
   void DeleteItem(TObject* obj);
   //
   void  SetDimensions(UInt_t dimCol,UInt_t dimRow,UInt_t dimCycle=1);
-  void  GetMaxIndex(UInt_t &ni,UInt_t &nj,UInt_t &cycle) const {ni=fDimCol; nj=fDimRow; cycle=fDimCycle;}
-  Int_t GetMaxIndex()                      const {return fDimCol*fDimRow;}
+  void  GetMaxIndex(UInt_t &col,UInt_t &row,UInt_t &cycle) const {col=fDimCol; row=fDimRow; cycle=fDimCycle;}
+  Int_t GetMaxIndex()                      const {return fDimCol*fDimRow*fDimCycle;}
   Int_t GetEntries()                       const {return fBTree->GetEntries();}
   Int_t GetEntriesUnsorted()               const {return fItems->GetEntriesFast();}
-  void  GetMapIndex(UInt_t index,UInt_t &col,UInt_t &row,UInt_t &cycle) const {return GetCell(index, col, row, cycle);}
-  TObject* GetItem(UInt_t col,UInt_t row,UInt_t cycle)  {SetUniqueID(GetIndex(col,row,cycle)); return fBTree->FindObject(this);}
+  void  GetMapIndex(UInt_t index,UInt_t &col,UInt_t &row,Int_t &cycle) const {return GetCell(index,fDimCol,fDimRow,fDimCycle,col,row,cycle);}
+  void  GetCell(UInt_t index,UInt_t &col,UInt_t &row,Int_t &cycle)     const {return GetCell(index,fDimCol,fDimRow,fDimCycle,col,row,cycle);}
+  TObject* GetItem(UInt_t col,UInt_t row,Int_t cycle)  {SetUniqueID(GetIndex(col,row,cycle)); return fBTree->FindObject(this);}
   TObject* GetItem(UInt_t index)                 {SetUniqueID(index);         return fBTree->FindObject(this);}
   TObject* GetItem(const TObject* obj)           {return fBTree->FindObject(obj);}
   TObject* At(Int_t i)                     const {return fBTree->At(i);}             //!!! Access in sorted order !!!
@@ -49,8 +49,7 @@ class AliITSUSensMap: public TObject
   TObject* RegisterItem(TObject* obj)            {fBTree->Add(obj); return obj;}
   TObject* GetFree()                             {return (*fItems)[fItems->GetEntriesFast()];}
   //
-  void   GetCell(UInt_t index,UInt_t &col,UInt_t &row, UInt_t &cycle)   const;
-  UInt_t GetIndex(UInt_t col,UInt_t row,UInt_t cycle=0)  const;
+  UInt_t   GetIndex(UInt_t col,UInt_t row,Int_t cycle=0)  const;
   //
   TClonesArray* GetItems()                 const {return fItems;}
   TBtree*       GetItemsBTree()            const {return fBTree;}
@@ -62,26 +61,46 @@ class AliITSUSensMap: public TObject
   static Bool_t IsDisabled(TObject* obj)         {return obj ? obj->TestBit(kDisableBit) : kFALSE;}
   static void   Disable(TObject* obj)            {if (obj) obj->SetBit(kDisableBit);}
   static void   Enable(TObject* obj)             {if (obj) obj->ResetBit(kDisableBit);}
+  static void   GetCell(UInt_t index,UInt_t dcol,UInt_t drow,UInt_t dcycle,UInt_t &col,UInt_t &row,Int_t &cycle);
   //
  protected:
   //
-  UInt_t fDimCol;              // 1st dimension of the matrix
-  UInt_t fDimRow;              // 2nd dimention of the matrix
-  UInt_t fDimCycle;          // readout cycle
+  UInt_t fDimCol;              // 1st dimension of the matrix, col index may span from 0 to fDimCol
+  UInt_t fDimRow;              // 2nd dimention of the matrix, row index may span from 0 to fDimRow
+  UInt_t fDimCycle;            // readout cycle range, may span from -fDimCycle to fDimCycle
   TClonesArray*    fItems;   // pListItems array
   TBtree*          fBTree;   // tree for ordered access
   //
   ClassDef(AliITSUSensMap,1) // list of sensor signals (should be sortable objects)
 };     
 
-inline UInt_t AliITSUSensMap::GetIndex(UInt_t col,UInt_t row, UInt_t cycle) const  
+//______________________________________________________________________
+inline UInt_t AliITSUSensMap::GetIndex(UInt_t col,UInt_t row, Int_t cycle) const  
 {
   // linearized ID of digit
+  UInt_t cyclePos = cycle+fDimCycle; // cycle may span from -fDimCycle to fDimCycle
 #ifdef _ROWWISE_SORT_
-  return fDimCol*(cycle*fDimRow+row)+col; // sorted in row, then in column
+  return fDimCol*(cyclePos*fDimRow+row)+col; // sorted in row, then in column
 #else
-  return fDimRow*(cycle*fDimCol+col)+row; // sorted in column, then in row
+  return fDimRow*(cyclePos*fDimCol+col)+row; // sorted in column, then in row
 #endif
 }
 
+//______________________________________________________________________
+inline void AliITSUSensMap::GetCell(UInt_t index,UInt_t dcol,UInt_t drow,UInt_t dcycle,UInt_t &col,UInt_t &row,Int_t &cycle) 
+{
+  // returns the i,j index numbers from the linearized index computed with GetIndex
+  UInt_t dcr = dcol*drow;
+  cycle = int(index/dcr) - dcycle;
+  index %= dcr;
+#ifdef _ROWWISE_SORT_
+  col = index%dcol;   // sorted in row, then in column
+  row = index/dcol;
+#else
+  col = index/drow;   // sorted in column, then in row
+  row = index%drow;
+#endif  
+}
+
+
 #endif
index e20df80..383ea89 100644 (file)
@@ -99,6 +99,7 @@ void AliITSUSimulation::InitSimulationModule(AliITSUModule* mod, Int_t event, Al
   SetSegmentation(seg);
   SetResponseParam(resp);
   ClearMap();
+  memset(fCyclesID,0,2*kMaxROCycleAccept*sizeof(Bool_t));
   //
   if (event != fEvent) GenerateReadOutCycleOffset(); 
   SetEvent(event);
@@ -134,10 +135,13 @@ Bool_t AliITSUSimulation::AddSDigitsToModule(TSeqCollection *pItemArr,Int_t mask
 void AliITSUSimulation::UpdateMapSignal(UInt_t col,UInt_t row,Int_t trk,Int_t ht,Double_t signal, Int_t roCycle) 
 {
   // update map with new hit
-  // Note: roCycle can be anything between -kMaxROCycleAccept : kMaxROCycleAccept, but the index should be built with pos.number
-  UInt_t ind = fSensMap->GetIndex(col,row,roCycle+kMaxROCycleAccept);
+  // Note: roCycle can be anything between -kMaxROCycleAccept : kMaxROCycleAccept
+  UInt_t ind = fSensMap->GetIndex(col,row,roCycle);
   AliITSUSDigit* oldItem = (AliITSUSDigit*)fSensMap->GetItem(ind);
-  if (!oldItem) fSensMap->RegisterItem( new(fSensMap->GetFree()) AliITSUSDigit(trk,ht,fModule->GetIndex(),ind,signal,roCycle) );
+  if (!oldItem) {
+    fSensMap->RegisterItem( new(fSensMap->GetFree()) AliITSUSDigit(trk,ht,fModule->GetIndex(),ind,signal,roCycle) );
+    fCyclesID[roCycle+kMaxROCycleAccept] = kTRUE;
+  }
   else oldItem->AddSignal(trk,ht,signal);
 }
 
@@ -147,7 +151,10 @@ void AliITSUSimulation::UpdateMapNoise(UInt_t col,UInt_t row,Double_t noise, Int
   // update map with new hit
   UInt_t ind = fSensMap->GetIndex(col,row,roCycle);
   AliITSUSDigit* oldItem = (AliITSUSDigit*)fSensMap->GetItem(ind);
-  if (!oldItem) fSensMap->RegisterItem( new(fSensMap->GetFree()) AliITSUSDigit(fModule->GetIndex(),ind,noise,roCycle) );
+  if (!oldItem) {
+    fSensMap->RegisterItem( new(fSensMap->GetFree()) AliITSUSDigit(fModule->GetIndex(),ind,noise,roCycle) );
+    fCyclesID[roCycle+kMaxROCycleAccept] = kTRUE;
+  }
   else oldItem->AddNoise(noise);
 }
 
index 8e127d8..b79623a 100644 (file)
@@ -19,6 +19,7 @@
 #include "AliITSUSensMap.h"
 #include "AliITSsegmentation.h"
 #include "AliMathBase.h"
+#include <TArrayS.h>
 
 class AliITSCalibration;
 class AliITSUSimuParam;
@@ -102,6 +103,7 @@ class AliITSUSimulation : public TObject
   AliITSUModule       *fModule;         //! module being processed
   Int_t                fEvent;          //! event number being processed
   Int_t                fDebug;          //!  debug flag
+  Bool_t               fCyclesID[2*kMaxROCycleAccept]; //! status of RO cycles
 
   ClassDef(AliITSUSimulation,1)       // Simulation base class 
     
index fae1a2c..7d2a45a 100644 (file)
@@ -124,6 +124,7 @@ AliITSUSimulationPix& AliITSUSimulationPix::operator=(const AliITSUSimulationPix
   fReadOutCycleLength = s.fReadOutCycleLength;
   fReadOutCycleOffset = s.fReadOutCycleOffset;
   fSpread2DHisto = s.fSpread2DHisto;
+  //
   fGlobalChargeScale = s.fGlobalChargeScale;
   fSpreadFun    = s.fSpreadFun;
   fROTimeFun    = s.fROTimeFun;
@@ -175,8 +176,8 @@ void AliITSUSimulationPix::SDigitiseModule()
   if (fModule->GetNHits()) Hits2SDigitsFast();
   //
   if (fSimuParam->GetPixAddNoisyFlag())   AddNoisyPixels();
-  if (fSimuParam->GetPixRemoveDeadFlag()) RemoveDeadPixels(); 
   if (!fSensMap->GetEntries()) return;
+  if (fSimuParam->GetPixRemoveDeadFlag()) RemoveDeadPixels(); 
   WriteSDigits();
   ClearMap();
   //
@@ -216,6 +217,7 @@ void AliITSUSimulationPix::DigitiseModule()
   Hits2SDigitsFast();
   //
   if (fSimuParam->GetPixAddNoisyFlag())   AddNoisyPixels();
+  if (!fSensMap->GetEntries()) return;
   if (fSimuParam->GetPixRemoveDeadFlag()) RemoveDeadPixels();
   FrompListToDigits();
   ClearMap();
@@ -509,12 +511,18 @@ void AliITSUSimulationPix::RemoveDeadPixels()
   //
   if (calObj->IsBad()) {ClearMap(); return;} // whole module is masked
   //
+  // prepare the list of r/o cycles seen
+  Char_t cyclesSeen[2*kMaxROCycleAccept];
+  int ncycles = 0;
+  for (int i=2*kMaxROCycleAccept;i--;) if (fCyclesID[i]) cyclesSeen[ncycles++]=i-kMaxROCycleAccept;
+  
   // remove single bad pixels one by one
   int nsingle = calObj->GetNrBadSingle();
-  UInt_t col,row,cycle;
+  UInt_t col,row;
+  Int_t cycle;
   for (int i=nsingle;i--;) {
     calObj->GetBadPixelSingle(i,row,col);
-    fSensMap->DeleteItem(col,row);
+    for (int icl=ncycles;icl--;) fSensMap->DeleteItem(col,row,cyclesSeen[icl]);
   }
   int nsd = fSensMap->GetEntriesUnsorted();
   for (int isd=nsd;isd--;) {
@@ -546,7 +554,8 @@ void AliITSUSimulationPix::FrompListToDigits()
   // add noise and electronics, perform the zero suppression and add the
   // digit to the list
   static AliITSU *aliITS = (AliITSU*)gAlice->GetModule("ITS");
-  UInt_t ix,iz,iCycle;
+  UInt_t row,col;
+  Int_t iCycle;
   Double_t sig;
   const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
   static AliITSUDigitPix dig;
@@ -590,10 +599,10 @@ void AliITSUSimulationPix::FrompListToDigits()
       //PH This apparently is a problem which needs investigation
       AliWarning(Form("Too big or too small signal value %f",sig));
     }
-    fSensMap->GetMapIndex(sd->GetUniqueID(),iz,ix,iCycle);
-    dig.SetCoord1(iz);
-    dig.SetCoord2(ix);
-    dig.SetROCycle(int(iCycle) - kMaxROCycleAccept);
+    fSensMap->GetMapIndex(sd->GetUniqueID(),col,row,iCycle);
+    dig.SetCoord1(col);
+    dig.SetCoord2(row);
+    dig.SetROCycle(iCycle);
     dig.SetSignal((Int_t)sig);
     dig.SetSignalPix((Int_t)sig);
     int ntr = sd->GetNTracks();
@@ -623,7 +632,8 @@ Int_t AliITSUSimulationPix::CreateNoisyDigits(Int_t minID,Int_t maxID,double pro
   // see FrompListToDigits for details
   //
   static AliITSU *aliITS = (AliITSU*)gAlice->GetModule("ITS");
-  UInt_t ix,iz,iCycle;
+  UInt_t row,col;
+  Int_t iCycle;
   static AliITSUDigitPix dig;
   static TArrayI ordSampleInd(100),ordSample(100); //RS!!! static is not thread-safe!!!
   const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
@@ -635,10 +645,10 @@ Int_t AliITSUSimulationPix::CreateNoisyDigits(Int_t minID,Int_t maxID,double pro
   int* ordV = ordSample.GetArray();
   int* ordI = ordSampleInd.GetArray();
   for (int j=0;j<ncand;j++) {
-    fSensMap->GetMapIndex((UInt_t)ordV[ordI[j]],iz,ix,iCycle);   // create noisy digit
-    dig.SetCoord1(iz);
-    dig.SetCoord2(ix);
-    dig.SetROCycle(int(iCycle) - kMaxROCycleAccept);
+    fSensMap->GetMapIndex((UInt_t)ordV[ordI[j]],col,row,iCycle);   // create noisy digit
+    dig.SetCoord1(col);
+    dig.SetCoord2(row);
+    dig.SetROCycle(iCycle);
     dig.SetSignal(1);
     dig.SetSignalPix((Int_t)AliITSUSimuParam::GenerateNoiseQFunction(probNoisy,base,noise));
     for (int k=knmaxtrk;k--;) {
@@ -646,7 +656,7 @@ Int_t AliITSUSimulationPix::CreateNoisyDigits(Int_t minID,Int_t maxID,double pro
       dig.SetHit(k,-1);
     }
     aliITS->AddSimDigit(AliITSUGeomTGeo::kDetTypePix,&dig);
-    AliDebug(10,Form("Add noisy pixel %d(%d/%d) Noise=%d",ordV[ordI[j]],iz,ix,dig.GetSignalPix()));
+    AliDebug(10,Form("Add noisy pixel %d(%d/%d) Noise=%d",ordV[ordI[j]],col,row,dig.GetSignalPix()));
   }
   return ncand;
 }
@@ -675,13 +685,14 @@ void AliITSUSimulationPix::SetCoupling(AliITSUSDigit* old, Int_t ntrack, Int_t i
   // old                  existing AliITSUSDigit
   // Int_t ntrack         track incex number
   // Int_t idhit          hit index number
-  UInt_t col,row,iCycle;
+  UInt_t col,row;
+  Int_t iCycle;
   Double_t pulse1,pulse2;
   Double_t couplR=0.0,couplC=0.0;
   Double_t xr=0.;
   //
   fSensMap->GetMapIndex(old->GetUniqueID(),col,row,iCycle);
-  int cycle = int(iCycle)-kMaxROCycleAccept;
+  int cycle = iCycle;
   fSimuParam->GetPixCouplingParam(couplC,couplR);
   if (GetDebug(2)) AliInfo(Form("(col=%d,row=%d,ntrack=%d,idhit=%d)  couplC=%e couplR=%e",
                                col,row,ntrack,idhit,couplC,couplR));
@@ -726,16 +737,16 @@ void AliITSUSimulationPix::SetCouplingOld(AliITSUSDigit* old, Int_t ntrack,Int_t
   // idhit          hit index number
   // module         module number
   //
-  UInt_t col,row,iCycle;
+  UInt_t col,row;
+  Int_t cycle;
   Int_t modId = fModule->GetIndex();
   Double_t pulse1,pulse2;
   Double_t couplR=0.0,couplC=0.0;
   //
-  fSensMap->GetMapIndex(old->GetUniqueID(),col,row,iCycle);
-  int cycle = int(iCycle)-kMaxROCycleAccept;  
+  fSensMap->GetMapIndex(old->GetUniqueID(),col,row,cycle);
   fSimuParam->GetPixCouplingParam(couplC,couplR);
   if (GetDebug(3)) AliInfo(Form("(col=%d,row=%d,roCycle=%d,ntrack=%d,idhit=%d)  couplC=%e couplR=%e",
-                               col,row,iCycle,ntrack,idhit,couplC,couplR));
+                               col,row,cycle,ntrack,idhit,couplC,couplR));
  //
  if (old->GetSignal()<fSimuParam->GetPixMinElToAdd()) return; // too small signal
  for (Int_t isign=-1;isign<=1;isign+=2) {// loop in col direction
index a4afa96..8d822d4 100644 (file)
@@ -3,8 +3,7 @@ void readDigits(){
   gSystem->Load("libITSUpgradeBase");
   gSystem->Load("libITSUpgradeSim");
   gROOT->SetStyle("Plain");
-
-
+  const Int_t kMaxROCycleAccept=126;
   gAlice=NULL;
   AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
   runLoader->LoadgAlice();
@@ -73,7 +72,10 @@ void readDigits(){
       for (int isdig=0;isdig<nsdig;isdig++) {
        AliITSUSDigit *pSdig = (AliITSUSDigit*)sDigArr->At(isdig);
        int sdinfo = pSdig->GetUniqueID();
-       printf("#%3d Sdigit col:%4d/row:%4d generated by track %5d (%s)\t",isdig, sdinfo%segm->Npz(), sdinfo/segm->Npz(),
+       UInt_t row,col;
+       Int_t cycle;
+       AliITSUSensMap::GetCell(sdinfo,segm->Npz(),segm->Npx(),kMaxROCycleAccept,col,row,cycle);
+       printf("#%3d Sdigit col:%4d/row:%4d/cycle:%d generated by track %5d (%s)\t",isdig, col,row,cycle-kMaxROCycleAccept,
               pSdig->GetTrack(0),stack->Particle(pSdig->GetTrack(0))->GetName());
        pSdig->Print();
        hNelSDig[lay]->Fill(pSdig->GetSignal());