Implemented possibility of synchronized, layer-staggered or fully randomized pixel...
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 23 Apr 2013 16:51:13 +0000 (16:51 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 23 Apr 2013 16:51:13 +0000 (16:51 +0000)
The optional AliITSUSimuParam::fLrROCycleShift[nlayers] array is interpreted as:
1) abs(kROShifts)<1: the modules of the layer are synchronized, the layer
   phase is set to kROShifts*ROCycleLength of the modules of this layer
2) abs(kROShifts)>1: each module within the layer will have random phase within its ROCycleLength
For kROShifts=0 or if the fLrROCycleShift is not initialized, all modules are synchronized and readout
starts at time=0.
The deme MakeITSUSimuParam.C is updated to create staggering by 0.5 cycle between lrs (0,1,2),(3,4) and (5,6)
(see kROShifts array)

Some reshufling of variables, double->float change.

ITS/UPGRADE/AliITSU.cxx
ITS/UPGRADE/AliITSUSimuParam.cxx
ITS/UPGRADE/AliITSUSimuParam.h
ITS/UPGRADE/AliITSUSimulation.cxx
ITS/UPGRADE/AliITSUSimulation.h
ITS/UPGRADE/AliITSUSimulationPix.cxx
ITS/UPGRADE/AliITSUSimulationPix.h
ITS/UPGRADE/testITSU/MakeITSUSimuParam.C
ITS/UPGRADE/testITSU/itsupcdb.tar.gz

index c587b9c..34876d6 100644 (file)
@@ -75,6 +75,7 @@ the AliITS class.
 #include <TString.h>
 #include <TTree.h>
 #include <TVirtualMC.h>
+#include <TMath.h>
 #include "AliDetector.h"
 #include "AliITSU.h"
 #include "AliITSLoader.h"
@@ -101,6 +102,8 @@ the AliITS class.
 #include "AliCDBManager.h" // tmp! Later the simuparam should be loaded centrally
 #include "AliCDBEntry.h"
 
+using namespace TMath;
+
 ClassImp(AliITSU)
 
 //______________________________________________________________________
