New SDigits and Digits routines, and related changes, (including new
authornilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Apr 2002 22:02:31 +0000 (22:02 +0000)
committernilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Apr 2002 22:02:31 +0000 (22:02 +0000)
noise values).

ITS/AliITSClusterFinderSDD.cxx
ITS/AliITSClusterFinderSDD.h
ITS/AliITSetfSDD.cxx
ITS/AliITSetfSDD.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h

index 47932b15b14a1a4a0de7d5617935cdc9e16c600b..41b5145946457a05b56c362a8fe16f34c5631ba2 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+/*
+  $Id$
+  $Log$
+ */
+
 #include <iostream.h>
 #include <TFile.h>
 #include <TMath.h>
@@ -64,7 +69,7 @@ AliITSClusterFinderSDD::AliITSClusterFinderSDD(){
     fCutAmplitude = 0;
     SetDAnode();
     SetDTime();
-    SetMinPeak();
+    SetMinPeak((Int_t)(((AliITSresponseSDD*)fResponse)->GetNoiseAfterElectronics()*5));
     SetMinNCells();
     SetMaxNCells();
     SetTimeCorr();
@@ -348,7 +353,7 @@ Int_t AliITSClusterFinderSDD::SearchPeak(Float_t *spect,Int_t xdim,Int_t zdim,
     Int_t i,j;
     // search peaks
     for( Int_t z=1; z<zdim-1; z++ ){
-        for( Int_t x=2; x<xdim-3; x++ ){
+        for( Int_t x=1; x<xdim-2; x++ ){
             Float_t sxz = spect[x*zdim+z];
             Float_t sxz1 = spect[(x+1)*zdim+z];
             Float_t sxz2 = spect[(x-1)*zdim+z];
@@ -748,7 +753,7 @@ void AliITSClusterFinderSDD::ResolveClustersE(){
             //        clusterJ->PrintInfo();
             Float_t *par = new Float_t[npeak*5+1];
             par[0] = (Float_t)npeak;                
-            // Initial paramiters in cell dimentions
+            // Initial parameters in cell dimentions
             Int_t k1 = 1;
             for( i=0; i<npeak; i++ ){
                 par[k1] = peakAmp1[i];
@@ -799,8 +804,8 @@ void AliITSClusterFinderSDD::ResolveClustersE(){
                 newiTimef *= fTimeStep;
                 if( newiTimef > fTimeCorr ) newiTimef -= fTimeCorr;
                 if( electronics == 1 ){
-                    newiTimef *= 0.999438;    // PASCAL
-                    newiTimef += (6./fDriftSpeed - newiTimef/3000.);
+                //    newiTimef *= 0.999438;    // PASCAL
+                //    newiTimef += (6./fDriftSpeed - newiTimef/3000.);
                 }else if( electronics == 2 )
                     newiTimef *= 0.99714;    // OLA
                 Float_t driftPath = fSddLength - newiTimef * fDriftSpeed;
@@ -812,17 +817,17 @@ void AliITSClusterFinderSDD::ResolveClustersE(){
                 clusterI.SetAsigma( sigma[i]*anodePitch );
                 clusterI.SetTsigma( tau[i]*fTimeStep );
                 clusterI.SetQ( integral[i] );
-                //        clusterI.PrintInfo();
+                //    clusterI.PrintInfo();
                 iTS->AddCluster( 1, &clusterI );
             } // end for i
             fClusters->RemoveAt( j );
             delete [] par;
-        } else {
+        } else {  // something odd
+            cout << " --- Peak not found!!!!  minpeak=" << fMinPeak<< 
+                    " cluster peak=" << clusterJ->PeakAmpl() << 
+                    " module=" << fModule << endl; 
             clusterJ->PrintInfo(); 
-            cout <<" --- Peak not found!!!!  minpeak=" << fMinPeak<< 
-                   " cluster peak=" << clusterJ->PeakAmpl() << 
-                   " npeak=" << npeak << endl << "xdim=" << xdim-2 << " zdim="
-                   << zdim-2 << endl << endl;
+            cout << " xdim=" << xdim-2 << " zdim=" << zdim-2 << endl << endl;
         }
         delete [] sp;
     } // cluster loop
index 797e0c875085112567db82d1fbc9067c547b9def..aaa5c19c90107aac6100cff5dae6dd7d85946db9 100644 (file)
@@ -4,7 +4,9 @@
 ////////////////////////////////////////////////
 //  ITS Cluster Finder Class                 //
 ////////////////////////////////////////////////
-
+/*
+  $Id$
+*/
 
 #include "AliITSClusterFinder.h"
 
@@ -13,9 +15,9 @@ class TFile;
 
 class AliITSClusterFinderSDD : public AliITSClusterFinder{
  public:
-
-    AliITSClusterFinderSDD(AliITSsegmentation *seg,AliITSresponse *response,
-                          TClonesArray *digits,TClonesArray *recpoints);
+    AliITSClusterFinderSDD
+       (AliITSsegmentation *seg,AliITSresponse *response,
+        TClonesArray *digits,TClonesArray *recpoints);
     AliITSClusterFinderSDD();
     virtual ~AliITSClusterFinderSDD();
 
@@ -46,7 +48,7 @@ class AliITSClusterFinderSDD : public AliITSClusterFinder{
        fMaxNCells=maxc;}
     virtual Int_t MaxNCells() {// get MaxNCells
        return fMaxNCells;}
-    virtual void SetTimeCorr(Float_t timec=23.) {// setNCells
+    virtual void SetTimeCorr(Float_t timec=19.3) {// setNCells
        fTimeCorr=timec;}
     virtual Float_t TimeCorr() {// get Time Correction (ns)
        return fTimeCorr;}
@@ -58,23 +60,22 @@ class AliITSClusterFinderSDD : public AliITSClusterFinder{
     void  GroupClusters();
     void  SelectClusters();
     void  GetRecPoints();
-    void ResolveClusters(); // Boris........ 
-    void ResolveClustersE(); // Ernesto 
-    Int_t SearchPeak(Float_t *spect,Int_t xdim,Int_t zdim,Int_t *peakX, Int_t
-                    *peakZ, Float_t *peakAmp, Float_t minpeak ); // Ernesto
-    Int_t NoLinearFit(Int_t xdim,Int_t zdim,Float_t *param,Float_t *spe,
-                     Int_t *niter, Float_t *chir );
-    void Minim( Int_t xdim, Int_t zdim, Float_t *param, Float_t *prm0,
-               Float_t *steprm,Float_t *chisqr,Float_t *spe,Float_t *speFit );
+    void  ResolveClusters(); // Boris........ 
+    void  ResolveClustersE(); // Ernesto 
+    Int_t SearchPeak(Float_t *spect,Int_t xdim,Int_t zdim,Int_t *peakX,
+                    Int_t *peakZ,Float_t *peakAmp,Float_t minpeak); // Ernesto
+    Int_t NoLinearFit( Int_t xdim, Int_t zdim, Float_t *param, Float_t *spe,
+                      Int_t *niter, Float_t *chir );
+    void  Minim( Int_t xdim, Int_t zdim, Float_t *param, Float_t *prm0,
+               Float_t *steprm, Float_t *chisqr,Float_t *spe,Float_t *speFit);
     Float_t ChiSqr( Int_t xdim, Int_t zdim, Float_t *spe, Float_t *speFit );
-    void PeakFunc( Int_t xdim, Int_t zdim, Float_t *par, Float_t *spe, Float_t
-                  *Integral=0 );
-    void Print();
+    void  PeakFunc( Int_t xdim, Int_t zdim, Float_t *par, Float_t *spe,
+                  Float_t *Integral=0 );
+    void  Print();
 
  private:
     AliITSClusterFinderSDD(const AliITSClusterFinderSDD &source); // copy ctor
     AliITSClusterFinderSDD& operator=(const AliITSClusterFinderSDD &source);
-
  private:
     Int_t               fModule;        //! ITS current module 
     TClonesArray       *fClusters;      //! clusters
@@ -89,7 +90,6 @@ class AliITSClusterFinderSDD : public AliITSClusterFinder{
     Int_t               fMaxNCells;     //! max num of cells
 
     ClassDef(AliITSClusterFinderSDD,1) // SDD clustering - Piergiorgio C. algo
-
-};
+    };
 
 #endif
index c44f66eaf1cb396040e33e301f678082102067b6..27d37d17eb558c9b479e6f6cb6c7136c3f3f9499 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-
+/*
+$Log$
+*/
 #include <iostream.h>
 #include <TMath.h>
 #include <TString.h>
@@ -44,11 +47,7 @@ AliITSetfSDD::AliITSetfSDD(Double_t timestep, Int_t amplif)
 
   fT0 = 0.;
   fDf = ppower(10,9)/(kMaxNofSamples*fSamplingTime);
-  fA0 = 16500.; // AL: 16500.;  // TB: 24000.; // 26000.; // 24000.; // 18000.; 
 
-  if(amplif == 2) fA0 = 24000.;
-//  cout << "fA0: " << fA0 << endl;
-//  cout << "fTimeDelay: " << fTimeDelay << endl;
   Int_t i,j;
   for(i=0; i<kMaxNofPoles; i++) {
     fZeroM[i] = 0.;
@@ -60,17 +59,35 @@ AliITSetfSDD::AliITSetfSDD(Double_t timestep, Int_t amplif)
   }
   // Alice
 
-  fPoleM[0] = 1.;
-  fPoleR[0] = -4140000.; // AL: -4140000.; // TB: -3000000.; // -3750000.; // -3500000; // -3000000.; 
-  fPoleI[0] = 0.; // AL: 0.; // TB: 4000000.; // 3750000.; // 3500000.; // 3000000.; 
-  if(amplif == 2) {
+  // PASCAL amplif
+  fA0 = 5.53269815e+11; 
+  fPoleM[0] = 3.;
+  fPoleR[0] = -8280000.; 
+  fPoleI[0] = 0.; 
+
+  if(amplif == 2) { // OLA amplif.
+    fA0 = 24000.;
+    fPoleM[0] = 1.;
     fPoleR[0] = -3000000.;
     fPoleI[0] = 4000000.;
+    fPoleM[1] = 1.;
+    fPoleR[1] = fPoleR[0];
+    fPoleI[1] = -fPoleI[0]; 
   }
-  fPoleM[1] = 1.;
-  fPoleR[1] = fPoleR[0];
-  fPoleI[1] = -fPoleI[0]; 
 
+  if( amplif == 3 ) { // old PASCAL
+    fA0 = 16500.; // AL: 16500.;  // TB: 24000.; // 26000.; // 24000.; // 18000.; 
+    fPoleM[0] = 1.;
+    fPoleR[0] = -4140000.; // AL: -4140000.; // TB: -3000000.; // -3750000.; // -3500000; // -3000000.; 
+    fPoleI[0] = 0.; // AL: 0.; // TB: 4000000.; // 3750000.; // 3500000.; // 3000000.; 
+    fPoleM[1] = 1.;
+    fPoleR[1] = fPoleR[0];
+    fPoleI[1] = -fPoleI[0]; 
+  }
+
+  //cout << "fA0: " << fA0 << endl;
+  //cout << "fTimeDelay: " << fTimeDelay << endl;
+  
   // Compute Transfer Function
 
   Double_t PI = acos(-1.);
index f204d0aa8766c31ea1c8c89ad7fe3c16771f634d..1aad9353bcc685353a42133c2f25ab324075db2e 100644 (file)
@@ -2,7 +2,9 @@
 #define ITSETFSDD_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
-
+/*
+$Log$
+*/
 #include <TObject.h>
 
 static const Int_t kMaxNofPoles = 5;
@@ -34,7 +36,7 @@ class AliITSetfSDD : public TObject {
   Float_t GetTimeDelay() { return fTimeDelay; }
   void PrintElectronics();          // Print Electronics parameters  
 
- private:
+ protected:
 
   Float_t  fTimeDelay;         //  Time delay caused by the amplifier shaping
   Double_t fSamplingTime;      //
index 6a93e8d5d5608f515f6c4880c6140998bf3a8aef..149e9ea599f4d326549d85d71c67396139e57fcd 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+/*
+$Id$
+$Log$
+*/
 
 #include <TString.h>
 #include <TRandom.h>
 #include "AliITSresponseSDD.h"
 
 
-//___________________________________________
-ClassImp(AliITSresponseSDD)    
+//______________________________________________________________________
+ClassImp(AliITSresponseSDD)
 
-AliITSresponseSDD::AliITSresponseSDD()
-{
+AliITSresponseSDD::AliITSresponseSDD(){
   // default constructor
    fGaus = 0;
    SetDeadChannels();
@@ -35,6 +38,7 @@ AliITSresponseSDD::AliITSresponseSDD()
    // SetClock();
    SetNoiseParam();
    SetNoiseAfterElectronics();
+   SetJitterError();
    SetElectronics();
    SetDynamicRange();
    SetChargeLoss();
@@ -49,16 +53,15 @@ AliITSresponseSDD::AliITSresponseSDD()
    // set the default zero suppression parameters
    fCPar[0]=0;
    fCPar[1]=0;
-   fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.2);
-   fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.2);
+   fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
+   fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
    fCPar[4]=0;
    fCPar[5]=0;
    fCPar[6]=0;
    fCPar[7]=0;
 }
-
-AliITSresponseSDD::AliITSresponseSDD(const char *dataType)
-{
+//______________________________________________________________________
+AliITSresponseSDD::AliITSresponseSDD(const char *dataType){
   // constructor
    fGaus = 0;
    SetDeadChannels();
@@ -70,6 +73,7 @@ AliITSresponseSDD::AliITSresponseSDD(const char *dataType)
    // SetClock();
    SetNoiseParam();
    SetNoiseAfterElectronics();
+   SetJitterError();
    SetElectronics();
    SetDynamicRange();
    SetChargeLoss();
@@ -84,44 +88,39 @@ AliITSresponseSDD::AliITSresponseSDD(const char *dataType)
    // set the default zero suppression parameters
    fCPar[0]=0;
    fCPar[1]=0;
-   fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.2);
-   fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.2);
+   fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
+   fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.5);
    fCPar[4]=0;
    fCPar[5]=0;
    fCPar[6]=0;
    fCPar[7]=0;
 }
-
+//______________________________________________________________________
 AliITSresponseSDD::~AliITSresponseSDD() { 
 
   if(fGaus) delete fGaus;
-
 }
-
-void AliITSresponseSDD::SetCompressParam(Int_t  cp[8])
-{
+//______________________________________________________________________
+void AliITSresponseSDD::SetCompressParam(Int_t  cp[8]){
   // set compression param
 
     Int_t i;
     for (i=0; i<8; i++) {
         fCPar[i]=cp[i];
-        //printf("\n CompressPar %d %d \n",i,fCPar[i]);
-    
-    }
+        //printf("\n CompressPar %d %d \n",i,fCPar[i]);    
+    } // end for i
 }
-
-void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8])
-{
+//______________________________________________________________________
+void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8]){
   // give compression param
 
     Int_t i;
     for (i=0; i<8; i++) {
         cp[i]=fCPar[i];
-    }
+    } // end for i
 }
-
-void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan) 
-{
+//______________________________________________________________________
+void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan){
     // Set fGain to zero to simulate a random distribution of 
     // dead modules, dead chips and single dead channels
 
@@ -190,7 +189,8 @@ void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan)
         chip_mod[i-1] = module;
         for( Int_t m=0; m<fChannels; m++ ) 
             fGain[module-1][chi-1][m] = 0.;
-        cout << i << ": Dead chip nr. " << chip[i-1] << " in module nr: " << chip_mod[i-1] << endl;
+        cout << i << ": Dead chip nr. " << chip[i-1] << " in module nr: " 
+            << chip_mod[i-1] << endl;
     }
 
     //  cout << "channels" << endl;
@@ -209,10 +209,11 @@ void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan)
             if( module == mod[k] ) { flag_mod = 1; break; }
         if( flag_mod == 1 ) continue;
         Int_t chipp = (Int_t) (fChips*gran->Uniform() + 1.);
