fixes in simulation classes
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 18 Aug 2012 01:59:48 +0000 (01:59 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 18 Aug 2012 01:59:48 +0000 (01:59 +0000)
ITS/UPGRADE/AliITSU.cxx
ITS/UPGRADE/AliITSUGeomTGeo.cxx
ITS/UPGRADE/AliITSUGeomTGeo.h
ITS/UPGRADE/AliITSUHit.cxx
ITS/UPGRADE/AliITSUSDigit.cxx
ITS/UPGRADE/AliITSUSegmentationPix.cxx
ITS/UPGRADE/AliITSUSimuParam.cxx
ITS/UPGRADE/AliITSUSimuParam.h
ITS/UPGRADE/AliITSUSimulationPix.cxx
ITS/UPGRADE/AliITSUSimulationPix.h

index 836f508..c715883 100644 (file)
@@ -679,6 +679,7 @@ void AliITSU::ResetDigits(Int_t branch)
 void AliITSU::AddSumDigit(AliITSUSDigit &sdig)
 {
   // Adds the module summable digits to the summable digits tree.
+  printf("Add sdigit %d : ",fSDigits->GetEntriesFast()); sdig.Print();
   new( (*fSDigits)[fSDigits->GetEntriesFast()]) AliITSUSDigit(sdig);
   //  
 }
index 189d65a..55f1f36 100644 (file)
@@ -394,6 +394,9 @@ TGeoHMatrix* AliITSUGeomTGeo::GetMatrixSens(Int_t lay, Int_t ladd, Int_t detInLa
     return 0;
   } // end if !gGeoManager
   TGeoHMatrix* mat = gGeoManager->GetCurrentMatrix();
+  //RSS
+  //  printf("%d/%d/%d %s\n",lay,ladd,detInLad,path.Data());
+  //  mat->Print();
   // Retstore the modeler state.
   gGeoManager->PopPath();
   return mat;
index e29d5bf..9dd79ba 100644 (file)
@@ -18,7 +18,7 @@
 //                                                                     //
 //  Note on the upgrade detector types:                                //
 //  The coarse type defines detectors served by different classes,     //
-//  like PixUpg. Each such a detector type can have kMaxSegmPerDetType //
+//  like Pix. Each such a detector type can have kMaxSegmPerDetType //
 //  segmentations (pitch etc.) whose parameteres are stored in the     //
 //  AliITSsegmentation derived class (like AliITSUSegmentationPix)   //
 //  This allows to have in the setup modules served by the same        //
index 5d60992..460180f 100644 (file)
@@ -71,6 +71,12 @@ void AliITSUHit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof)
   y = l[1];
   z = l[2];
   tof = fTof;
+  /*
+    RSS
+  printf("\nMod#%4d: Glo:%+7.2f %+7.2f %+7.2f | Loc: %+7.2f %+7.2f %+7.2f\n",
+              fModule,g[0],g[1],g[2],l[0],l[1],l[2]);
+  */
+  gm->GetMatrixSens(fModule)->Print();
   //
 }
 
index 239d287..f2f2edf 100644 (file)
@@ -133,18 +133,20 @@ void AliITSUSDigit::AddSignal(Int_t track,Int_t hit,Double_t signal)
     } // end for i & if.
   }
   //
-  if (flg && fNTracks>1) { // resort arrays.  
-    for (i=1;i<fNTracks;i++) {
-      j = i;
-      while(j>0 && fSignal[j]>fSignal[j-1]) {
-       swap(fTrack[j-1],fTrack[j]);
-       swap(fHits[j-1] ,fHits[j]);
-       swap(fSignal[j-1],fSignal[j]);
-       j--;
-      } // end while
-    } // end if i
+  if (flg) {
+    if (fNTracks>1) { // resort arrays.  
+      for (i=1;i<fNTracks;i++) {
+       j = i;
+       while(j>0 && fSignal[j]>fSignal[j-1]) {
+         swap(fTrack[j-1],fTrack[j]);
+         swap(fHits[j-1] ,fHits[j]);
+         swap(fSignal[j-1],fSignal[j]);
+         j--;
+       } // end while
+      } // end if i
+    } // end if added to existing and resorted array
     return;
-  } // end if added to existing and resorted array
+  }
   //
   // new entry add it in order.
   // if this signal is <= smallest then don't add it.
@@ -269,6 +271,7 @@ Int_t AliITSUSDigit::Compare(const TObject* obj) const
 void AliITSUSDigit::Print(Option_t*) const 
 {
   // print itself
-  printf("Mod: %4d Index:%7d Ntr:%2d |",fModule,GetUniqueID(),fNTracks);
-  for (int i=0;i<fNTracks;i++) printf("%d |",fTrack[i]); printf("\n");
+  printf("Mod: %4d Index:%7d Ntr:%2d | TotSignal:%.2e Noise:%.2e |",
+        fModule,GetUniqueID(),fNTracks,fTsignal,fNoise);
+  for (int i=0;i<fNTracks;i++) printf("%d(%.2e) |",fTrack[i],fSignal[i]); printf("\n");
 }
index c85a8cc..41cc417 100644 (file)
@@ -72,7 +72,7 @@ AliITSUSegmentationPix::AliITSUSegmentationPix(UInt_t id, int nchips,int ncol,in
 void AliITSUSegmentationPix::GetPadIxz(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const 
 {
   //  Returns pixel coordinates (ix,iz) for given real local coordinates (x,z)
-  //  expects x, z in microns
+  //  expects x, z in microns. RS: TO CHECK: why from 1
   ix = int(x/fPitchX) + 1;     
   iz = int(Z2Col(z)) + 1;
   //  
@@ -95,7 +95,7 @@ void AliITSUSegmentationPix::GetPadTxz(Float_t &x,Float_t &z) const
 void AliITSUSegmentationPix::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z) const
 {
   // Transform from pixel to real local coordinates
-  // returns x, z in microns
+  // returns x, z in microns. RS: TO CHECK if indexing starts from 1 or 0 
   x = (ix>0) ? Float_t((ix-0.5)*fPitchX) : Float_t((ix+0.5)*fPitchX);
   z = Col2Z(iz);
   //
@@ -105,16 +105,10 @@ void AliITSUSegmentationPix::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z) c
 Float_t AliITSUSegmentationPix::Z2Col(Float_t z) const 
 {
   // get column number (from 0) from local Z
-  int chip = z/fChipDZ;
+  int chip = int(z/fChipDZ);
   float col = chip*fNColPerChip;
   z -= chip*fChipDZ;
-  if (z<fPitchZLftCol) col += z/fPitchZLftCol;
-  else {
-    z = fPitchZLftCol;
-    col += 1;
-    if (z<(fChipDZ-fPitchZRgtCol)) col += 1+z/fPitchZ;
-    else col += 1+(z - (fNColPerChip-2)*fPitchZ)/fPitchZRgtCol;
-  }
+  if (z>fPitchZLftCol) col += 1+(z-fPitchZLftCol)/fPitchZ;
   return col;
 }
 
@@ -125,10 +119,11 @@ Float_t AliITSUSegmentationPix::Col2Z(Int_t col) const
   int nchip = col/fNColPerChip;
   col %= fNColPerChip;
   float z = nchip*fChipDZ;
-  if (!col) z -= fPitchZRgtCol/2;
-  else if (col==1) z += fPitchZLftCol/2;
-  else if (col==fNColPerChip-1) z += fChipDZ - fPitchZRgtCol/2;
-  else    z += fPitchZLftCol + (col-0.5)*fChipDZ;
+  if (col>0) {
+    if (col<fNColPerChip-1) z += fPitchZLftCol + (col-0.5)*fPitchZ;
+    else                    z += fChipDZ - fPitchZRgtCol/2;
+  }
+  else z += fPitchZLftCol/2;
   return z;
   //
 }
@@ -269,8 +264,8 @@ void AliITSUSegmentationPix::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z)
   x = -0.5/kCM2MC*Dx(); // default value.
   z = -0.5/kCM2MC*Dz(); // default value.
   // RS: to check: why we don't do strict check for [0:n)
-  if(ix<0 || ix>=fNRow) return; // outside of detector 
-  if(iz<0 || iz>=fNCol) return; // outside of detctor
+  if(ix<0 || ix>fNRow) return; // outside of detector 
+  if(iz<0 || iz>fNCol) return; // outside of detctor
   x += (ix+0.5)*fPitchX*(1./kCM2MC);       // RS: we go to the center of the pad, i.e. + pitch/2, not to the boundary as in SPD
   z += Col2Z(iz)*(1./kCM2MC); 
   return; // Found x and z, return.
index 4893d67..7d88768 100644 (file)
 #include "AliLog.h"
 
 