@@ -505,14 +508,27 @@ void AliITSU::Hits2SDigits(Int_t evNumber,Int_t bgrev,Option_t *option,const cha
   FillModules(bgrev,option,filename);
   //
   Int_t nmodules = fGeomTGeo->GetNModules();
-  
+  int prevLr = -1;
+  float roPhase=0; // synchronysation type between layers/modules
+  Bool_t randomyzeModules = kFALSE; // do we need to randomize layers
+  //
   for(int module=0;module<nmodules;module++) {
     int lr = fGeomTGeo->GetLayer(module);
     AliITSUSimulation* sim = GetSimulationModel(lr);
     sim->InitSimulationModule(GetModule(module),evNumber/*,gAlice->GetEvNumber()*/,GetSegmentation(lr),GetResponseParam(lr));
+    //
+    if (prevLr!=lr) { // new layer started)
+      roPhase = fSimuParam->GetLrROCycleShift(lr);
+      if (Abs(roPhase)<1.) roPhase = roPhase*sim->GenerateReadOutCycleOffset(); // modules synchronized within layer with this offset
+      else                randomyzeModules = kTRUE;                     // modules have random offset
+    }
+    if (randomyzeModules) sim->GenerateReadOutCycleOffset();
+    else                  sim->SetReadOutCycleOffset(roPhase);
+    //
     sim->SDigitiseModule();
     fLoader->TreeS()->Fill();      // fills all branches - wasted disk space
     ResetSDigits();
+    prevLr = lr;
   } 
   //
   ClearModules();
@@ -563,14 +579,27 @@ void AliITSU::Hits2Digits(Int_t evNumber,Int_t bgrev,Option_t *option,const char
   FillModules(bgrev,option,filename);
   // 
   Int_t nmodules = fGeomTGeo->GetNModules();
+  int prevLr = -1;
+  float roPhase=0; // synchronysation type between layers/modules
+  Bool_t randomyzeModules = kFALSE; // do we need to randomize layers
+  //
   for (Int_t module=0;module<nmodules;module++) {
     int lr = fGeomTGeo->GetLayer(module);
     AliITSUSimulation* sim = GetSimulationModel(lr);
+    //
     sim->InitSimulationModule(GetModule(module),evNumber/*gAlice->GetEvNumber()*/,GetSegmentation(lr),GetResponseParam(lr));
+    if (prevLr!=lr) { // new layer started)
+      roPhase = fSimuParam->GetLrROCycleShift(lr);
+      if (Abs(roPhase)<1.) roPhase = roPhase*sim->GenerateReadOutCycleOffset(); // modules synchronized within layer with this offset
+      else                randomyzeModules = kTRUE;                     // modules have random offset
+    }
+    if (randomyzeModules) sim->GenerateReadOutCycleOffset();
+    else                  sim->SetReadOutCycleOffset(roPhase);
     sim->DigitiseModule();
     // fills all branches - wasted disk space
     fLoader->TreeD()->Fill(); 
     ResetDigits();
+    prevLr = lr;
   } // end for module
   //
   ClearModules();
@@ -805,16 +834,30 @@ void AliITSU::SDigits2Digits()
   TBranch* brchSDigits = trees->GetBranch(GetName());
   //
   int nmodules = fGeomTGeo->GetNModules();
+  int prevLr = -1;
+  float roPhase=0; // synchronysation type between layers/modules
+  Bool_t randomyzeModules = kFALSE; // do we need to randomize layers
+  //
   for (int module=0;module<nmodules;module++) {
     int lr = fGeomTGeo->GetLayer(module);
     AliITSUSimulation* sim = GetSimulationModel(lr);
     sim->InitSimulationModule(GetModule(module),gAlice->GetEvNumber(),GetSegmentation(lr),GetResponseParam(lr));
+    //
+    if (prevLr!=lr) { // new layer started)
+      roPhase = fSimuParam->GetLrROCycleShift(lr);
+      if (Abs(roPhase)<1.) roPhase = roPhase*sim->GenerateReadOutCycleOffset(); // modules synchronized within layer with this offset
+      else                randomyzeModules = kTRUE;                     // modules have random offset
+    }
+    if (randomyzeModules) sim->GenerateReadOutCycleOffset();
+    else                  sim->SetReadOutCycleOffset(roPhase);
+    //
     fSDigits->Clear();
     brchSDigits->GetEvent(module);
     sim->AddSDigitsToModule(fSDigits,0);
     sim->FinishSDigitiseModule();
     fLoader->TreeD()->Fill();
     ResetDigits();
+    prevLr = lr;
   }
   //  WriteFOSignals(); 
   fLoader->TreeD()->GetEntries();
index 161a75c..ebad3e6 100644 (file)
 using namespace TMath;
 
 
-const Double_t  AliITSUSimuParam::fgkPixBiasVoltageDefault = 18.182;
-const Double_t  AliITSUSimuParam::fgkPixThreshDefault = 20.;
-const Double_t  AliITSUSimuParam::fgkPixThrSigmaDefault = 5.;
-const Double_t  AliITSUSimuParam::fgkPixMinElToAddDefault = 1.;
+const Float_t  AliITSUSimuParam::fgkPixBiasVoltageDefault = 18.182;
+const Float_t  AliITSUSimuParam::fgkPixThreshDefault = 20.;
+const Float_t  AliITSUSimuParam::fgkPixThrSigmaDefault = 5.;
+const Float_t  AliITSUSimuParam::fgkPixMinElToAddDefault = 1.;
 const UInt_t    AliITSUSimuParam::fgkPixCouplingOptDefault = AliITSUSimuParam::kNoCouplingPix;
-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;
-const Double_t  AliITSUSimuParam::fgkPixFakeRateDefault = 1e-4;
+const Float_t  AliITSUSimuParam::fgkPixCouplColDefault = 0.;
+const Float_t  AliITSUSimuParam::fgkPixCouplRowDefault = 0.055;
+const Float_t  AliITSUSimuParam::fgkPixEccDiffDefault = 0.85;
+const Float_t  AliITSUSimuParam::fgkPixLorentzHoleWeightDefault = 1.0;
+const Float_t  AliITSUSimuParam::fgkGeVtoChargeDefault = 3.6e-9;
+const Float_t  AliITSUSimuParam::fgkDOverVDefault = 0.000375;
+const Float_t  AliITSUSimuParam::fgkTDefault = 300;
+const Float_t  AliITSUSimuParam::fgkPixFakeRateDefault = 1e-4;
 const Bool_t    AliITSUSimuParam::fgkPixNoiseInAllMod = kFALSE;        
 
-const Double_t  AliITSUSimuParam::fgkNsigmasDefault = 3.;
+const Float_t  AliITSUSimuParam::fgkNsigmasDefault = 3.;
 const Int_t    AliITSUSimuParam::fgkNcompsDefault = 121;
 
 ClassImp(AliITSUSimuParam)
@@ -83,6 +83,7 @@ AliITSUSimuParam::AliITSUSimuParam()
   ,fDOverV(fgkDOverVDefault)
   ,fT(fgkTDefault)
   //
+  ,fNLayers(0)
   ,fNPix(0)
   ,fPixCouplOpt(kNoCouplingPix)
   ,fPixCouplCol(fgkPixCouplColDefault)
@@ -101,6 +102,8 @@ AliITSUSimuParam::AliITSUSimuParam()
   ,fPixFakeRateDef(fgkPixFakeRateDefault)
   ,fPixNoiseInAllMod(fgkPixNoiseInAllMod)
   //
+  ,fLrROCycleShift(0)
+  //
   ,fPixThresh(0)
   ,fPixThrSigma(0)
   ,fPixBiasVoltage(0)
@@ -110,16 +113,19 @@ AliITSUSimuParam::AliITSUSimuParam()
   ,fRespFunParam(0)
 {  
   // default constructor
+  SetNPix(0);
+  SetNLayers(0);
   fRespFunParam.SetOwner(kTRUE);
 }
 
 //______________________________________________________________________
-AliITSUSimuParam::AliITSUSimuParam(UInt_t nPix)
+AliITSUSimuParam::AliITSUSimuParam(UInt_t nLayer,UInt_t nPix)
   :fGeVcharge(fgkGeVtoChargeDefault)
   ,fDOverV(fgkDOverVDefault)
   ,fT(fgkTDefault)
     //
-  ,fNPix(nPix)
+  ,fNLayers(0)
+  ,fNPix(0)
   ,fPixCouplOpt(kNoCouplingPix)
   ,fPixCouplCol(fgkPixCouplColDefault)
   ,fPixCouplRow(fgkPixCouplRowDefault)
@@ -137,6 +143,8 @@ AliITSUSimuParam::AliITSUSimuParam(UInt_t nPix)
   ,fPixFakeRateDef(fgkPixFakeRateDefault)
   ,fPixNoiseInAllMod(fgkPixNoiseInAllMod)
   //
+  ,fLrROCycleShift(0)
+   //
   ,fPixThresh(0)
   ,fPixThrSigma(0)
   ,fPixBiasVoltage(0)
@@ -146,16 +154,8 @@ AliITSUSimuParam::AliITSUSimuParam(UInt_t nPix)
   ,fRespFunParam(0)
 {  
   // regular constructor
-  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];
-  }
-  SetPixThreshold(fgkPixThreshDefault,fgkPixThrSigmaDefault);
-  SetPixNoise(0.,0.);
-  SetPixBiasVoltage(fgkPixBiasVoltageDefault);
+  SetNPix(nPix);
+  SetNLayers(nLayer);
   fRespFunParam.SetOwner(kTRUE);
   //
 }