-        if( chipp <=0 || chipp > fChips ) cout << "Wrong chip: " << chipp << endl;
+        if( chipp <=0 || chipp > fChips ) cout << "Wrong chip: "<< chipp<<endl;
         Int_t flag_chip = 0;
         for( k=0; k<nchip; k++) 
-            if( chipp == chip[k] && module == chip_mod[k] ) { flag_chip = 1; break; }
+            if( chipp == chip[k] && module == chip_mod[k] ) { 
+               flag_chip = 1; break; }
         if( flag_chip == 1 ) continue;
         i++;
         channel[i-1] = (Int_t) (fChannels*gran->Uniform() + 1.); 
@@ -221,7 +222,9 @@ void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan)
         channel_chip[i-1] = chipp;
         channel_mod[i-1] = module;
         fGain[module-1][chipp-1][channel[i-1]-1] = 0.;
-        cout << i << ": Dead channel nr. " << channel[i-1] << " in chip nr. " << channel_chip[i-1] << " in module nr: " << channel_mod[i-1] << endl;
+        cout << i << ": Dead channel nr. " << channel[i-1] << " in chip nr. " 
+            << channel_chip[i-1] << " in module nr: " << channel_mod[i-1] 
+            << endl;
     }
     
     delete [] mod;
@@ -231,40 +234,41 @@ void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan)
     delete [] channel_mod;
     delete [] channel_chip;
 }