-const Double_t  AliITSUSimuParam::fgkPixUpgBiasVoltageDefault = 18.182;
-const Double_t  AliITSUSimuParam::fgkPixUpgThreshDefault = 3000.;
-const Double_t  AliITSUSimuParam::fgkPixUpgThrSigmaDefault = 250.;
-const UInt_t    AliITSUSimuParam::fgkPixUpgCouplingOptDefault = AliITSUSimuParam::kOldCouplingPixUpg;
-const Double_t  AliITSUSimuParam::fgkPixUpgCouplColDefault = 0.;
-const Double_t  AliITSUSimuParam::fgkPixUpgCouplRowDefault = 0.055;
-const Double_t  AliITSUSimuParam::fgkPixUpgEccDiffDefault = 0.85;
-const Double_t  AliITSUSimuParam::fgkPixUpgLorentzHoleWeightDefault = 1.0;
+const Double_t  AliITSUSimuParam::fgkPixBiasVoltageDefault = 18.182;
+const Double_t  AliITSUSimuParam::fgkPixThreshDefault = 2000.;
+const Double_t  AliITSUSimuParam::fgkPixThrSigmaDefault = 200.;
+const Double_t  AliITSUSimuParam::fgkPixMinElToAddDefault = 2.;
+const UInt_t    AliITSUSimuParam::fgkPixCouplingOptDefault = AliITSUSimuParam::kOldCouplingPix;
+const Double_t  AliITSUSimuParam::fgkPixCouplColDefault = 0.;
+const Double_t  AliITSUSimuParam::fgkPixCouplRowDefault = 0.055;
+const Double_t  AliITSUSimuParam::fgkPixEccDiffDefault = 0.85;
+const Double_t  AliITSUSimuParam::fgkPixLorentzHoleWeightDefault = 1.0;
 const Double_t  AliITSUSimuParam::fgkGeVtoChargeDefault = 3.6e-9;
 const Double_t  AliITSUSimuParam::fgkDOverVDefault = 0.000375;
 const Double_t  AliITSUSimuParam::fgkTDefault = 300;
@@ -49,72 +50,74 @@ AliITSUSimuParam::AliITSUSimuParam()
   ,fDOverV(fgkDOverVDefault)
   ,fT(fgkTDefault)
   //
-  ,fNPixUpg(0)
-  ,fPixUpgCouplOpt(kOldCouplingPixUpg)
-  ,fPixUpgCouplCol(fgkPixUpgCouplColDefault)
-  ,fPixUpgCouplRow(fgkPixUpgCouplRowDefault)
-  ,fPixUpgEccDiff(fgkPixUpgEccDiffDefault)
-  ,fPixUpgLorentzDrift(kTRUE)
-  ,fPixUpgLorentzHoleWeight(fgkPixUpgLorentzHoleWeightDefault)
-  ,fPixUpgAddNoisyFlag(kFALSE)
-  ,fPixUpgRemoveDeadFlag(kFALSE)
+  ,fNPix(0)
+  ,fPixCouplOpt(kOldCouplingPix)
+  ,fPixCouplCol(fgkPixCouplColDefault)
+  ,fPixCouplRow(fgkPixCouplRowDefault)
+  ,fPixEccDiff(fgkPixEccDiffDefault)
+  ,fPixLorentzDrift(kTRUE)
+  ,fPixLorentzHoleWeight(fgkPixLorentzHoleWeightDefault)
+  ,fPixAddNoisyFlag(kFALSE)
+  ,fPixRemoveDeadFlag(kFALSE)
   //
-  ,fPixUpgThreshDef(fgkPixUpgThreshDefault)
-  ,fPixUpgThrSigmaDef(fgkPixUpgThrSigmaDefault)
-  ,fPixUpgBiasVoltageDef(fgkPixUpgBiasVoltageDefault)
-  ,fPixUpgNoiseDef(0)
-  ,fPixUpgBaselineDef(0)
+  ,fPixThreshDef(fgkPixThreshDefault)
+  ,fPixThrSigmaDef(fgkPixThrSigmaDefault)
+  ,fPixBiasVoltageDef(fgkPixBiasVoltageDefault)
+  ,fPixNoiseDef(0)
+  ,fPixBaselineDef(0)
+  ,fPixMinElToAddDef(fgkPixMinElToAddDefault)
   //
-  ,fPixUpgThresh(0)
-  ,fPixUpgThrSigma(0)
-  ,fPixUpgBiasVoltage(0)
-  ,fPixUpgSigma(0)
-  ,fPixUpgNoise(0)
-  ,fPixUpgBaseline(0)
+  ,fPixThresh(0)
+  ,fPixThrSigma(0)
+  ,fPixBiasVoltage(0)
+  ,fPixSigma(0)
+  ,fPixNoise(0)
+  ,fPixBaseline(0)
 {  
   // default constructor
 }
 
 //______________________________________________________________________
-AliITSUSimuParam::AliITSUSimuParam(UInt_t nPixUpg)
+AliITSUSimuParam::AliITSUSimuParam(UInt_t nPix)
   :fGeVcharge(fgkGeVtoChargeDefault)
   ,fDOverV(fgkDOverVDefault)
   ,fT(fgkTDefault)
     //
-  ,fNPixUpg(nPixUpg)
-  ,fPixUpgCouplOpt(kOldCouplingPixUpg)
-  ,fPixUpgCouplCol(fgkPixUpgCouplColDefault)
-  ,fPixUpgCouplRow(fgkPixUpgCouplRowDefault)
-  ,fPixUpgEccDiff(fgkPixUpgEccDiffDefault)
-  ,fPixUpgLorentzDrift(kTRUE)
-  ,fPixUpgLorentzHoleWeight(fgkPixUpgLorentzHoleWeightDefault)
-  ,fPixUpgAddNoisyFlag(kFALSE)
-  ,fPixUpgRemoveDeadFlag(kFALSE)
+  ,fNPix(nPix)
+  ,fPixCouplOpt(kOldCouplingPix)
+  ,fPixCouplCol(fgkPixCouplColDefault)
+  ,fPixCouplRow(fgkPixCouplRowDefault)
+  ,fPixEccDiff(fgkPixEccDiffDefault)
+  ,fPixLorentzDrift(kTRUE)
+  ,fPixLorentzHoleWeight(fgkPixLorentzHoleWeightDefault)
+  ,fPixAddNoisyFlag(kFALSE)
+  ,fPixRemoveDeadFlag(kFALSE)
   //
-  ,fPixUpgThreshDef(fgkPixUpgThreshDefault)
-  ,fPixUpgThrSigmaDef(fgkPixUpgThrSigmaDefault)
-  ,fPixUpgBiasVoltageDef(fgkPixUpgBiasVoltageDefault)
-  ,fPixUpgNoiseDef(0)
-  ,fPixUpgBaselineDef(0)
+  ,fPixThreshDef(fgkPixThreshDefault)
+  ,fPixThrSigmaDef(fgkPixThrSigmaDefault)
+  ,fPixBiasVoltageDef(fgkPixBiasVoltageDefault)
+  ,fPixNoiseDef(0)
+  ,fPixBaselineDef(0)
+  ,fPixMinElToAddDef(fgkPixMinElToAddDefault)
   //