@@ -167,6 +167,7 @@ AliITSUSimuParam::AliITSUSimuParam(const AliITSUSimuParam &simpar)
   ,fDOverV(simpar.fDOverV)
   ,fT(simpar.fT)
    //
+  ,fNLayers(simpar.fNLayers)
   ,fNPix(simpar.fNPix)
   ,fPixCouplOpt(simpar.fPixCouplOpt)
   ,fPixCouplCol(simpar.fPixCouplCol)
@@ -185,6 +186,7 @@ AliITSUSimuParam::AliITSUSimuParam(const AliITSUSimuParam &simpar)
   ,fPixFakeRateDef(simpar.fPixFakeRateDef)
   ,fPixNoiseInAllMod(simpar.fPixNoiseInAllMod)
    //
+  ,fLrROCycleShift(0)
   ,fPixThresh(0)
   ,fPixThrSigma(0)
   ,fPixBiasVoltage(0)
@@ -195,12 +197,18 @@ AliITSUSimuParam::AliITSUSimuParam(const AliITSUSimuParam &simpar)
    //
 {
   // copy constructor
+  //
+  if (fNLayers>0) {
+    fLrROCycleShift = new Float_t[fNLayers];
+    for (int i=fNLayers;i--;) fLrROCycleShift[i] = simpar.fLrROCycleShift[i];
+  }
+  //
   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];