+//______________________________________________________________________
+void AliITSresponseSDD::PrintGains(){
+    //
 
-void AliITSresponseSDD::PrintGains()
-{
-    // Print Electronics Gains
+  if( GetDeadModules() == 0 && 
+      GetDeadChips() == 0 && 
+      GetDeadChannels() == 0 )
+      return;  
+
+  // Print Electronics Gains
   cout << "**************************************************" << endl; 
   cout << "             Print Electronics Gains              " << endl;
   cout << "**************************************************" << endl;
 
-//  FILE *f = fopen( "gains.txt", "w" );
-//  fprintf( f, "    Module    Chip   Channel   Gain\n" );
-
   // Print SDD electronic gains
   for(Int_t t=0; t<fModules;t++)
     for(Int_t u=0; u<fChips;u++)
       for(Int_t v=0; v<fChannels;v++)
       {
-        cout << "Gain for Module: " << t+1 << ", Chip " << u+1 << ", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
-//        if( fGain[t][u][v] != 1.0 )
-//          fprintf( f, " %8d %8d %8d   %f\n", t+1, u+1, v+1, fGain[t][u][v] );
+        if( fGain[t][u][v] != 1.0 )
+           cout << "Gain for Module: " << t+1 << ", Chip " << u+1 << 
+                   ", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
       }
-//  fclose( f );
 }
-
-void AliITSresponseSDD::Print()
-{
+//______________________________________________________________________
+void AliITSresponseSDD::Print(){
   // Print SDD response Parameters
 
    cout << "**************************************************" << endl;
    cout << "   Silicon Drift Detector Response Parameters    " << endl;
    cout << "**************************************************" << endl;
-   cout << "Diffusion Coefficients: " << fDiffCoeff << ", " << fDiffCoeff1 << endl;
+   cout << "Diffusion Coefficients: "<< fDiffCoeff<< ", "<<fDiffCoeff1 << endl;
 
    cout << "Hardware compression parameters: " << endl; 
-   for(Int_t i=0; i<8; i++) cout << "fCPar[" << i << "] = " << fCPar[i] << endl;
+   for(Int_t i=0; i<8; i++) cout << "fCPar[" << i << "] = " << fCPar[i] <<endl;
    cout << "Noise before electronics (arbitrary units): " << fNoise << endl;
    cout << "Baseline (ADC units): " << fBaseline << endl;
    cout << "Noise after electronics (ADC units): " << fNoiseAfterEl << endl;
index 9a0d40d02fa9d9b801f270c54ba9e162077bd5ca..4a39a6a0e967ee0350206f7311d13b5f6c62624f 100644 (file)
@@ -1,6 +1,12 @@
 #ifndef ALIITSRESPONSESDD_H
 #define ALIITSRESPONSESDD_H
-
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/*
+  $Id$
+*/
 #include "TArrayF.h"
 #include <TString.h>
 #include <iostream.h>
 
 // response for SDD
 
-class AliITSresponseSDD :
-  public AliITSresponse {
-public:
+class AliITSresponseSDD : public AliITSresponse {
+ public:
   //
   // Configuration methods
   //
   
-  AliITSresponseSDD();
-  AliITSresponseSDD(const char *dataType);
-  
-  virtual ~AliITSresponseSDD();
+    AliITSresponseSDD();
+    AliITSresponseSDD(const char *dataType);
+    virtual ~AliITSresponseSDD();
 
-  void SetElectronics(Int_t p1=1) {
-    // Electronics: Pascal (1) or OLA (2)
-    fElectronics=p1;
-  }
-  
-  Int_t Electronics() {
-    // Electronics: 1 = Pascal; 2 = OLA
-    return fElectronics;
-  }
-  
-  void    SetMaxAdc(Float_t p1=1024.) {
-    // Adc-count saturation value
-    fMaxAdc=p1;
-  }
-  Float_t MaxAdc()  {
-    // Get maximum Adc-count value
-    return fMaxAdc;
-  }                       
-  
-  void    SetChargeLoss(Float_t p1=0.0) {
-    // Set Linear Charge Loss Steepness  // 0.01 for 20%
-    fChargeLoss=p1;
-  }
-  Float_t ChargeLoss()  {
-    // Get Charge Loss Coefficient
-    return fChargeLoss;
-  }                       
-  
-  void    SetDynamicRange(Float_t p1=132.) {
-    // Set Dynamic Range
-    fDynamicRange=p1;
-  }
-  Float_t DynamicRange()  {
-    // Get Dynamic Range
-    return fDynamicRange;
-  }                       
-  
-  void    SetDiffCoeff(Float_t p1=3.23,Float_t p2=30.) {
-    // Diffusion coefficients
-    fDiffCoeff=p1;
-    fDiffCoeff1=p2;
-  }
-  void DiffCoeff(Float_t&diff,Float_t&diff1) {
-    // Get diffusion coefficients
-    diff = fDiffCoeff;
-    diff1 = fDiffCoeff1;
-  } 
-  
-  void    SetDriftSpeed(Float_t p1=7.3) {
-    // Drift velocity
-    fDriftSpeed=p1;
-  }
-  Float_t DriftSpeed() {
-    // drift speed
-    return fDriftSpeed;
-  } 
-  
-  void    SetTemperature(Float_t p1=23.) {
-    // Temperature
-    fTemperature=p1;
-  }
-  Float_t Temperature() {
-    // Get temperature
-    return fTemperature;
-  } 
-  
-  void    SetDataType(const char *data="simulated") {
-    // Type of data - real or simulated
-    fDataType=data;
-  }
-  const char  *DataType() const {
-    // Get data type
-    return fDataType.Data();
-  } 
-  
-  void SetParamOptions(const char *opt1="same",const char *opt2="same"){
-    // Parameters: "same" or read from "file" 
-    fParam1=opt1; fParam2=opt2;
-  }
-  void   ParamOptions(char *opt1,char *opt2) {
-    // options
-    strcpy(opt1,fParam1.Data()); strcpy(opt2,fParam2.Data());
-  }
-  
-  void  SetNoiseParam(Float_t n=0., Float_t b=20.){
-    // Noise and baseline  // 8.3 for ALICE with beam test measurements
-    fNoise=n; fBaseline=b;
-  }   
-  void  SetNoiseAfterElectronics(Float_t n=0.){
-    // Noise after electronics (ADC units) // 1.6 for ALICE from beam test measurements
-    fNoiseAfterEl=n;
-  }   
-  void  GetNoiseParam(Float_t &n, Float_t &b) {
-    // get noise param
-    n=fNoise; b=fBaseline;
-  }  
-  Float_t  GetNoiseAfterElectronics(){
-    // Noise after electronics (ADC units)
-    return fNoiseAfterEl;
-  }   
-
-  void  SetDo10to8(Bool_t bitcomp=kTRUE) {
-    // set the option for 10 to 8 bit compression
-    fBitComp = bitcomp;
-  }
-
-  Bool_t Do10to8() {
-    // get 10 to 8 compression option
-    return fBitComp;
-  }   
-  
-  void    SetZeroSupp (const char *opt="1D") {
-    // Zero-suppression option - could be 1D, 2D or non-ZS 
-    fOption=opt;
-  }
-  const char *ZeroSuppOption() const {
-    // Get zero-suppression option
-    return fOption.Data();
-  }
-  void  SetMinVal(Int_t mv=4) {
-    // Min value used in 2D - could be used as a threshold setting
-    fMinVal = mv;
-  }
-  Int_t  MinVal() {
-    // min val
-    return fMinVal;
-  }
-  
-  void   SetFilenames(const char *f1="",const char *f2="",const char *f3="") {
-    // Set filenames - input, output, parameters ....
-    fFileName1=f1; fFileName2=f2; fFileName3=f3;
-  }
-  void   Filenames(char *input,char *baseline,char *param) {
-    // Filenames
-   strcpy(input,fFileName1.Data());  strcpy(baseline,fFileName2.Data());  
-   strcpy(param,fFileName3.Data());
-  }     
-  
-  
-  void  SetOutputOption(Bool_t write=kFALSE) {
-    // set output option
-    fWrite = write;
-  }
-  Bool_t OutputOption()  {
-    // output option
-    return fWrite;
-  }
-  // 
-  // Compression parameters
-  void  SetCompressParam(Int_t cp[8]); 
-  void  GiveCompressParam(Int_t *x);
-  
-  //  
-  // Detector type response methods
-  void    SetNSigmaIntegration(Float_t p1=3.) {
-    // Set number of sigmas over which cluster disintegration is performed
-    fNsigmas=p1;
-  }
-  Float_t NSigmaIntegration() {
-    // Get number of sigmas over which cluster disintegration is performed
-    return fNsigmas;
-  }
-  void SetNLookUp(Int_t p1=121) {
-    // Set number of sigmas over which cluster disintegration is performed
-    fNcomps=p1;
-    fGaus = new TArrayF(fNcomps+1);
-    for(Int_t i=0; i<=fNcomps; i++) {
-      Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
-      (*fGaus)[i] = exp(-((x*x)/2));
- //     cout << "fGaus[" << i << "]: " << fGaus->At(i) << endl;
+    void SetElectronics(Int_t p1=1) {// Electronics: Pascal (1) or OLA (2)
+       fElectronics=p1;}
+    Int_t Electronics() {// Electronics: 1 = Pascal; 2 = OLA
+       return fElectronics;}
+    void    SetMaxAdc(Float_t p1=1024.) {// Adc-count saturation value
+       fMaxAdc=p1;}
+    Float_t MaxAdc()  {// Get maximum Adc-count value
+       return fMaxAdc;}
+    void    SetChargeLoss(Float_t p1=0.0) {
+       // Set Linear Charge Loss Steepness  // 0.01 for 20%
+       fChargeLoss=p1;}
+    Float_t ChargeLoss(){// Get Charge Loss Coefficient
+       return fChargeLoss;}
+    void    SetDynamicRange(Float_t p1=132.) {// Set Dynamic Range
+       fDynamicRange=p1;}
+    Float_t DynamicRange(){// Get Dynamic Range
+       return fDynamicRange;}
+    void    SetDiffCoeff(Float_t p1=3.23,Float_t p2=30.) {
+       // Diffusion coefficients
+       fDiffCoeff=p1;fDiffCoeff1=p2;}
+    void DiffCoeff(Float_t&diff,Float_t&diff1) {// Get diffusion coefficients
+       diff = fDiffCoeff;diff1 = fDiffCoeff1;}
+    void    SetDriftSpeed(Float_t p1=7.3) {// Drift velocity
+       fDriftSpeed=p1;}
+    Float_t DriftSpeed() {// drift speed
+       return fDriftSpeed;}
+    void    SetTemperature(Float_t p1=23.) {// Temperature
+       fTemperature=p1;}
+    Float_t Temperature() {// Get temperature
+       return fTemperature;}
+    void    SetDataType(const char *data="simulated") {
+       // Type of data - real or simulated
+       fDataType=data;}
+    const char  *DataType() const {// Get data type
+       return fDataType.Data();}
+    void SetParamOptions(const char *opt1="same",const char *opt2="same"){
+       // Parameters: "same" or read from "file" 
+       fParam1=opt1; fParam2=opt2;}
+    void   ParamOptions(char *opt1,char *opt2) {// options
+       strcpy(opt1,fParam1.Data()); strcpy(opt2,fParam2.Data());}
+    void  SetNoiseParam(Float_t n=10., Float_t b=20.){
+       // Noise and baseline  // 10 for ALICE with beam test measurements 2001
+       fNoise=n; fBaseline=b;}
+    void  SetNoiseAfterElectronics(Float_t n=2.38){
+       // Noise after electronics (ADC units)
+       // 2.36 for ALICE from beam test measurements 2001
+       fNoiseAfterEl=n;}
+    void  GetNoiseParam(Float_t &n, Float_t &b) {// get noise param
+       n=fNoise; b=fBaseline;}
+    Float_t  GetNoiseAfterElectronics(){
+       // Noise after electronics (ADC units)
+       return fNoiseAfterEl;}
+    void  SetJitterError(Float_t jitter=20) {
+       // set Jitter error (20 um for ALICE from beam test measurements 2001)
+       fJitterError=jitter;}
+    Float_t  JitterError() {// set Jitter error
+       return fJitterError;}
+    void  SetDo10to8(Bool_t bitcomp=kTRUE) {
+       // set the option for 10 to 8 bit compression
+       fBitComp = bitcomp;}
+    Bool_t Do10to8() {// get 10 to 8 compression option
+       return fBitComp;}
+    void    SetZeroSupp (const char *opt="1D") {
+       // Zero-suppression option - could be 1D, 2D or non-ZS 
+       fOption=opt;}
+    const char *ZeroSuppOption() const {// Get zero-suppression option
+       return fOption.Data();}
+    void  SetMinVal(Int_t mv=4) {
+       // Min value used in 2D - could be used as a threshold setting
+       fMinVal = mv;}
+    Int_t  MinVal() {// min val
+       return fMinVal;}
+    void   SetFilenames(const char *f1="",const char *f2="",const char *f3=""){
+       // Set filenames - input, output, parameters ....
+       fFileName1=f1; fFileName2=f2; fFileName3=f3;}
+    void   Filenames(char *input,char *baseline,char *param) {// Filenames
+       strcpy(input,fFileName1.Data());  strcpy(baseline,fFileName2.Data());  
+       strcpy(param,fFileName3.Data());}
+    void  SetOutputOption(Bool_t write=kFALSE) {// set output option
+       fWrite = write;}
+    Bool_t OutputOption()  {// output option
+       return fWrite;}
+    // 
+    // Compression parameters
+    void  SetCompressParam(Int_t cp[8]); 
+    void  GiveCompressParam(Int_t *x);
+    //
+    // Detector type response methods
+    void    SetNSigmaIntegration(Float_t p1=3.) {
+       // Set number of sigmas over which cluster disintegration is performed
+       fNsigmas=p1;}
+    Float_t NSigmaIntegration() {
+       // Get number of sigmas over which cluster disintegration is performed
+       return fNsigmas;}
+    void SetNLookUp(Int_t p1=121) {
+       // Set number of sigmas over which cluster disintegration is performed
+       fNcomps=p1;
+       fGaus = new TArrayF(fNcomps+1);
+       for(Int_t i=0; i<=fNcomps; i++) {
+           Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
+           (*fGaus)[i] = exp(-((x*x)/2));
+           //     cout << "fGaus[" << i << "]: " << fGaus->At(i) << endl;
+       }
     }
-  }
     // Get number of intervals in which the gaussian lookup table is divided
-  Int_t GausNLookUp() {return fNcomps;}
-  
-  Float_t IntPH(Float_t eloss) {
-    // Pulse height from scored quantity (eloss)
-    return 0.;
-  }
-  Float_t IntXZ(AliITSsegmentation *) {
-    // Charge disintegration 
-    return 0.;
-  }
-  Float_t GausLookUp(Int_t i) {
-    if(i<0 || i>=fNcomps) return 0.;
-    return fGaus->At(i);
-  }
-  void SetDeadChannels(Int_t nmodules=0, Int_t nchips=0, Int_t nchannels=0);
-
-  Int_t GetDeadModules() { return fDeadModules; }
-  Int_t GetDeadChips() { return fDeadChips; }
-  Int_t GetDeadChannels() { return fDeadChannels; }
-  Float_t Gain( Int_t mod, Int_t chip, Int_t ch) 
-    { return fGain[mod][chip][ch]; }
-
-  // these functions should be move to AliITSsegmentationSDD
-  const Int_t Modules() const { return fModules; }     // Total number of SDD modules
-  const Int_t Chips() const { return fChips; }         // Number of chips/module
-  const Int_t Channels() const { return fChannels; }    // Number of channels/chip
-  //********
-  
-  void    PrintGains();
-  void    Print();
-
-
-private:
+    Int_t GausNLookUp() {return fNcomps;}
+    Float_t IntPH(Float_t eloss) {// Pulse height from scored quantity (eloss)
+       return 0.;}
+    Float_t IntXZ(AliITSsegmentation *) {// Charge disintegration 
+       return 0.;}
+    Float_t GausLookUp(Int_t i) {
+       if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);}
+    void SetDeadChannels(Int_t nmodules=0, Int_t nchips=0, Int_t nchannels=0);
+    Int_t GetDeadModules() { return fDeadModules; }
+    Int_t GetDeadChips() { return fDeadChips; }
+    Int_t GetDeadChannels() { return fDeadChannels; }
+    Float_t Gain(Int_t mod,Int_t chip,Int_t ch){return fGain[mod][chip][ch]; }
+    // these functions should be move to AliITSsegmentationSDD
+    const Int_t Modules() const{return fModules;}// Total number of SDD modules
+    const Int_t Chips() const{return fChips;} // Number of chips/module
+    const Int_t Channels() const { return fChannels;}// Number of channels/chip
+    //********
+    void    PrintGains();
+    void    Print();
 
-  AliITSresponseSDD(const AliITSresponseSDD &source); // copy constructor
-  AliITSresponseSDD& operator=(const AliITSresponseSDD &source); // ass. op.
-    
-protected:
-  // these statis const should be move to AliITSsegmentationSDD
-  static const Int_t fModules = 520;     // Total number of SDD modules
-  static const Int_t fChips = 4;        // Number of chips/module
-  static const Int_t fChannels = 64;    // Number of channels/chip
-  //*******
-  
-  Int_t fDeadModules;                                  // Total number of dead SDD modules
-  Int_t fDeadChips;                                    // Number of dead chips
-  Int_t fDeadChannels;                                 // Number of dead channels
-  Float_t   fGain[fModules][fChips][fChannels];   // Array for channel gains
+ private:
+    AliITSresponseSDD(const AliITSresponseSDD &source); // copy constructor
+    AliITSresponseSDD& operator=(const AliITSresponseSDD &source); // ass. op.
 
-  Int_t     fCPar[8];        // Hardware compression parameters
-  Float_t   fNoise;          // Noise
-  Float_t   fBaseline;       // Baseline
-  Float_t   fNoiseAfterEl;   // Noise after electronics
-  Float_t   fDynamicRange;   // Set Dynamic Range 
-  Float_t   fChargeLoss;     // Set Linear Coefficient for Charge Loss 
-  Float_t   fTemperature;    // Temperature 
-  Float_t   fDriftSpeed;     // Drift velocity
-  Int_t     fElectronics;    // Electronics
-  
-  Float_t    fMaxAdc;        // Adc saturation value
-  Float_t    fDiffCoeff;     // Diffusion Coefficient (scaling the time)
-  Float_t    fDiffCoeff1;    // Diffusion Coefficient (constant term)
-  Float_t    fNsigmas;       // Number of sigmas over which charge disintegration 
-                             // is performed 
-  TArrayF   *fGaus;          // Gaussian lookup table for signal generation
-  Int_t      fNcomps;        // Number of samplings along the gaussian
-  
-  Int_t      fMinVal;        // Min value used in 2D zero-suppression algo
-  
-  Bool_t     fWrite;         // Write option for the compression algorithms
-  Bool_t     fBitComp;       // 10 to 8 bit compression option
+ protected:
+    // these statis const should be move to AliITSsegmentationSDD
+    static const Int_t fModules = 520;     // Total number of SDD modules
+    static const Int_t fChips = 4;        // Number of chips/module
+    static const Int_t fChannels = 64;    // Number of channels/chip
+    //*******
+    Int_t fDeadModules;                   // Total number of dead SDD modules
+    Int_t fDeadChips;                     // Number of dead chips
+    Int_t fDeadChannels;                  // Number of dead channels
+    Float_t   fGain[fModules][fChips][fChannels];   // Array for channel gains
+    Int_t     fCPar[8];        // Hardware compression parameters
+    Float_t   fNoise;          // Noise
+    Float_t   fBaseline;       // Baseline
+    Float_t   fNoiseAfterEl;   // Noise after electronics
+    Float_t   fJitterError;    // jitter error
+    Float_t   fDynamicRange;   // Set Dynamic Range 
+    Float_t   fChargeLoss;     // Set Linear Coefficient for Charge Loss 
+    Float_t   fTemperature;    // Temperature 
+    Float_t   fDriftSpeed;     // Drift velocity
+    Int_t     fElectronics;    // Electronics
+    Float_t    fMaxAdc;        // Adc saturation value
+    Float_t    fDiffCoeff;     // Diffusion Coefficient (scaling the time)
+    Float_t    fDiffCoeff1;    // Diffusion Coefficient (constant term)
+    Float_t    fNsigmas;   // Number of sigmas over which charge disintegration
+                               // is performed
+    TArrayF   *fGaus;          // Gaussian lookup table for signal generation
+    Int_t      fNcomps;        // Number of samplings along the gaussian
+    Int_t      fMinVal;        // Min value used in 2D zero-suppression algo
+    Bool_t     fWrite;         // Write option for the compression algorithms
+    Bool_t     fBitComp;       // 10 to 8 bit compression option
+    TString    fOption;        // Zero-suppresion option (1D, 2D or none)
+    TString    fParam1;        // Read baselines from file option
+    TString    fParam2;        // Read compression algo thresholds from file
+    TString         fDataType;         // data type - real or simulated
+    TString         fFileName1;        // input keys : run, module #
+    TString         fFileName2;        // baseline & noise val or output code
+                                       // signal or monitored bgr.
+    TString         fFileName3;        // param values or output coded signal
 
-  TString    fOption;        // Zero-suppresion option (1D, 2D or none)
-  TString    fParam1;        // Read baselines from file option
-  TString    fParam2;        // Read compression algo thresholds from file 
-  
-  TString         fDataType;         // data type - real or simulated
-  TString         fFileName1;        // input keys : run, module #
-  TString         fFileName2;        // baseline & noise val or output coded                                                 // signal or monitored bgr.
-  TString         fFileName3;        // param values or output coded signal 
-  
-  ClassDef(AliITSresponseSDD,3) // SDD response 
+    ClassDef(AliITSresponseSDD,2) // SDD response 
     
     };
 #endif
-    
index eed81fe0d501e1db062b52a8cde657d3f8668851..e3a3e752e14e60d865c722864d1caa8b413b07d4 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+/*
+  $Id$
+  $Log$
+ */
 
 #include <iostream.h>
 #include <stdlib.h>
@@ -142,6 +146,8 @@ AliITSsimulationSDD::AliITSsimulationSDD(){
     fHis           = 0;
 //    fpList         = 0;
     fHitMap2       = 0;
+    fHitSigMap2    = 0;
+    fHitNoiMap2    = 0;
     fElectronics   = 0;
     fStream        = 0;
     fInZR          = 0;
@@ -186,6 +192,8 @@ AliITSsimulationSDD::AliITSsimulationSDD(AliITSsegmentation *seg,
     fHis           = 0;
 //    fpList         = 0;
     fHitMap2       = 0;
+    fHitSigMap2    = 0;
+    fHitNoiMap2    = 0;
     fElectronics   = 0;
     fStream        = 0;
     fInZR          = 0;
@@ -214,7 +222,9 @@ void AliITSsimulationSDD::Init(AliITSsegmentationSDD *seg,
 
     fpList = new AliITSpList( fSegmentation->Npz(),
                               fScaleSize*fSegmentation->Npx() );
-    fHitMap2 = new AliITSMapA2(fSegmentation,fScaleSize,1);
+    fHitSigMap2 = new AliITSMapA2(fSegmentation,fScaleSize,1);
+    fHitNoiMap2 = new AliITSMapA2(fSegmentation,fScaleSize,1);
+    fHitMap2 = fHitSigMap2;
 
     fNofMaps = fSegmentation->Npz();
     fMaxNofSamples = fSegmentation->Npx();
@@ -296,7 +306,8 @@ AliITSsimulationSDD::~AliITSsimulationSDD() {
     // destructor
 
 //    delete fpList;
-    delete fHitMap2;
+    delete fHitSigMap2;
+    delete fHitNoiMap2;
     delete fStream;
     delete fElectronics;
 
@@ -323,7 +334,8 @@ void AliITSsimulationSDD::InitSimulationModule( Int_t module, Int_t event ) {
 void AliITSsimulationSDD::ClearMaps() {
     // clear maps
     fpList->ClearMap();
-    fHitMap2->ClearMap();
+    fHitSigMap2->ClearMap();
+    fHitNoiMap2->ClearMap();
 }
 //______________________________________________________________________
 void AliITSsimulationSDD::SDigitiseModule( AliITSmodule *mod, Int_t md, Int_t ev){
@@ -336,14 +348,20 @@ void AliITSsimulationSDD::SDigitiseModule( AliITSmodule *mod, Int_t md, Int_t ev
 
     InitSimulationModule( md, ev );
     HitsToAnalogDigits( mod );
+    ChargeToSignal( kFALSE ); // - Process signal without add noise
+    fHitMap2 = fHitNoiMap2;   // - Swap to noise map
+    ChargeToSignal( kTRUE );  // - Process only noise
+    fHitMap2 = fHitSigMap2;   // - Return to signal map
     WriteSDigits();
     ClearMaps();
 }
 //______________________________________________________________________
-/*void AliITSsimulationSDD::AddSDigitsToModule( TClonesArray *pItemArray, Int_t mask ) {
+Bool_t AliITSsimulationSDD::AddSDigitsToModule( TClonesArray *pItemArray, Int_t mask ) {
     // Add Summable digits to module maps.
-    Int_t nItems = pItemArray->GetEntries();
-
+    Int_t    nItems = pItemArray->GetEntries();
+    Double_t maxadc = fResponse->MaxAdc();
+    Bool_t sig = kFALSE;
+    
     // cout << "Adding "<< nItems <<" SDigits to module " << fModule << endl;
     for( Int_t i=0; i<nItems; i++ ) {
         AliITSpListItem * pItem = (AliITSpListItem *)(pItemArray->At( i ));
@@ -351,12 +369,21 @@ void AliITSsimulationSDD::SDigitiseModule( AliITSmodule *mod, Int_t md, Int_t ev
             Error( "AliITSsimulationSDD",
                    "Error reading, SDigits module %d != current module %d: exit\n",
                     pItem->GetModule(), fModule );
-            return;
+            return sig;
         } // end if
-        
-        fpList->AddItemTo( mask, pItem );
+
+       if(pItem->GetSignal()>0.0 ) sig = kTRUE;
+        fpList->AddItemTo( mask, pItem ); // Add SignalAfterElect + noise
+        AliITSpListItem * pItem2 = fpList->GetpListItem( pItem->GetIndex() );
+        Double_t sigAE = pItem2->GetSignalAfterElect();
+        if( sigAE >= maxadc ) sigAE = maxadc-1; // avoid overflow signal
+        Int_t ia;
+        Int_t it;
+        fpList->GetMapIndex( pItem->GetIndex(), ia, it );
+        fHitMap2->SetHit( ia, it, sigAE );
     }
-}*/
+    return sig;
+}
 //______________________________________________________________________
 void AliITSsimulationSDD::FinishSDigitiseModule() {
     // digitize module using the "slow" detector simulator from
@@ -374,13 +401,32 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
     InitSimulationModule( md, ev );
 
     if( !nhits && fCheckNoise ) {
-        ChargeToSignal();
+        ChargeToSignal( kTRUE );  // process noise
         GetNoise();
         ClearMaps();
         return;
     } else 
         if( !nhits ) return;
+        
     HitsToAnalogDigits( mod );
+    ChargeToSignal( kTRUE );  // process signal + noise
+
+    for( Int_t i=0; i<fNofMaps; i++ ) {
+        for( Int_t j=0; j<fMaxNofSamples; j++ ) {
+            Int_t jdx = j*fScaleSize;
+            Int_t index = fpList->GetHitIndex( i, j );
+            AliITSpListItem pItemTmp2( fModule, index, 0. );
+            // put the fScaleSize analog digits in only one
+            for( Int_t ik=0; ik<fScaleSize; ik++ ) {
+                AliITSpListItem *pItemTmp = fpList->GetpListItem( i, jdx+ik );
+                if( pItemTmp == 0 ) continue;
+                pItemTmp2.Add( pItemTmp );
+            }
+            fpList->DeleteHit( i, j );
+            fpList->AddItemTo( 0, &pItemTmp2 );
+        }
+    }
+
     FinishDigits();
     ClearMaps();
 }
@@ -388,11 +434,6 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
 void AliITSsimulationSDD::FinishDigits() {
     // introduce the electronics effects and do zero-suppression if required
 
-    // Fill maps from fpList.
-    Int_t maxIndex = fpList->GetEntries();
-    for(Int_t i=0;i<maxIndex;i++) fHitMap2->SetHit(i,fpList->GetSignal(i));
-
-    ChargeToSignal();
     ApplyDeadChannels();
     if( fCrosstalkFlag ) ApplyCrosstalk();
 
@@ -421,6 +462,7 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
     Double_t eVpairs    = 3.6;  // electron pair energy eV.
     Float_t  nsigma     = fResponse->NSigmaIntegration(); //
     Int_t    nlookups   = fResponse->GausNLookUp();       //
+    Float_t  jitter     = ((AliITSresponseSDD*)fResponse)->JitterError(); // 
 
     // Piergiorgio's part (apart for few variables which I made float
     // when i thought that can be done
@@ -471,6 +513,7 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
     for(ii=0; ii<nhits; ii++) {
         if(!mod->LineSegmentL(ii,xL[0],dxL[0],xL[1],dxL[1],xL[2],dxL[2],
                               depEnergy,itrack)) continue;
+        xL[0] += 0.0001*gRandom->Gaus( 0, jitter ); //
         depEnergy  *= kconv;
         hitDetector = mod->GetDet();
         //tof         = 1.E+09*(mod->GetHit(ii)->GetTOF()); // tof in ns.
@@ -641,6 +684,9 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
                     timeAmplitude *= norm;
                     timeAmplitude *= 10;
 //                    ListOfFiredCells(arg,timeAmplitude,alst,padr);
+                    Double_t charge = timeAmplitude;
+                    charge += fHitMap2->GetSignal(index,it-1);
+                    fHitMap2->SetHit(index, it-1, charge);
                     fpList->AddSignal(index,it-1,itrack,ii-1,
                                      mod->GetIndex(),timeAmplitude);
                 } // end if anodeAmplitude and loop over time in window
@@ -758,34 +804,24 @@ void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
     digits[1] = j;
     digits[2] = signal;
 
-    Int_t jdx = j*fScaleSize;
-    AliITSpListItem pItem;
-
-    // put the fScaleSize analog digits in only one
-    for( Int_t ik=0; ik<fScaleSize; ik++ ) {
-        AliITSpListItem* pItemTmp = fpList->GetpListItem( i, jdx+ik );
-        if( pItemTmp == 0 ) continue;
-        Double_t sig = 0.0;
-        for( Int_t l=0; l<pItemTmp->GetNsignals(); l++ ) {
-            Double_t signalT = pItemTmp->GetSignal( l );
-        //    if( signalT <= 0.0 ) break; // no more signals
-            sig += signalT;
-            Int_t track      = pItemTmp->GetTrack( l );
-            Int_t hit        = pItemTmp->GetHit( l );
-            pItem.AddSignal( track, hit, -1, -1, signalT );
+    AliITSpListItem *pItem = fpList->GetpListItem( i, j );
+    if( pItem == 0 ) {
+        phys = 0.0;
+        for( Int_t l=0; l<3; l++ ) {
+            tracks[l]  = 0;
+            hits[l]    = 0;
+            charges[l] = 0.0;
+        }
+    } else {
+        Int_t idtrack =  pItem->GetTrack( 0 );
+        if( idtrack >= 0 ) phys = pItem->GetSignal();  
+        else phys = 0.0;
+
+        for( Int_t l=0; l<3; l++ ) {
+            tracks[l]  = pItem->GetTrack( l );
+            hits[l]    = pItem->GetHit( l );
+            charges[l] = pItem->GetSignal( l );
         }
-        // add to noise : total signal - sum of signal tracks
-        pItem.AddNoise( -1, -1, pItemTmp->GetSignal() - sig );
-    }
-
-    Int_t idtrack =  pItem.GetTrack( 0 );
-    if( idtrack >= 0 ) phys = pItem.GetSumSignal();  
-    else phys = 0;
-
-    for( Int_t l=0; l<3; l++ ) {
-        tracks[l]  = pItem.GetTrack( l );
-        hits[l]    = pItem.GetHit( l );
-        charges[l] = pItem.GetSignal( l );
     }
 
     fITS->AddSimDigit( 1, phys, digits, tracks, hits, charges ); 
@@ -914,7 +950,7 @@ void AliITSsimulationSDD::SortTracks(Int_t *tracks,Float_t *charges,
 }
 */
 //______________________________________________________________________
-void AliITSsimulationSDD::ChargeToSignal() {
+void AliITSsimulationSDD::ChargeToSignal(Bool_t bAddNoise) {
     // add baseline, noise, electronics and ADC saturation effects
 
     char opt1[20], opt2[20];
@@ -937,8 +973,10 @@ void AliITSsimulationSDD::ChargeToSignal() {
             if (read && i<fNofMaps) GetAnodeBaseline(i,baseline,noise);
             for(k=0; k<fScaleSize*fMaxNofSamples; k++) {
                 fInZR[k]  = fHitMap2->GetSignal(i,k);
-                contrib   = (baseline + noise*gRandom->Gaus());
-                fInZR[k] += contrib;
+                if( bAddNoise ) {
+                    contrib   = (baseline + noise*gRandom->Gaus());
+                    fInZR[k] += contrib;
+                }
             } // end for k
             for(k=0; k<fMaxNofSamples; k++) {
                 Double_t newcont = 0.;
@@ -963,8 +1001,10 @@ void AliITSsimulationSDD::ChargeToSignal() {
         if  (read && i<fNofMaps) GetAnodeBaseline(i,baseline,noise);
         for(k=0; k<fScaleSize*fMaxNofSamples; k++) {
             fInZR[k]  = fHitMap2->GetSignal(i,k);
-            contrib   = (baseline + noise*gRandom->Gaus());
-            fInZR[k] += contrib;
+            if( bAddNoise ) {
+                contrib   = (baseline + noise*gRandom->Gaus());
+                fInZR[k] += contrib;
+            }
             fInZI[k]  = 0.;
         } // end for k
         FastFourierTransform(fElectronics,&fInZR[0],&fInZI[0],1);
@@ -1227,7 +1267,7 @@ Int_t AliITSsimulationSDD::Convert8to10(Int_t signal) const {
         else  return (256+((signal-192)<<3)+4);
     } // end if signal < 224
     if (TMath::Odd(signal)) return (512+((signal-224)<<4)+7);
-    return (512+((signal-224)<<4)+7);
+    return (512+((signal-224)<<4)+8);
 }
 
 /*
@@ -1677,19 +1717,27 @@ Float_t AliITSsimulationSDD::GetNoise() {
 //______________________________________________________________________
 void AliITSsimulationSDD::WriteSDigits(){
     // Fills the Summable digits Tree
-    Int_t i,ni,j,nj;
     static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
 
-    fpList->GetMaxMapIndex( ni, nj );
-    for( i=0; i<ni; i++ )
-        for( j=0; j<nj; j++ ) {
-//            if( fpList->GetSignalOnly( i, j ) > 0.5*fT1[0] ) { 
-            if( fpList->GetpListItem( i, j ) != 0 )
-                // above small threshold.
-                aliITS->AddSumDigit( *(fpList->GetpListItem( i, j ) ) );
-//                cout << "pListSDD: " << *(pList->GetpListItem(i,j)) << endl;
-//            } // end if
-        } // end for i,j
+    for( Int_t i=0; i<fNofMaps; i++ ) {
+        for( Int_t j=0; j<fMaxNofSamples; j++ ) {
+            Double_t sig = fHitMap2->GetSignal( i, j );
+            if( sig > 0.2 ) {
+                Int_t jdx = j*fScaleSize;
+                Int_t index = fpList->GetHitIndex( i, j );
+                AliITSpListItem pItemTmp2( fModule, index, 0. );
+                // put the fScaleSize analog digits in only one
+                for( Int_t ik=0; ik<fScaleSize; ik++ ) {
+                    AliITSpListItem *pItemTmp = fpList->GetpListItem( i, jdx+ik );
+                    if( pItemTmp == 0 ) continue;
+                    pItemTmp2.Add( pItemTmp );
+                }
+                pItemTmp2.AddSignalAfterElect( fModule, index, sig );
+                pItemTmp2.AddNoise( fModule, index, fHitNoiMap2->GetSignal( i, j ) );         
+                aliITS->AddSumDigit( pItemTmp2 );
+            } // end if (sig > 0.2)
+        }
+    }
     return;
 }
 //______________________________________________________________________
index 0ff1b91acc2fc3512d6281fb91523add87b26f33..91d4fd98f399614f7bcc97f81228ea2e64391a00 100644 (file)
@@ -85,7 +85,7 @@ class AliITSsimulationSDD : public AliITSsimulation {
     virtual void SetFileName(const char *filnam) {fFileName=filnam;}
 
     // add baseline, noise, electronics and ADC saturation effects
-    void ChargeToSignal();
+    void ChargeToSignal(Bool_t bAddNoise=kFALSE);
     // add dead channels
     void ApplyDeadChannels();
     // add crosstalk effect
@@ -97,8 +97,8 @@ class AliITSsimulationSDD : public AliITSsimulation {
     void ClearMaps();
     // Summable Digitses a SDD module
     void SDigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev);
-//    // Add Summable digits to module maps.
-//    void AddSDigitsToModule( TClonesArray *pItemArray, Int_t mask );
+    // Add Summable digits to module maps.
+    Bool_t AddSDigitsToModule( TClonesArray *pItemArray, Int_t mask );
     // digitize module from the sum of summable digits.
     void FinishSDigitiseModule();
     // Writes summable digits
@@ -149,6 +149,8 @@ class AliITSsimulationSDD : public AliITSsimulation {
     AliITS         *fITS;          //! local pointer to ITS
 //    AliITSMapA1    *fHitMap1;      //! local pointer to map of digits
     AliITSMapA2    *fHitMap2;      //! local pointer to map of signals
+    AliITSMapA2    *fHitSigMap2;   //! local pointer to map of signals
+    AliITSMapA2    *fHitNoiMap2;   //! local pointer to map of signals
 //    AliITSpList    *fpList;        //! 
 //    TObjArray      *falist;        //
 //    TClonesArray   *fpadr;         //