-  ,fPixUpgThresh(0)
-  ,fPixUpgThrSigma(0)
-  ,fPixUpgBiasVoltage(0)
-  ,fPixUpgSigma(0)
-  ,fPixUpgNoise(0)
-  ,fPixUpgBaseline(0)
+  ,fPixThresh(0)
+  ,fPixThrSigma(0)
+  ,fPixBiasVoltage(0)
+  ,fPixSigma(0)
+  ,fPixNoise(0)
+  ,fPixBaseline(0)
 {  
   // regular constructor
-  if (fNPixUpg>0) {
-    fPixUpgBiasVoltage = new Double_t[fNPixUpg];
-    fPixUpgThresh      = new Double_t[fNPixUpg];
-    fPixUpgThrSigma    = new Double_t[fNPixUpg];
-    fPixUpgNoise       = new Double_t[fNPixUpg];
-    fPixUpgBaseline    = new Double_t[fNPixUpg];
+  if (fNPix>0) {
+    fPixBiasVoltage = new Double_t[fNPix];
+    fPixThresh      = new Double_t[fNPix];
+    fPixThrSigma    = new Double_t[fNPix];
+    fPixNoise       = new Double_t[fNPix];
+    fPixBaseline    = new Double_t[fNPix];
   }
-  SetPixUpgThreshold(fgkPixUpgThreshDefault,fgkPixUpgThrSigmaDefault);
-  SetPixUpgNoise(0.,0.);
-  SetPixUpgBiasVoltage(fgkPixUpgBiasVoltageDefault);
+  SetPixThreshold(fgkPixThreshDefault,fgkPixThrSigmaDefault);
+  SetPixNoise(0.,0.);
+  SetPixBiasVoltage(fgkPixBiasVoltageDefault);
   //
 }
 
@@ -125,44 +128,45 @@ AliITSUSimuParam::AliITSUSimuParam(const AliITSUSimuParam &simpar)
   ,fDOverV(simpar.fDOverV)
   ,fT(simpar.fT)
    //
-  ,fNPixUpg(simpar.fNPixUpg)
-  ,fPixUpgCouplOpt(simpar.fPixUpgCouplOpt)
-  ,fPixUpgCouplCol(simpar.fPixUpgCouplCol)
-  ,fPixUpgCouplRow(simpar.fPixUpgCouplRow)
-  ,fPixUpgEccDiff(simpar.fPixUpgEccDiff)
-  ,fPixUpgLorentzDrift(simpar.fPixUpgLorentzDrift)
-  ,fPixUpgLorentzHoleWeight(simpar.fPixUpgLorentzHoleWeight)
-  ,fPixUpgAddNoisyFlag(simpar.fPixUpgAddNoisyFlag)
-  ,fPixUpgRemoveDeadFlag(simpar.fPixUpgRemoveDeadFlag)
+  ,fNPix(simpar.fNPix)
+  ,fPixCouplOpt(simpar.fPixCouplOpt)
+  ,fPixCouplCol(simpar.fPixCouplCol)
+  ,fPixCouplRow(simpar.fPixCouplRow)
+  ,fPixEccDiff(simpar.fPixEccDiff)
+  ,fPixLorentzDrift(simpar.fPixLorentzDrift)
+  ,fPixLorentzHoleWeight(simpar.fPixLorentzHoleWeight)
+  ,fPixAddNoisyFlag(simpar.fPixAddNoisyFlag)
+  ,fPixRemoveDeadFlag(simpar.fPixRemoveDeadFlag)
    //
-  ,fPixUpgThreshDef(simpar.fPixUpgThreshDef)
-  ,fPixUpgThrSigmaDef(simpar.fPixUpgThrSigmaDef)
-  ,fPixUpgBiasVoltageDef(simpar.fPixUpgBiasVoltageDef)
-  ,fPixUpgNoiseDef(simpar.fPixUpgNoiseDef)
-  ,fPixUpgBaselineDef(simpar.fPixUpgBaselineDef)
+  ,fPixThreshDef(simpar.fPixThreshDef)
+  ,fPixThrSigmaDef(simpar.fPixThrSigmaDef)
+  ,fPixBiasVoltageDef(simpar.fPixBiasVoltageDef)
+  ,fPixNoiseDef(simpar.fPixNoiseDef)
+  ,fPixBaselineDef(simpar.fPixBaselineDef)
+  ,fPixMinElToAddDef(simpar.fPixMinElToAddDef)
   //
-  ,fPixUpgThresh(0)
-  ,fPixUpgThrSigma(0)
-  ,fPixUpgBiasVoltage(0)
-  ,fPixUpgSigma(0)
-  ,fPixUpgNoise(0)
-  ,fPixUpgBaseline(0)   
+  ,fPixThresh(0)
+  ,fPixThrSigma(0)
+  ,fPixBiasVoltage(0)
+  ,fPixSigma(0)
+  ,fPixNoise(0)
+  ,fPixBaseline(0)   
    //
 {
   // copy constructor
-  if (fNPixUpg) {
-    fPixUpgBiasVoltage = new Double_t[fNPixUpg];
-    fPixUpgThresh      = new Double_t[fNPixUpg];
-    fPixUpgThrSigma    = new Double_t[fNPixUpg];
-    fPixUpgNoise       = new Double_t[fNPixUpg];
-    fPixUpgBaseline    = new Double_t[fNPixUpg];
+  if (fNPix) {
+    fPixBiasVoltage = new Double_t[fNPix];
+    fPixThresh      = new Double_t[fNPix];
+    fPixThrSigma    = new Double_t[fNPix];
+    fPixNoise       = new Double_t[fNPix];
+    fPixBaseline    = new Double_t[fNPix];
   }
-  for (Int_t i=fNPixUpg;i--;) {
-    fPixUpgBiasVoltage[i] = simpar.fPixUpgBiasVoltage[i];
-    fPixUpgThresh[i]      = simpar.fPixUpgThresh[i];
-    fPixUpgThrSigma[i]    = simpar.fPixUpgThrSigma[i];
-    fPixUpgNoise[i]       = simpar.fPixUpgNoise[i];
-    fPixUpgBaseline[i]    = simpar.fPixUpgBaseline[i];
+  for (Int_t i=fNPix;i--;) {
+    fPixBiasVoltage[i] = simpar.fPixBiasVoltage[i];
+    fPixThresh[i]      = simpar.fPixThresh[i];
+    fPixThrSigma[i]    = simpar.fPixThrSigma[i];
+    fPixNoise[i]       = simpar.fPixNoise[i];
+    fPixBaseline[i]    = simpar.fPixBaseline[i];
   }
   //
 }
@@ -182,11 +186,11 @@ AliITSUSimuParam& AliITSUSimuParam::operator=(const AliITSUSimuParam& source)
 AliITSUSimuParam::~AliITSUSimuParam() 
 {
   // destructor
-  delete[] fPixUpgBiasVoltage;
-  delete[] fPixUpgThresh;
-  delete[] fPixUpgThrSigma;
-  delete[] fPixUpgNoise;
-  delete[] fPixUpgBaseline;
+  delete[] fPixBiasVoltage;
+  delete[] fPixThresh;
+  delete[] fPixThrSigma;
+  delete[] fPixNoise;
+  delete[] fPixBaseline;
 }
 
 //________________________________________________________________________
@@ -197,18 +201,18 @@ void AliITSUSimuParam::Print(Option_t *) const
 }
 
 //_______________________________________________________________________
-Double_t AliITSUSimuParam::ApplyPixUpgBaselineAndNoise(UInt_t mod) const 
+Double_t AliITSUSimuParam::ApplyPixBaselineAndNoise(UInt_t mod) const 
 {
   // generate random noise 
   double base,noise;
-  if (mod>=fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    base = fPixUpgBaselineDef;
-    noise = fPixUpgNoiseDef;
+  if (mod>=fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    base = fPixBaselineDef;
+    noise = fPixNoiseDef;
   }
   else {
-    base  = fPixUpgBaseline[mod];
-    noise = fPixUpgNoise[mod];    
+    base  = fPixBaseline[mod];
+    noise = fPixNoise[mod];    
   }
   return base+noise*gRandom->Gaus();
 }
@@ -218,16 +222,16 @@ Double_t AliITSUSimuParam::CalcProbNoiseOverThreshold(UInt_t mod) const
 {
   // calculate probability of noise exceeding the threshold
   double base,noise,thresh;
-  if (mod>=fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    base   = fPixUpgBaselineDef;
-    noise  = fPixUpgNoiseDef;
-    thresh = fPixUpgThreshDef;
+  if (mod>=fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    base   = fPixBaselineDef;
+    noise  = fPixNoiseDef;
+    thresh = fPixThreshDef;
   }
   else {
-    base   = fPixUpgBaseline[mod];
-    noise  = fPixUpgNoise[mod];
-    thresh = fPixUpgThresh[mod];
+    base   = fPixBaseline[mod];
+    noise  = fPixNoise[mod];
+    thresh = fPixThresh[mod];
   }
   if (noise<1e-12) {
     if (base>thresh) return 1;
@@ -237,127 +241,127 @@ Double_t AliITSUSimuParam::CalcProbNoiseOverThreshold(UInt_t mod) const
 }
 
 //_______________________________________________________________________
-void AliITSUSimuParam::SetPixUpgThreshold(Double_t thresh, Double_t sigma, int mod)
+void AliITSUSimuParam::SetPixThreshold(Double_t thresh, Double_t sigma, int mod)
 {
   // set threshold params
   if (mod<0) {
-    fPixUpgThreshDef = thresh;
-    fPixUpgThrSigmaDef  = sigma;
-    for (int i=fNPixUpg;i--;) {
-      fPixUpgThresh[i] = thresh;
-      fPixUpgThrSigma[i]  = sigma;
+    fPixThreshDef = thresh;
+    fPixThrSigmaDef  = sigma;
+    for (int i=fNPix;i--;) {
+      fPixThresh[i] = thresh;
+      fPixThrSigma[i]  = sigma;
     }
   }
-  else if (mod>=(int)fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    fPixUpgThreshDef = thresh;
-    fPixUpgThrSigmaDef  = sigma;
+  else if (mod>=(int)fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    fPixThreshDef = thresh;
+    fPixThrSigmaDef  = sigma;
   }
   else {
-    fPixUpgThresh[mod] = thresh;
-    fPixUpgThrSigma[mod]  = sigma;
+    fPixThresh[mod] = thresh;
+    fPixThrSigma[mod]  = sigma;
   }
   //
 }
 
 //_______________________________________________________________________
-Double_t AliITSUSimuParam::GetPixUpgThreshold(UInt_t mod) const
+Double_t AliITSUSimuParam::GetPixThreshold(UInt_t mod) const
 {
   // obtain threshold
-  if (mod>=fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    return fPixUpgThreshDef;
+  if (mod>=fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    return fPixThreshDef;
   }
-  else return fPixUpgThresh[mod];
+  else return fPixThresh[mod];
 }
 
 //_______________________________________________________________________
-void AliITSUSimuParam::GetPixUpgThreshold(UInt_t mod, Double_t &thresh, Double_t &sigma) const
+void AliITSUSimuParam::GetPixThreshold(UInt_t mod, Double_t &thresh, Double_t &sigma) const
 {
   // obtain thresholds
-  if (mod>=fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    thresh = fPixUpgThreshDef;
-    sigma  = fPixUpgThrSigmaDef;
+  if (mod>=fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    thresh = fPixThreshDef;
+    sigma  = fPixThrSigmaDef;
   }
   else {
-    thresh = fPixUpgThresh[mod];
-    sigma  = fPixUpgThrSigma[mod];
+    thresh = fPixThresh[mod];
+    sigma  = fPixThrSigma[mod];
   }
 }
 
 //_______________________________________________________________________
-void AliITSUSimuParam::SetPixUpgBiasVoltage(Double_t val, int mod)
+void AliITSUSimuParam::SetPixBiasVoltage(Double_t val, int mod)
 {
   // set threshold params
   if (mod<0) {
-    fPixUpgBiasVoltageDef = val;
-    for (int i=fNPixUpg;i--;) fPixUpgBiasVoltage[i] = val;
+    fPixBiasVoltageDef = val;
+    for (int i=fNPix;i--;) fPixBiasVoltage[i] = val;
   }
-  else if (mod>=(int)fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    fPixUpgBiasVoltageDef = val;
+  else if (mod>=(int)fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    fPixBiasVoltageDef = val;
   }
-  else fPixUpgBiasVoltage[mod] = val;
+  else fPixBiasVoltage[mod] = val;
   //
 }
 
 //_______________________________________________________________________
-Double_t AliITSUSimuParam::GetPixUpgBiasVoltage(UInt_t mod) const
+Double_t AliITSUSimuParam::GetPixBiasVoltage(UInt_t mod) const
 {
   // obtain threshold
-  if (mod>=fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    return fPixUpgBiasVoltageDef;
+  if (mod>=fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    return fPixBiasVoltageDef;
   }
-  else return fPixUpgBiasVoltage[mod];
+  else return fPixBiasVoltage[mod];
 }
 
 //_______________________________________________________________________
-void AliITSUSimuParam::SetPixUpgNoise(Double_t noise, Double_t baseline, int mod)
+void AliITSUSimuParam::SetPixNoise(Double_t noise, Double_t baseline, int mod)
 {
   // set noise params
   if (mod<0) {
-    fPixUpgNoiseDef = noise;
-    fPixUpgBaselineDef  = baseline;
-    for (int i=fNPixUpg;i--;) {
-      fPixUpgNoise[i] = noise;
-      fPixUpgBaseline[i]  = baseline;
+    fPixNoiseDef = noise;
+    fPixBaselineDef  = baseline;
+    for (int i=fNPix;i--;) {
+      fPixNoise[i] = noise;
+      fPixBaseline[i]  = baseline;
     }
   }
-  else if (mod>=(int)fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    fPixUpgNoiseDef = noise;
-    fPixUpgBaselineDef  = baseline;
+  else if (mod>=(int)fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    fPixNoiseDef = noise;
+    fPixBaselineDef  = baseline;
   }
   else {
-    fPixUpgNoise[mod] = noise;
-    fPixUpgBaseline[mod]  = baseline;
+    fPixNoise[mod] = noise;
+    fPixBaseline[mod]  = baseline;
   }
   //
 }
 
 //_______________________________________________________________________
-void AliITSUSimuParam::GetPixUpgNoise(UInt_t mod, Double_t &noise, Double_t &baseline) const
+void AliITSUSimuParam::GetPixNoise(UInt_t mod, Double_t &noise, Double_t &baseline) const
 {
   // obtain noise
-  if (mod>=fNPixUpg) {
-    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
-    noise     = fPixUpgNoiseDef;
-    baseline  = fPixUpgBaselineDef;
+  if (mod>=fNPix) {
+    if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
+    noise     = fPixNoiseDef;
+    baseline  = fPixBaselineDef;
   }
   else {
-    noise     = fPixUpgNoise[mod];
-    baseline  = fPixUpgBaseline[mod];
+    noise     = fPixNoise[mod];
+    baseline  = fPixBaseline[mod];
   }
 }
 
 //_______________________________________________________________________
-void AliITSUSimuParam::SetPixUpgCouplingOption(UInt_t opt)
+void AliITSUSimuParam::SetPixCouplingOption(UInt_t opt)
 {
   // set coupling option
-  if (opt>=kMaxCouplingOptPixUpg) AliFatal(Form("Coupling option %d should be less than %d",opt,kMaxCouplingOptPixUpg));
-  fPixUpgCouplOpt = opt;
+  if (opt>=kMaxCouplingOptPix) AliFatal(Form("Coupling option %d should be less than %d",opt,kMaxCouplingOptPix));
+  fPixCouplOpt = opt;
 }
 
 
index 0bb7d8a..53b7ca8 100644 (file)
 class AliITSUSimuParam : public TObject {
 
  public:
-  enum {kOldCouplingPixUpg,kNewCouplingPixUpg,kMaxCouplingOptPixUpg};
+  enum {kOldCouplingPix,kNewCouplingPix,kMaxCouplingOptPix};
   //
   AliITSUSimuParam();
-  AliITSUSimuParam(UInt_t nPixUpg);
+  AliITSUSimuParam(UInt_t nPix);
   AliITSUSimuParam(const AliITSUSimuParam& simpar);
   // assignment operator 
   AliITSUSimuParam& operator=(const AliITSUSimuParam& source);
   ~AliITSUSimuParam();
 
-  Double_t ApplyPixUpgBaselineAndNoise(UInt_t mod) const;
+  Double_t ApplyPixBaselineAndNoise(UInt_t mod) const;
   Double_t CalcProbNoiseOverThreshold(UInt_t mod) const;
   //
-  void     SetPixUpgThreshold(Double_t thresh, Double_t sigma, int mod=-1);
-  void     GetPixUpgThreshold(UInt_t mod, Double_t& thresh, Double_t& sigma) const;
-  Double_t GetPixUpgThreshold(UInt_t mod)                                    const;
+  void     SetPixThreshold(Double_t thresh, Double_t sigma, int mod=-1);
+  void     SetPixMinElToAdd(Double_t nel)                                        {fPixMinElToAddDef = nel;}
+  void     GetPixThreshold(UInt_t mod, Double_t& thresh, Double_t& sigma) const;
+  Double_t GetPixThreshold(UInt_t mod)                                    const;
+  Double_t GetPixMinElToAdd()                                             const  {return fPixMinElToAddDef;}
   //
-  void     SetPixUpgNoise(Double_t noise, Double_t baseline, Int_t mod=-1);
-  void     GetPixUpgNoise(UInt_t mod,Double_t &noise, Double_t &baseline)    const;
+  void     SetPixNoise(Double_t noise, Double_t baseline, Int_t mod=-1);
+  void     GetPixNoise(UInt_t mod,Double_t &noise, Double_t &baseline)    const;
   //
-  void     SetPixUpgBiasVoltage(Double_t bias=18.182,Int_t mod=-1);
-  Double_t GetPixUpgBiasVoltage(UInt_t mod)                                  const;
+  void     SetPixBiasVoltage(Double_t bias=18.182,Int_t mod=-1);
+  Double_t GetPixBiasVoltage(UInt_t mod)                                  const;
 
  
   void     SetGeVToCharge(Double_t gc=fgkNcompsDefault)                             {fGeVcharge = gc;}
@@ -48,24 +50,24 @@ class AliITSUSimuParam : public TObject {
   void     SetDistanceOverVoltage(Double_t dv=fgkDOverVDefault)                     {fDOverV = dv;}
   Double_t GetDistanceOverVoltage()                                          const  {return fDOverV;}
   //
-  void     SetPixUpgCouplingOption(UInt_t opt);
-  UInt_t   GetPixUpgCouplingOption()                                         const  {return fPixUpgCouplOpt;}
+  void     SetPixCouplingOption(UInt_t opt);
+  UInt_t   GetPixCouplingOption()                                         const  {return fPixCouplOpt;}
 
-  void     SetPixUpgCouplingParam(Double_t col, Double_t row)                       {fPixUpgCouplCol = col; fPixUpgCouplRow = row;}
-  void     GetPixUpgCouplingParam(Double_t &col, Double_t &row)              const  {col = fPixUpgCouplCol; row = fPixUpgCouplRow;}
+  void     SetPixCouplingParam(Double_t col, Double_t row)                       {fPixCouplCol = col; fPixCouplRow = row;}
+  void     GetPixCouplingParam(Double_t &col, Double_t &row)              const  {col = fPixCouplCol; row = fPixCouplRow;}
 
-  void     SetPixUpgSigmaDiffusionAsymmetry(Double_t ecc)                           {fPixUpgEccDiff=ecc;}   
-  void     GetPixUpgSigmaDiffusionAsymmetry(Double_t &ecc)                   const  {ecc=fPixUpgEccDiff;}
+  void     SetPixSigmaDiffusionAsymmetry(Double_t ecc)                           {fPixEccDiff=ecc;}   
+  void     GetPixSigmaDiffusionAsymmetry(Double_t &ecc)                   const  {ecc=fPixEccDiff;}
 
-  void     SetPixUpgLorentzDrift(Bool_t ison)                                       {fPixUpgLorentzDrift=ison;}
-  Bool_t   GetPixUpgLorentzDrift()                                           const  {return fPixUpgLorentzDrift;}
-  void     SetPixUpgLorentzHoleWeight(Double_t weight)                               {fPixUpgLorentzHoleWeight=weight;}
-  Double_t GetPixUpgLorentzHoleWeight()                                      const  {return fPixUpgLorentzHoleWeight;}
+  void     SetPixLorentzDrift(Bool_t ison)                                       {fPixLorentzDrift=ison;}
+  Bool_t   GetPixLorentzDrift()                                           const  {return fPixLorentzDrift;}
+  void     SetPixLorentzHoleWeight(Double_t weight)                               {fPixLorentzHoleWeight=weight;}
+  Double_t GetPixLorentzHoleWeight()                                      const  {return fPixLorentzHoleWeight;}
   
-  void     SetPixUpgAddNoisyFlag(Bool_t value)                                      {fPixUpgAddNoisyFlag = value;}
-  Bool_t   GetPixUpgAddNoisyFlag()                                           const  {return fPixUpgAddNoisyFlag;}
-  void     SetPixUpgRemoveDeadFlag(Bool_t value)                                    {fPixUpgRemoveDeadFlag = value;}
-  Bool_t   GetPixUpgRemoveDeadFlag()                                         const  {return fPixUpgRemoveDeadFlag;}
+  void     SetPixAddNoisyFlag(Bool_t value)                                      {fPixAddNoisyFlag = value;}
+  Bool_t   GetPixAddNoisyFlag()                                           const  {return fPixAddNoisyFlag;}
+  void     SetPixRemoveDeadFlag(Bool_t value)                                    {fPixRemoveDeadFlag = value;}
+  Bool_t   GetPixRemoveDeadFlag()                                         const  {return fPixRemoveDeadFlag;}
   //
   Double_t LorentzAngleElectron(Double_t bz)                                 const;
   Double_t LorentzAngleHole(Double_t bz)                                     const;
@@ -81,14 +83,15 @@ class AliITSUSimuParam : public TObject {
   //
  protected:
 
-  static const Double_t fgkPixUpgBiasVoltageDefault;//default for fPixUpgBiasVoltage
-  static const Double_t fgkPixUpgThreshDefault; //default for fThresh
-  static const Double_t fgkPixUpgThrSigmaDefault; //default for fSigma
-  static const Double_t fgkPixUpgCouplColDefault; //default for fPixUpgCouplCol
-  static const Double_t fgkPixUpgCouplRowDefault; //default for fPixUpgCouplRow
-  static const Double_t fgkPixUpgEccDiffDefault;//default for fPixUpgEccDiff
-  static const Double_t fgkPixUpgLorentzHoleWeightDefault;//default for fPixUpgLorentzHoleWeight
-  static const UInt_t   fgkPixUpgCouplingOptDefault;  // type of pixel Coupling (old or new)
+  static const Double_t fgkPixBiasVoltageDefault;//default for fPixBiasVoltage
+  static const Double_t fgkPixThreshDefault; //default for fThresh
+  static const Double_t fgkPixMinElToAddDefault; // default min number of electrons to add to sdigit
+  static const Double_t fgkPixThrSigmaDefault; //default for fSigma
+  static const Double_t fgkPixCouplColDefault; //default for fPixCouplCol
+  static const Double_t fgkPixCouplRowDefault; //default for fPixCouplRow
+  static const Double_t fgkPixEccDiffDefault;//default for fPixEccDiff
+  static const Double_t fgkPixLorentzHoleWeightDefault;//default for fPixLorentzHoleWeight
+  static const UInt_t   fgkPixCouplingOptDefault;  // type of pixel Coupling (old or new)
   static const Double_t fgkDOverVDefault;             // default distance over voltage 
   static const Double_t fgkGeVtoChargeDefault;        // default energy to ionize (free an electron) in GeV
   static const Double_t fgkTDefault;                  // default temperature
@@ -102,29 +105,30 @@ class AliITSUSimuParam : public TObject {
   Double_t   fDOverV;             // The parameter d/v where d is the disance over which the the potential v is applied d/v [cm/volts]
   Double_t   fT;                  // The temperature of the Si in Degree K.
   //
-  UInt_t     fNPixUpg;            // number of PixUpg type detectors
-  UInt_t     fPixUpgCouplOpt;     // PixUpg Coupling Option
-  Double_t   fPixUpgCouplCol;     // PixUpg Coupling parameter along the cols
-  Double_t   fPixUpgCouplRow;     // PixUpg Coupling parameter along the rows
-  Double_t   fPixUpgEccDiff;      // Eccentricity (i.e. asymmetry parameter) in the  Gaussian diffusion for PixUpg  
-  Bool_t     fPixUpgLorentzDrift;     // Flag to decide whether to simulate the Lorentz Drift or not in PixUpg
-  Double_t   fPixUpgLorentzHoleWeight;// Lorentz Angle is computed for PixUpg as average of Hole and Electron
+  UInt_t     fNPix;            // number of Pix type detectors
+  UInt_t     fPixCouplOpt;     // Pix Coupling Option
+  Double_t   fPixCouplCol;     // Pix Coupling parameter along the cols
+  Double_t   fPixCouplRow;     // Pix Coupling parameter along the rows
+  Double_t   fPixEccDiff;      // Eccentricity (i.e. asymmetry parameter) in the  Gaussian diffusion for Pix  
+  Bool_t     fPixLorentzDrift;     // Flag to decide whether to simulate the Lorentz Drift or not in Pix
+  Double_t   fPixLorentzHoleWeight;// Lorentz Angle is computed for Pix as average of Hole and Electron
   //                                    this parameter gives the relative weights between the two
-  Bool_t     fPixUpgAddNoisyFlag;     // Flag saying whether noisy pixels should be added to digits
-  Bool_t     fPixUpgRemoveDeadFlag;   // Flag saying whether dead pixels should be removed from digits
-  //
-  Double_t   fPixUpgThreshDef;      // PixUpg Threshold value
-  Double_t   fPixUpgThrSigmaDef;    // PixUpg Threshold fluctuation
-  Double_t   fPixUpgBiasVoltageDef; // Bias Voltage for the PixUpg
-  Double_t   fPixUpgNoiseDef;       // PixUpg electronic noise: sigma
-  Double_t   fPixUpgBaselineDef;    // PixUpg electronic noise: baseline
-  //
-  Double_t*  fPixUpgThresh;      //[fNPixUpg] PixUpg Threshold value
-  Double_t*  fPixUpgThrSigma;    //[fNPixUpg] PixUpg Threshold fluctuation
-  Double_t*  fPixUpgBiasVoltage; //[fNPixUpg] Bias Voltage for the PixUpg
-  Double_t*  fPixUpgSigma;       //[fNPixUpg] PixUpg threshold fluctuations spread
-  Double_t*  fPixUpgNoise;       //[fNPixUpg] PixUpg electronic noise: sigma
-  Double_t*  fPixUpgBaseline;    //[fNPixUpg] PixUpg electronic noise: baseline
+  Bool_t     fPixAddNoisyFlag;     // Flag saying whether noisy pixels should be added to digits
+  Bool_t     fPixRemoveDeadFlag;   // Flag saying whether dead pixels should be removed from digits
+  //
+  Double_t   fPixThreshDef;      // Pix Threshold value
+  Double_t   fPixThrSigmaDef;    // Pix Threshold fluctuation
+  Double_t   fPixBiasVoltageDef; // Bias Voltage for the Pix
+  Double_t   fPixNoiseDef;       // Pix electronic noise: sigma
+  Double_t   fPixBaselineDef;    // Pix electronic noise: baseline
+  Double_t   fPixMinElToAddDef;  // min number of electrons to add
+  //
+  Double_t*  fPixThresh;      //[fNPix] Pix Threshold value
+  Double_t*  fPixThrSigma;    //[fNPix] Pix Threshold fluctuation
+  Double_t*  fPixBiasVoltage; //[fNPix] Bias Voltage for the Pix
+  Double_t*  fPixSigma;       //[fNPix] Pix threshold fluctuations spread
+  Double_t*  fPixNoise;       //[fNPix] Pix electronic noise: sigma
+  Double_t*  fPixBaseline;    //[fNPix] Pix electronic noise: baseline
   //
 
   ClassDef(AliITSUSimuParam,1);  // ITSU simulataion params
index 3e6eae9..b5a0619 100644 (file)
@@ -113,7 +113,7 @@ AliITSUSimulationPix& AliITSUSimulationPix::operator=(const AliITSUSimulationPix
 void AliITSUSimulationPix::Init()
 {
   // Initilization
-  if (fSimuParam->GetPixUpgLorentzDrift()) SetTanLorAngle(fSimuParam->GetPixUpgLorentzHoleWeight());
+  if (fSimuParam->GetPixLorentzDrift()) SetTanLorAngle(fSimuParam->GetPixLorentzHoleWeight());
 }
 
 //______________________________________________________________________
@@ -157,8 +157,8 @@ void AliITSUSimulationPix::SDigitiseModule(AliITSUModule *mod, Int_t /*mask*/,In
   InitSimulationModule(mod->GetIndex(), event, seg );
   // Hits2SDigits(mod);
   Hits2SDigitsFast(mod);
-  if (fSimuParam->GetPixUpgAddNoisyFlag())   AddNoisyPixels();
-  if (fSimuParam->GetPixUpgRemoveDeadFlag()) RemoveDeadPixels();  
+  if (fSimuParam->GetPixAddNoisyFlag())   AddNoisyPixels();
+  if (fSimuParam->GetPixRemoveDeadFlag()) RemoveDeadPixels();  
   WriteSDigits();
   ClearMap();
 }
@@ -198,8 +198,8 @@ void AliITSUSimulationPix::DigitiseModule(AliITSUModule *mod,Int_t /*mask*/, Int
   // Hits2SDigits(mod);
   Hits2SDigitsFast(mod);
   //
-  if (fSimuParam->GetPixUpgAddNoisyFlag())   AddNoisyPixels();
-  if (fSimuParam->GetPixUpgRemoveDeadFlag()) RemoveDeadPixels();
+  if (fSimuParam->GetPixAddNoisyFlag())   AddNoisyPixels();
+  if (fSimuParam->GetPixRemoveDeadFlag()) RemoveDeadPixels();
   FrompListToDigits();
   ClearMap();
 }
@@ -216,10 +216,11 @@ void AliITSUSimulationPix::Hits2SDigits(AliITSUModule *mod)
   //
   Int_t h,ix,iz,i;
   Int_t idtrack;
+  Float_t x,y,z;  // keep coordinates float (required by AliSegmentation)
   Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0,ld=0.0;
-  Double_t x,y,z,t,tp,st,dt=0.2,el,sig,sigx,sigz,fda;
+  Double_t t,tp,st,dt=0.2,el,sig,sigx,sigz,fda;
   Double_t thick = 0.5*kmictocm*fSeg->Dy();  // Half Thickness
-  fSimuParam->GetPixUpgSigmaDiffusionAsymmetry(fda);
+  fSimuParam->GetPixSigmaDiffusionAsymmetry(fda);
   //
   for (h=0;h<nhits;h++) {
     if (fStrobe && 
@@ -246,7 +247,7 @@ void AliITSUSimulationPix::Hits2SDigits(AliITSUModule *mod)
        sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y)); 
        sigx=sig;
        sigz=sig*fda;
-       if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+       if (fSimuParam->GetPixLorentzDrift()) ld=(y+thick)*fTanLorAng;
        SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
       } // end for t
     } else { // st == 0.0 deposit it at this point
@@ -258,7 +259,7 @@ void AliITSUSimulationPix::Hits2SDigits(AliITSUModule *mod)
       sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y));
       sigx = sig;
       sigz = sig*fda;
-      if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+      if (fSimuParam->GetPixLorentzDrift()) ld=(y+thick)*fTanLorAng;
       SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
     } // end if st>0.0    
   } // Loop over all hits h
@@ -266,15 +267,15 @@ void AliITSUSimulationPix::Hits2SDigits(AliITSUModule *mod)
   // Coupling
   int nd = fSensMap->GetEntriesUnsorted(); // use unsorted access when possible, since it is faster
   AliITSUSDigit* dg = 0;
-  switch (fSimuParam->GetPixUpgCouplingOption()) {
-  case AliITSUSimuParam::kNewCouplingPixUpg :
+  switch (fSimuParam->GetPixCouplingOption()) {
+  case AliITSUSimuParam::kNewCouplingPix :
     for (i=nd;i--;) {
       dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
       if (fSensMap->IsDisabled(dg)) continue;
       SetCoupling(dg,idtrack,h);
     } 
     break;
-  case AliITSUSimuParam::kOldCouplingPixUpg:
+  case AliITSUSimuParam::kOldCouplingPix:
     for (i=nd;i--;) {
       dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
       if (fSensMap->IsDisabled(dg)) continue;
@@ -285,7 +286,7 @@ void AliITSUSimulationPix::Hits2SDigits(AliITSUModule *mod)
     break;
     
   } // end switch
-  if (GetDebug(2)) Info("Hits2SDigits","Finished fCoupling=%d",fSimuParam->GetPixUpgCouplingOption());
+  if (GetDebug(2)) AliInfo(Form("Finished fCoupling=%d",fSimuParam->GetPixCouplingOption()));
 }
 
 //______________________________________________________________________
@@ -314,10 +315,11 @@ void AliITSUSimulationPix::Hits2SDigitsFast(AliITSUModule *mod)
   //
   Int_t h,ix,iz,i;
   Int_t idtrack;
-  Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0,ld=0.0;
-  Double_t x,y,z,t,st,el,sig,sigx,sigz,fda;
+  Float_t x,y,z; // keep coordinates float (required by AliSegmentation)
+  Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0; 
+  Double_t t,st,el,sig,sigx,sigz,fda,de=0.0,ld=0.0;
   Double_t thick = 0.5*kmictocm*fSeg->Dy();  // Half thickness
-  fSimuParam->GetPixUpgSigmaDiffusionAsymmetry(fda);
+  fSimuParam->GetPixSigmaDiffusionAsymmetry(fda);
   //
   for (h=0;h<nhits;h++) {
     // Check if the hit is inside readout window
@@ -339,7 +341,7 @@ void AliITSUSimulationPix::Hits2SDigitsFast(AliITSUModule *mod)
        sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y));
        sigx=sig;
        sigz=sig*fda;
-       if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+       if (fSimuParam->GetPixLorentzDrift()) ld=(y+thick)*fTanLorAng;
        SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
        //                cout << "sigx sigz " << sigx << " " << sigz << endl; // dom
       } // end for i // End Integrate over t
@@ -352,7 +354,7 @@ void AliITSUSimulationPix::Hits2SDigitsFast(AliITSUModule *mod)
       sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y));
       sigx=sig;
       sigz=sig*fda;
-      if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+      if (fSimuParam->GetPixLorentzDrift()) ld=(y+thick)*fTanLorAng;
       SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
     } // end if st>0.0
     
@@ -361,14 +363,14 @@ void AliITSUSimulationPix::Hits2SDigitsFast(AliITSUModule *mod)
   // Coupling
   int nd = fSensMap->GetEntriesUnsorted(); // use unsorted access when possible, since it is faster
   AliITSUSDigit* dg = 0;
-  switch (fSimuParam->GetPixUpgCouplingOption()) {
-  case AliITSUSimuParam::kNewCouplingPixUpg :
+  switch (fSimuParam->GetPixCouplingOption()) {
+  case AliITSUSimuParam::kNewCouplingPix :
     for (i=nd;i--;) {
       dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
       if (fSensMap->IsDisabled(dg)) continue;
       SetCoupling(dg,idtrack,h);
     } 
-  case AliITSUSimuParam::kOldCouplingPixUpg:
+  case AliITSUSimuParam::kOldCouplingPix:
     for (i=nd;i--;) {
       dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
       if (fSensMap->IsDisabled(dg)) continue;
@@ -378,7 +380,7 @@ void AliITSUSimulationPix::Hits2SDigitsFast(AliITSUModule *mod)
   default:
     break;
   } // end switch
-  if (GetDebug(2))Info("Hits2SDigits","Finished fCoupling=%d",fSimuParam->GetPixUpgCouplingOption());
+  if (GetDebug(2)) AliInfo(Form("Finished fCoupling=%d",fSimuParam->GetPixCouplingOption()));
 }
 
 //______________________________________________________________________
@@ -390,7 +392,7 @@ void AliITSUSimulationPix::SpreadCharge(Double_t x0,Double_t z0,
    // Spreads the charge over neighboring cells. Assume charge is distributed
    // as charge(x,z) = (el/2*pi*sig*sig)*exp(-arg)
    // arg=((x-x0)*(x-x0)/2*sig*sig)+((z-z0*z-z0)/2*sig*sig)
-   // if fSimuParam->GetPixUpgLorentzDrift()=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
+   // if fSimuParam->GetPixLorentzDrift()=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
    // Defined this way, the integral over all x and z is el.
    // Inputs:
    //    Double_t x0   x position of point where charge is liberated
@@ -411,17 +413,15 @@ void AliITSUSimulationPix::SpreadCharge(Double_t x0,Double_t z0,
    const Double_t kRoot2 = 1.414213562; // Sqrt(2).
    const Double_t kmictocm = 1.0e-4; // convert microns to cm.
    Int_t ix,iz,ixs,ixe,izs,ize;
-   Float_t x,z;
-   Double_t x1,x2,z1,z2,s,sp;
+   Float_t x,z;  // keep coordinates float (required by AliSegmentation)
+   Double_t s,sp,x1,x2,z1,z2; 
    //
-   if (GetDebug(4)) Info("SpreadCharge","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sig=%e,t=%d,i=%d)",x0,z0,ix0,iz0,el,sig,t,hi);
+   if (GetDebug(2)) AliInfo(Form("(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sig=%e,t=%d,i=%d)",x0,z0,ix0,iz0,el,sig,t,hi));
    if (sig<=0.0) { // if sig<=0 No diffusion to simulate.
      UpdateMapSignal(iz0,ix0,t,hi,el);
-     if (GetDebug(2)) cout << "sig<=0.0=" << sig << endl; // end if GetDebug
      return;
    } // end if
    sp = 1.0/(sig*kRoot2);
-   if (GetDebug(2)) cout << "sig=" << sig << " sp=" << sp << endl; // end if GetDebug
    ixs = TMath::Max(-knx+ix0,0);
    ixe = TMath::Min(knx+ix0,fSeg->Npx()-1);
    izs = TMath::Max(-knz+iz0,0);
@@ -429,17 +429,19 @@ void AliITSUSimulationPix::SpreadCharge(Double_t x0,Double_t z0,
    for (ix=ixs;ix<=ixe;ix++) 
      for (iz=izs;iz<=ize;iz++) {
        fSeg->DetToLocal(ix,iz,x,z); // pixel center
+       double dxi = 0.5*kmictocm*fSeg->Dpx(ix);
+       double dzi = 0.5*kmictocm*fSeg->Dpz(iz);
        x1  = x;
        z1  = z;
-       x2  = x1 + 0.5*kmictocm*fSeg->Dpx(ix); // Upper
-       x1 -= 0.5*kmictocm*fSeg->Dpx(ix);  // Lower
-       z2  = z1 + 0.5*kmictocm*fSeg->Dpz(iz); // Upper
-       z1 -= 0.5*kmictocm*fSeg->Dpz(iz);  // Lower
+       x2  = x1 + dxi; // Upper
+       x1 -= dxi;  // Lower
+       z2  = z1 + dzi; // Upper
+       z1 -= dzi;  // Lower
        x1 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
        x2 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
        z1 -= z0; // Distance from where track traveled
        z2 -= z0; // Distance from where track traveled
-       s   = 0.25; // Correction based on definision of Erfc
+       s   = el*0.25; // Correction based on definision of Erfc
        s  *= AliMathBase::ErfcFast(sp*x1) - AliMathBase::ErfcFast(sp*x2);
        if (GetDebug(3)) {
         cout <<"el="<<el<<" ix0="<<ix0<<" ix="<<ix<<" x0="<<x<<
@@ -448,21 +450,21 @@ void AliITSUSimulationPix::SpreadCharge(Double_t x0,Double_t z0,
        } // end if GetDebug
        s  *= AliMathBase::ErfcFast(sp*z1) - AliMathBase::ErfcFast(sp*z2);
        if (GetDebug(3)) cout<<" sp*z1="<<sp*z1<<" sp*z2="<<sp*z2<<" s="<<s<< endl; // end if GetDebug
-       UpdateMapSignal(iz,ix,t,hi,s*el);
+       if (s>fSimuParam->GetPixMinElToAdd()) UpdateMapSignal(iz,ix,t,hi,s);
      } // end for ix, iz
    //
 }
 
 //______________________________________________________________________
 void AliITSUSimulationPix::SpreadChargeAsym(Double_t x0,Double_t z0,
-                                             Int_t ix0,Int_t iz0,
-                                             Double_t el,Double_t sigx,Double_t sigz,
-                                             Double_t ld,Int_t t,Int_t hi)
+                                           Int_t ix0,Int_t iz0,
+                                           Double_t el,Double_t sigx,Double_t sigz,
+                                           Double_t ld,Int_t t,Int_t hi)
 {
   // Spreads the charge over neighboring cells. Assume charge is distributed
   // as charge(x,z) = (el/2*pi*sigx*sigz)*exp(-arg)
   // arg=((x-x0)*(x-x0)/2*sigx*sigx)+((z-z0*z-z0)/2*sigz*sigz)
-  // if fSimuParam->GetPixUpgLorentzDrift()=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
+  // if fSimuParam->GetPixLorentzDrift()=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
   // Defined this way, the integral over all x and z is el.
   // Inputs:
   //    Double_t x0   x position of point where charge is liberated
@@ -471,7 +473,7 @@ void AliITSUSimulationPix::SpreadChargeAsym(Double_t x0,Double_t z0,
   //    Int_t    iz0  columb of cell corresponding to point z0
   //    Double_t el   number of electrons liberated in this step
   //    Double_t sigx Sigma difusion along x for this step (y0 dependent)
-  //    Double_t sigz Sigma difusion along z for this step (y0 dependent)
+  //    Double_t sigz Sigma difusion along z for this step (z0 dependent)
   //    Double_t ld   lorentz drift in x for this stip (y0 dependent)
   //    Int_t    t    track number
   //    Int_t    ti   hit track index number
@@ -480,14 +482,14 @@ void AliITSUSimulationPix::SpreadChargeAsym(Double_t x0,Double_t z0,
   //     none.
   // Return:
   //     none.
-  const Int_t knx = 3,knz = 2;
+  const Int_t knx = 3,knz = 3; // RS: TO TUNE
   const Double_t kRoot2 = 1.414213562; // Sqrt(2).
   const Double_t kmictocm = 1.0e-4; // convert microns to cm.
   Int_t ix,iz,ixs,ixe,izs,ize;
-  Float_t x,z;
-  Double_t x1,x2,z1,z2,s,spx,spz;
+  Float_t x,z;   // keep coordinates float (required by AliSegmentation)
+  Double_t s,spx,spz,x1,x2,z1,z2; 
   //
-  if (GetDebug(4)) Info("SpreadChargeAsym","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sigx=%e, sigz=%e, t=%d,i=%d)",x0,z0,ix0,iz0,el,sigx,sigz,t,hi);
+  if (GetDebug(2)) AliInfo(Form("SpreadChargeAsym","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sigx=%e, sigz=%e, t=%d,i=%d,ld=%e)",x0,z0,ix0,iz0,el,sigx,sigz,t,hi,ld));
   if (sigx<=0.0 || sigz<=0.0) { // if sig<=0 No diffusion to simulate.
     UpdateMapSignal(iz0,ix0,t,hi,el);
     if (GetDebug(2)) {
@@ -509,22 +511,24 @@ void AliITSUSimulationPix::SpreadChargeAsym(Double_t x0,Double_t z0,
   for (ix=ixs;ix<=ixe;ix++) 
     for (iz=izs;iz<=ize;iz++) {
       fSeg->DetToLocal(ix,iz,x,z); // pixel center
+      double dxi = 0.5*kmictocm*fSeg->Dpx(ix);
+      double dzi = 0.5*kmictocm*fSeg->Dpz(iz);
       x1  = x;
       z1  = z;
-      x2  = x1 + 0.5*kmictocm*fSeg->Dpx(ix); // Upper
-      x1 -= 0.5*kmictocm*fSeg->Dpx(ix);  // Lower
-      z2  = z1 + 0.5*kmictocm*fSeg->Dpz(iz); // Upper
-      z1 -= 0.5*kmictocm*fSeg->Dpz(iz);  // Lower
+      x2  = x1 + dxi; // Upper
+      x1 -= dxi;      // Lower
+      z2  = z1 + dzi; // Upper
+      z1 -= dzi;      // Lower
       x1 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
       x2 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
       z1 -= z0; // Distance from where track traveled
       z2 -= z0; // Distance from where track traveled
-      s   = 0.25; // Correction based on definision of Erfc
+      s   = el*0.25; // Correction based on definision of Erfc
       s  *= AliMathBase::ErfcFast(spx*x1) - AliMathBase::ErfcFast(spx*x2);
       if (GetDebug(3)) cout <<"el="<<el<<" ix0="<<ix0<<" ix="<<ix<<" x0="<<x<<" iz0="<<iz0<<" iz="<<iz<<" z0="<<z<<" spx*x1="<<spx*x1<<" spx*x2="<<spx*x2<<" s="<<s; // end if GetDebug
       s  *= AliMathBase::ErfcFast(spz*z1) - AliMathBase::ErfcFast(spz*z2);
       if (GetDebug(3)) cout<<" spz*z1="<<spz*z1<<" spz*z2="<<spz*z2<<" s="<<s<< endl; // end if GetDebug
-      UpdateMapSignal(iz,ix,t,hi,s*el);
+      if (s>fSimuParam->GetPixMinElToAdd()) UpdateMapSignal(iz,ix,t,hi,s);
     } // end for ix, iz
   //
 }
@@ -567,7 +571,7 @@ void AliITSUSimulationPix::AddNoisyPixels()
   AliITSUCalibrationPix* calObj = (AliITSUCalibrationPix*) GetCalibNoisy();
   if (!calObj) return;
   for (Int_t i=calObj->GetNrBad(); i--;) UpdateMapNoise(calObj->GetBadColAt(i), calObj->GetBadRowAt(i), 
-                                                       10*fSimuParam->GetPixUpgThreshold(fModule));
+                                                       10*fSimuParam->GetPixThreshold(fModule));
   //
 }
 
@@ -598,8 +602,8 @@ void AliITSUSimulationPix::FrompListToDigits()
   Int_t prevID=0,curID=0;
   TArrayI ordSampleInd(100),ordSample(100);
   //
-  double probNoisy,noiseSig,noiseMean,thresh = fSimuParam->GetPixUpgThreshold(fModule);
-  fSimuParam->GetPixUpgNoise(fModule, noiseSig, noiseMean);
+  double probNoisy,noiseSig,noiseMean,thresh = fSimuParam->GetPixThreshold(fModule);
+  fSimuParam->GetPixNoise(fModule, noiseSig, noiseMean);
   probNoisy = AliITSUSimuParam::CalcProbNoiseOverThreshold(noiseMean,noiseSig,thresh); // prob. to have noise above threshold
   //
   for (int i=0;i<nsd;i++) {
@@ -612,7 +616,7 @@ void AliITSUSimulationPix::FrompListToDigits()
       prevID = curID+1;
     }
     //
-    if ((sig=sd->GetSumSignal())<=fSimuParam->GetPixUpgThreshold(fModule)) continue;
+    if ((sig=sd->GetSumSignal())<=fSimuParam->GetPixThreshold(fModule)) continue;
     if (TMath::Abs(sig)>2147483647.0) { //RS?
       //PH 2147483647 is the max. integer
       //PH This apparently is a problem which needs investigation
@@ -668,7 +672,7 @@ Int_t AliITSUSimulationPix::CreateNoisyDigits(Int_t minID,Int_t maxID,double pro
       dig.SetHit(k,-1);
     }
     aliITS->AddSimDigit(AliITSUGeomTGeo::kDetTypePix,&dig);
-    AliInfo(Form("Add noisy pixel %d(%d/%d) Noise=%d",ordV[ordI[j]],iz,ix,dig.GetSignalPix()));
+    if (GetDebug(2)) AliInfo(Form("Add noisy pixel %d(%d/%d) Noise=%d",ordV[ordI[j]],iz,ix,dig.GetSignalPix()));
   }
   return ncand;
 }
@@ -703,11 +707,11 @@ void AliITSUSimulationPix::SetCoupling(AliITSUSDigit* old, Int_t ntrack, Int_t i
   Double_t xr=0.;
   //
   fSensMap->GetMapIndex(old->GetUniqueID(),col,row);
-  fSimuParam->GetPixUpgCouplingParam(couplC,couplR);
-  if (GetDebug(3)) Info("SetCoupling","(col=%d,row=%d,ntrack=%d,idhit=%d) "
-                       "Calling SetCoupling couplC=%e couplR=%e",
-                       col,row,ntrack,idhit,couplC,couplR);
+  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));
   pulse2 = pulse1 = old->GetSignal();
+  if (pulse1<fSimuParam->GetPixMinElToAdd()) return; // too small signal
   for (Int_t isign=-1;isign<=1;isign+=2) {
     //
     // loop in col direction
@@ -752,25 +756,25 @@ void AliITSUSimulationPix::SetCouplingOld(AliITSUSDigit* old, Int_t ntrack,Int_t
   Double_t couplR=0.0,couplC=0.0;
   //
   fSensMap->GetMapIndex(old->GetUniqueID(),col,row);
-  fSimuParam->GetPixUpgCouplingParam(couplC,couplR);
-  if (GetDebug(3)) Info("SetCouplingOld","(col=%d,row=%d,ntrack=%d,idhit=%d) "
-                        "Calling SetCoupling couplC=%e couplR=%e",
-                        col,row,ntrack,idhit,couplC,couplR);
-  //
-  for (Int_t isign=-1;isign<=1;isign+=2) {// loop in col direction
-    pulse2 = pulse1 = old->GetSignal();
-    //
-    int j1 = int(col)+isign;
-    pulse1 *= couplC;
-    if ((j1<0)||(j1>fSeg->Npz()-1)||(pulse1<fSimuParam->GetPixUpgThreshold(fModule))) pulse1 = old->GetSignal();
-    else UpdateMapSignal(UInt_t(j1),row,ntrack,idhit,pulse1);
-
-    // loop in row direction
-    int j2 = int(row) + isign;
-    pulse2 *= couplR;
-    if ((j2<0)||(j2>(fSeg->Npx()-1))||(pulse2<fSimuParam->GetPixUpgThreshold(fModule))) pulse2 = old->GetSignal();
-    else UpdateMapSignal(col,UInt_t(j2),ntrack,idhit,pulse2);
-  } // for isign
+  fSimuParam->GetPixCouplingParam(couplC,couplR);
+  if (GetDebug(3)) AliInfo(Form("(col=%d,row=%d,ntrack=%d,idhit=%d)  couplC=%e couplR=%e",
+                               col,row,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
+   pulse2 = pulse1 = old->GetSignal();
+   //
+   int j1 = int(col)+isign;
+   pulse1 *= couplC;    
+   if ((j1<0)||(j1>fSeg->Npz()-1)||(pulse1<fSimuParam->GetPixThreshold(fModule))) pulse1 = old->GetSignal();
+   else UpdateMapSignal(UInt_t(j1),row,ntrack,idhit,pulse1);
+   
+   // loop in row direction
+   int j2 = int(row) + isign;
+   pulse2 *= couplR;
+   if ((j2<0)||(j2>(fSeg->Npx()-1))||(pulse2<fSimuParam->GetPixThreshold(fModule))) pulse2 = old->GetSignal();
+   else UpdateMapSignal(col,UInt_t(j2),ntrack,idhit,pulse2);
+ } // for isign
 }
 
 //______________________________________________________________________
index b84b81c..b03d72b 100644 (file)
@@ -8,7 +8,7 @@
 // Simulation class for upgrade pixels                    //
 ////////////////////////////////////////////////////////////
 
-#include "TObjArray.h"
+#include <TObjArray.h>
 #include "AliITSUSimulation.h"
 #include "AliITSUSegmentationPix.h"