+    fPixBiasVoltage = new Float_t[fNPix];
+    fPixThresh      = new Float_t[fNPix];
+    fPixThrSigma    = new Float_t[fNPix];
+    fPixNoise       = new Float_t[fNPix];
+    fPixBaseline    = new Float_t[fNPix];
   }
   for (Int_t i=fNPix;i--;) {
     fPixBiasVoltage[i] = simpar.fPixBiasVoltage[i];
@@ -218,6 +226,36 @@ AliITSUSimuParam::AliITSUSimuParam(const AliITSUSimuParam &simpar)
 }
 
 //______________________________________________________________________
+void AliITSUSimuParam::SetNPix(Int_t np)
+{
+  if (fNPix>0) AliFatal(Form("Number of pixels is already set to %d",fNPix));
+  if (np>0) {
+    fNPix = np;
+    fPixBiasVoltage = new Float_t[fNPix];
+    fPixThresh      = new Float_t[fNPix];
+    fPixThrSigma    = new Float_t[fNPix];
+    fPixNoise       = new Float_t[fNPix];
+    fPixBaseline    = new Float_t[fNPix];
+  }
+  SetPixThreshold(fgkPixThreshDefault,fgkPixThrSigmaDefault);
+  SetPixNoise(0.,0.);
+  SetPixBiasVoltage(fgkPixBiasVoltageDefault);
+  //
+}
+
+//______________________________________________________________________
+void AliITSUSimuParam::SetNLayers(Int_t nl)
+{
+  if (fNLayers>0) AliFatal(Form("Number of layers is already set to %d",fNLayers));
+  if (nl>0) {
+    fNLayers = nl;
+    fLrROCycleShift = new Float_t[fNLayers];
+  }
+  SetLrROCycleShift(0);
+  //
+}
+
+//______________________________________________________________________
 AliITSUSimuParam& AliITSUSimuParam::operator=(const AliITSUSimuParam& source)
 {
   // Assignment operator. 
@@ -237,6 +275,7 @@ AliITSUSimuParam::~AliITSUSimuParam()
   delete[] fPixThrSigma;
   delete[] fPixNoise;
   delete[] fPixBaseline;
+  delete[] fLrROCycleShift;
 }
 
 //________________________________________________________________________
@@ -297,6 +336,14 @@ Double_t AliITSUSimuParam::CalcProbNoiseOverThreshold(UInt_t mod) const
 }
 
 //_______________________________________________________________________
+void AliITSUSimuParam::SetLrROCycleShift(Double_t v,Int_t lr)
+{
+  // set fractional offset of layer RO cycle
+  if (lr<0) for (int i=fNLayers;i--;) fLrROCycleShift[i]=v;
+  else fLrROCycleShift[lr]=v;
+}
+
+//_______________________________________________________________________
 void AliITSUSimuParam::SetPixThreshold(Double_t thresh, Double_t sigma, int mod)
 {
   // set threshold params
index 6736448..ccd72a0 100644 (file)
@@ -23,15 +23,21 @@ class AliITSUSimuParam : public TObject {
   enum {kNoCouplingPix,kOldCouplingPix,kNewCouplingPix,kMaxCouplingOptPix};
   //
   AliITSUSimuParam();
-  AliITSUSimuParam(UInt_t nPix);
+  AliITSUSimuParam(UInt_t nLayers,UInt_t nPix);
   AliITSUSimuParam(const AliITSUSimuParam& simpar);
   // assignment operator 
   AliITSUSimuParam& operator=(const AliITSUSimuParam& source);
   ~AliITSUSimuParam();
-
+  //
+  void     SetNPix(Int_t np);
+  void     SetNLayers(Int_t nl);
+  //
   Double_t ApplyPixBaselineAndNoise(UInt_t mod) const;
   Double_t CalcProbNoiseOverThreshold(UInt_t mod) const;
   //
+  void     SetLrROCycleShift(Double_t v=0, Int_t lr=-1);
+  Double_t GetLrROCycleShift(Int_t lr)                                    const  {return fLrROCycleShift ? fLrROCycleShift[lr]:0;}
+  //
   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;
@@ -49,9 +55,8 @@ class AliITSUSimuParam : public TObject {
   //
   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;}
+  // 
+  void     SetGeVToCharge(Double_t gc=fgkNcompsDefault)                          {fGeVcharge = gc;}
   Double_t GetGeVToCharge()                                               const  {return fGeVcharge;}
   Double_t GeVToCharge(Double_t gev)                                      const  {return gev/fGeVcharge;}
   //
@@ -74,9 +79,9 @@ class AliITSUSimuParam : public TObject {
   Double_t LorentzAngleElectron(Double_t bz)                              const;
   Double_t LorentzAngleHole(Double_t bz)                                  const;
   //
-  Int_t    GetNRespFunParams()                                            const {return fRespFunParam.GetEntriesFast();}
-  const AliITSUParamList* GetRespFunParams(Int_t i)                       const {return (const AliITSUParamList*)fRespFunParam[i];}
-  const AliITSUParamList* FindRespFunParams(Int_t detId)                  const;
+  Int_t    GetNRespFunParams()                                            const  {return fRespFunParam.GetEntriesFast();}
+  const    AliITSUParamList* GetRespFunParams(Int_t i)                    const  {return (const AliITSUParamList*)fRespFunParam[i];}
+  const    AliITSUParamList* FindRespFunParams(Int_t detId)               const;
   void     AddRespFunParam(AliITSUParamList* pr);
   //
   virtual void Print(Option_t *opt = "")                                  const; 
@@ -86,59 +91,62 @@ class AliITSUSimuParam : public TObject {
   //
  protected:
 
-  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
-  static const Double_t fgkPixFakeRateDefault;        // default monopix fake rate
-  static const Bool_t   fgkPixNoiseInAllMod;          // default switch to add digital noise to every module
+  static const Float_t fgkPixBiasVoltageDefault;//default for fPixBiasVoltage
+  static const Float_t fgkPixThreshDefault; //default for fThresh
+  static const Float_t fgkPixMinElToAddDefault; // default min number of electrons to add to sdigit
+  static const Float_t fgkPixThrSigmaDefault; //default for fSigma
+  static const Float_t fgkPixCouplColDefault; //default for fPixCouplCol
+  static const Float_t fgkPixCouplRowDefault; //default for fPixCouplRow
+  static const Float_t fgkPixEccDiffDefault;//default for fPixEccDiff
+  static const Float_t fgkPixLorentzHoleWeightDefault;//default for fPixLorentzHoleWeight
+  static const UInt_t  fgkPixCouplingOptDefault;  // type of pixel Coupling (old or new)
+  static const Float_t fgkDOverVDefault;             // default distance over voltage 
+  static const Float_t fgkGeVtoChargeDefault;        // default energy to ionize (free an electron) in GeV
+  static const Float_t fgkTDefault;                  // default temperature
+  static const Float_t fgkPixFakeRateDefault;        // default monopix fake rate
+  static const Bool_t  fgkPixNoiseInAllMod;          // default switch to add digital noise to every module
   
-  static const Double_t fgkNsigmasDefault; //default for fNsigmas
-  static const Int_t fgkNcompsDefault; //default for fNcomps
+  static const Float_t fgkNsigmasDefault; //default for fNsigmas
+  static const Int_t   fgkNcompsDefault; //default for fNcomps
 
  private:
   //
-  Double_t   fGeVcharge;          // Energy to ionize (free an electron) in GeV
-  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.
+  Float_t    fGeVcharge;          // Energy to ionize (free an electron) in GeV
+  Float_t    fDOverV;             // The parameter d/v where d is the disance over which the the potential v is applied d/v [cm/volts]
+  Float_t    fT;                  // The temperature of the Si in Degree K.
   //
-  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
+  UInt_t     fNLayers;             // number of layers  
+  UInt_t     fNPix;                // number of Pix type detectors
+  UInt_t     fPixCouplOpt;         // Pix Coupling Option
+  Float_t    fPixCouplCol;         // Pix Coupling parameter along the cols
+  Float_t    fPixCouplRow;         // Pix Coupling parameter along the rows
   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
+  Float_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     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   fPixFakeRateDef;      // Fake rate for the monopix
+  Float_t    fPixThreshDef;        // Pix Threshold value
+  Float_t    fPixThrSigmaDef;      // Pix Threshold fluctuation
+  Float_t    fPixBiasVoltageDef;   // Bias Voltage for the Pix
+  Float_t    fPixNoiseDef;         // Pix electronic noise: sigma
+  Float_t    fPixBaselineDef;      // Pix electronic noise: baseline
+  Float_t    fPixMinElToAddDef;    // min number of electrons to add
+  Float_t    fPixFakeRateDef;      // Fake rate for the monopix
   Bool_t     fPixNoiseInAllMod;    // Add digital noise to every module
   //
-  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
+  Float_t*   fLrROCycleShift; //[fNLayers] optional RO cycle shift for each layer (in fraction of RO cycle length if abs<1)
+                              // if abs>1, then each module will have random phase
+  Float_t*   fPixThresh;      //[fNPix] Pix Threshold value
+  Float_t*   fPixThrSigma;    //[fNPix] Pix Threshold fluctuation
+  Float_t*   fPixBiasVoltage; //[fNPix] Bias Voltage for the Pix
+  Float_t*   fPixSigma;       //[fNPix] Pix threshold fluctuations spread
+  Float_t*   fPixNoise;       //[fNPix] Pix electronic noise: sigma
+  Float_t*   fPixBaseline;    //[fNPix] Pix electronic noise: baseline
   //
   TObjArray  fRespFunParam;   // set of parameterizations for response function (AliITSUParamList)
 
-  ClassDef(AliITSUSimuParam,1);  // ITSU simulataion params
+  ClassDef(AliITSUSimuParam,2);  // ITSU simulataion params
 };
 
 
index 0b28d5a..2988541 100644 (file)
@@ -37,6 +37,8 @@ AliITSUSimulation::AliITSUSimulation()
   ,fSimuParam(0)
   ,fResponseParam(0)
   ,fModule(0)
+  ,fReadOutCycleOffset(0)
+  ,fReadOutCycleLength(25e-6)  
   ,fEvent(0)
   ,fDebug(0)
 {
@@ -51,6 +53,8 @@ AliITSUSimulation::AliITSUSimulation(AliITSUSimuParam* sim,AliITSUSensMap* map)
   ,fSimuParam(sim)
   ,fResponseParam(0)
   ,fModule(0)
+  ,fReadOutCycleOffset(0)
+  ,fReadOutCycleLength(25e-6)
   ,fEvent(0)
   ,fDebug(0)
 {
@@ -67,6 +71,8 @@ AliITSUSimulation::AliITSUSimulation(const AliITSUSimulation &s)
   ,fSimuParam(s.fSimuParam)   
   ,fResponseParam(s.fResponseParam)
   ,fModule(s.fModule)
+  ,fReadOutCycleOffset(s.fReadOutCycleOffset)
+  ,fReadOutCycleLength(s.fReadOutCycleLength)
   ,fEvent(s.fEvent)
   ,fDebug(s.fDebug)
 {
@@ -85,6 +91,8 @@ AliITSUSimulation&  AliITSUSimulation::operator=(const AliITSUSimulation &s)
   fSimuParam = s.fSimuParam;
   fResponseParam = s.fResponseParam;
   fModule    = s.fModule;
+  fReadOutCycleOffset = s.fReadOutCycleOffset;
+  fReadOutCycleLength = s.fReadOutCycleLength;
   fEvent     = s.fEvent;
   return *this;
 }
@@ -101,7 +109,6 @@ void AliITSUSimulation::InitSimulationModule(AliITSUModule* mod, Int_t event, Al
   ClearMap();
   memset(fCyclesID,0,(1+2*kMaxROCycleAccept)*sizeof(Bool_t));
   //
-  if (event != fEvent) GenerateReadOutCycleOffset(); 
   SetEvent(event);
   
 }
@@ -192,3 +199,15 @@ Int_t AliITSUSimulation::GenOrderedSample(UInt_t nmax,UInt_t ngen,TArrayI &vals,
   Sort((int)ngen,valA,indA,kFALSE);
   return ngen;
 }
+
+//______________________________________________________________________
+Double_t AliITSUSimulation::GenerateReadOutCycleOffset()
+{
+  // Generate randomly the strobe
+  // phase w.r.t to the LHC clock
+  return fReadOutCycleOffset = fReadOutCycleLength*gRandom->Rndm();
+  // fReadOutCycleOffset = 25e-9*gRandom->Rndm(); // clm: I think this way we shift too much 10-30 us! The global shift should be between the BCs?!
+  // RS: 25 ns is too small number, the staggering will not work. Let's at the moment keep fully random shift (still, no particle from correct
+  // collision will be lost) untill real number is specified
+ //
+}
index 1e05102..af063b7 100644 (file)
@@ -62,7 +62,7 @@ class AliITSUSimulation : public TObject
   virtual void CreateFastRecPoints(AliITSUModule *,Int_t,TRandom *,TClonesArray* /*recp*/) {}
   //
   // readout phase (strobe, timing etc) generation
-  virtual void GenerateReadOutCycleOffset() {}
+  virtual Double_t GenerateReadOutCycleOffset();
   //
   AliITSCalibration*  GetCalibDead()                   const {return fCalibDead;}
   AliITSCalibration*  GetCalibNoisy()                  const {return fCalibNoisy;}
@@ -87,6 +87,9 @@ class AliITSUSimulation : public TObject
   void SetNoDebug()                                        {fDebug=0;}
   void ClearMap()                                          {fSensMap->Clear();}
   //
+  Double_t GetReadOutCycleOffset()              const      {return fReadOutCycleOffset;}
+  void     SetReadOutCycleOffset(Double_t v=0)             {fReadOutCycleOffset = v;}
+  //
   static  Int_t GenOrderedSample(UInt_t nmax,UInt_t ngen,TArrayI &vals,TArrayI &ind);
   //
   static  Double_t GausInt1D(Double_t sig,Double_t a,Double_t b);
@@ -101,11 +104,14 @@ class AliITSUSimulation : public TObject
   AliITSUSimuParam    *fSimuParam;      //! simulation parameters
   AliITSUParamList    *fResponseParam;  //! response parameterization data
   AliITSUModule       *fModule;         //! module being processed
+  Float_t              fReadOutCycleOffset; //! The phase of the RO with respect to the trigger
+  Float_t              fReadOutCycleLength; //! readout cycle lenght in s
+
   Int_t                fEvent;          //! event number being processed
   Int_t                fDebug;          //!  debug flag
   Bool_t               fCyclesID[2*kMaxROCycleAccept+1]; //! status of RO cycles
 
-  ClassDef(AliITSUSimulation,1)       // Simulation base class 
+  ClassDef(AliITSUSimulation,2)       // Simulation base class 
     
 };
 
index fc733d7..63961dd 100644 (file)
@@ -61,8 +61,6 @@ ClassImp(AliITSUSimulationPix)
 //______________________________________________________________________
 AliITSUSimulationPix::AliITSUSimulationPix()
 :  fTanLorAng(0)
-  ,fReadOutCycleLength(25e-6)
-  ,fReadOutCycleOffset(0)
   ,fGlobalChargeScale(1.0)
   ,fSpread2DHisto(0)
   ,fSpreadFun(0)
@@ -76,8 +74,6 @@ AliITSUSimulationPix::AliITSUSimulationPix()
 AliITSUSimulationPix::AliITSUSimulationPix(AliITSUSimuParam* sim,AliITSUSensMap* map)
   :AliITSUSimulation(sim,map)
   ,fTanLorAng(0)
-  ,fReadOutCycleLength(25e-6)
-  ,fReadOutCycleOffset(0)
   ,fGlobalChargeScale(1.0)
   ,fSpread2DHisto(0)
   ,fSpreadFun(0)
@@ -92,8 +88,6 @@ AliITSUSimulationPix::AliITSUSimulationPix(AliITSUSimuParam* sim,AliITSUSensMap*
 AliITSUSimulationPix::AliITSUSimulationPix(const AliITSUSimulationPix &s) 
   :AliITSUSimulation(s)
   ,fTanLorAng(s.fTanLorAng)
-  ,fReadOutCycleLength(s.fReadOutCycleLength)
-  ,fReadOutCycleOffset(s.fReadOutCycleOffset)
   ,fGlobalChargeScale(s.fGlobalChargeScale)
   ,fSpread2DHisto(s.fSpread2DHisto)
   ,fSpreadFun(s.fSpreadFun)
@@ -116,8 +110,6 @@ AliITSUSimulationPix& AliITSUSimulationPix::operator=(const AliITSUSimulationPix
   //    Assignment operator
   if (&s == this) return *this;
   AliITSUSimulation::operator=(s);
-  fReadOutCycleLength = s.fReadOutCycleLength;
-  fReadOutCycleOffset = s.fReadOutCycleOffset;
   fSpread2DHisto = s.fSpread2DHisto;
   //
   fGlobalChargeScale = s.fGlobalChargeScale;
@@ -713,18 +705,6 @@ void AliITSUSimulationPix::SetCouplingOld(AliITSUSDigit* old)
 }
 
 //______________________________________________________________________
-void AliITSUSimulationPix::GenerateReadOutCycleOffset()
-{
-  // Generate randomly the strobe
-  // phase w.r.t to the LHC clock
-  fReadOutCycleOffset = fReadOutCycleLength*gRandom->Rndm();
-  // fReadOutCycleOffset = 25e-9*gRandom->Rndm(); // clm: I think this way we shift too much 10-30 us! The global shift should be between the BCs?!
-  // RS: 25 ns is too small number, the staggering will not work. Let's at the moment keep fully random shift (still, no particle from correct
-  // collision will be lost) untill real number is specified
- //
-}
-
-//______________________________________________________________________
 void AliITSUSimulationPix::SetResponseParam(AliITSUParamList* resp)
 {
   // attach response parameterisation data
index e8a3089..5e4bd90 100644 (file)
@@ -79,15 +79,14 @@ public:
   void AddNoisyPixels();   
   void RemoveDeadPixels();
   void FrompListToDigits();
+  //
   Int_t AddRandomNoisePixels(Double_t tof=0);
   Bool_t SetTanLorAngle(Double_t WeightHole=1.0);
   Double_t GetTanLorAngle() const {return fTanLorAng;};
   //
   // For backwards compatibility
   void SDigitsToDigits(){ FinishSDigitiseModule();}
-  
-  virtual void GenerateReadOutCycleOffset();
-  //
+  //  
   Double_t SpreadFunDoubleGauss2D(const Double_t *dtIn);
   Double_t SpreadFunGauss2D(const Double_t *dtIn);
   Double_t SpreadFrom2DHisto(const Double_t *dtIn);
@@ -108,8 +107,6 @@ public:
   //   
  protected:
    Double_t      fTanLorAng;               //! Tangent of the Lorentz Angle (weighted average for hole and electrons)
-   Double_t      fReadOutCycleLength;      // readout cycle lenght in s
-   Double_t      fReadOutCycleOffset;      // The phase of the RO with respect to the trigger
    Double_t      fGlobalChargeScale;       // Charge scaling to match Geant and Test beam
    //   
    TH2*          fSpread2DHisto;           //! optional 2D histo for charge spread parameterization
index 27f03e2..f5f86c3 100644 (file)
@@ -10,6 +10,16 @@ const int kAddNoise = -1;
 const int kAddNoiseInAllMod = -1;
 
 const char* inpPSFName = "$ALICE_ROOT/ITS/UPGRADE/misc/ITSU_pixel_response_PSFs.root";
+const int kNLayers = 7; 
+
+/*
+  these are readout phases settings: 
+  the rule is: 
+  1) abs(kROShifts)<1: the modules of the layer are synchronized, the layer 
+     phase is set to kROShifts*ROCycleLength of the modules of this layer
+  2) abs(kROShifts)>1: each module within the layer will have random phase within its ROCycleLength
+*/
+const float kROShifts[kNLayers] = {0.5,0.5,0.5, -0.5,-0.5, 0.5,0.5};
 
 void MakeITSUSimuParam(const char* cdbURI="local://") {
   //========================================================================
@@ -56,6 +66,9 @@ AliITSUSimuParam* MakeITSUSimuParam_M32P26Func()
   //
   AliITSUSimuParam* itsSimuParam = new AliITSUSimuParam();
   //
+  itsSimuParam->SetNLayers(kNLayers);
+  for (int ilr=kNLayers;ilr--;) itsSimuParam->SetLrROCycleShift(kROShifts[ilr],ilr);
+  //
   // Add spread function parameterization data
   AliITSUParamList* parData = 0;
   //  
@@ -196,6 +209,9 @@ AliITSUSimuParam* MakeITSUSimuParam_M32P26Map()
   //
   AliITSUSimuParam* itsSimuParam = new AliITSUSimuParam();
   //
+  itsSimuParam->SetNLayers(kNLayers);
+  for (int ilr=kNLayers;ilr--;) itsSimuParam->SetLrROCycleShift(kROShifts[ilr],ilr);
+  //
   // Add spread function parameterization data
   AliITSUParamList* parData = 0;
   //
@@ -293,6 +309,9 @@ AliITSUSimuParam* MakeITSUSimuParam_M32terP31Map()
   //
   AliITSUSimuParam* itsSimuParam = new AliITSUSimuParam();
   //
+  itsSimuParam->SetNLayers(kNLayers);
+  for (int ilr=kNLayers;ilr--;) itsSimuParam->SetLrROCycleShift(kROShifts[ilr],ilr);
+  //
   // Add spread function parameterization data
   AliITSUParamList* parData = 0;
   // 
index 027d80c..9b63903 100644 (file)
Binary files a/ITS/UPGRADE/testITSU/itsupcdb.tar.gz and b/ITS/UPGRADE/testITSU/itsupcdb.tar.gz differ