Major changes in supppor of PreDigits (SDigits). Changes made with will make
authornilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Oct 2001 22:44:31 +0000 (22:44 +0000)
committernilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Oct 2001 22:44:31 +0000 (22:44 +0000)
it easier to suppor expected changes in AliITSHit class. Added use of new
class AliITSpList. Both SPD and SDD have added effects of Dead Channels. Both
of these will require addtional work as data bases of detectors and the like
are developed.

ITS/AliITSsimulation.h
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h
ITS/AliITSsimulationSPD.cxx
ITS/AliITSsimulationSPD.h
ITS/AliITSsimulationSSD.cxx
ITS/AliITSsimulationSSD.h

index 252b51a..b45c6a8 100644 (file)
@@ -36,7 +36,10 @@ class AliITSsimulation : public TObject {
     AliITSsimulation(const AliITSsimulation &source);
     // Assignment opporator. See detector specific implementation.
     virtual AliITSsimulation& operator=(const AliITSsimulation &source);
-    // digitize module using the "slow" detector simulator.
+    // digitize module using the "slow" detector simulator creating
+    // summable digits.
+    virtual void SDigitiseModule(AliITSmodule *mod,Int_t module,Int_t event){;}
+    // digitize module using the "slow" detector simulator creating digits.
     virtual void DigitiseModule(AliITSmodule *mod,Int_t module,Int_t event) {;}
     // digitizes module using the "fast" detector simulator.
     virtual void CreateFastRecPoints(AliITSmodule *mod,Int_t module,
@@ -44,8 +47,8 @@ class AliITSsimulation : public TObject {
 
 protected:
 
-  AliITSresponse      *fResponse;       // response
-  AliITSsegmentation  *fSegmentation;   // segmentation
+  AliITSresponse      *fResponse;       //! response
+  AliITSsegmentation  *fSegmentation;   //! segmentation
 
   ClassDef(AliITSsimulation,1)  // Simulation base class 
     
index 11b164b..61be309 100644 (file)
@@ -35,6 +35,7 @@
 #include "AliITShit.h"
 #include "AliITSdigit.h"
 #include "AliITSmodule.h"
+#include "AliITSpList.h"
 #include "AliITSMapA1.h"
 #include "AliITSMapA2.h"
 #include "AliITSetfSDD.h"
@@ -42,6 +43,8 @@
 #include "AliITSHuffman.h"
 #include "AliITSsegmentation.h"
 #include "AliITSresponse.h"
+#include "AliITSsegmentationSDD.h"
+#include "AliITSresponseSDD.h"
 #include "AliITSsimulationSDD.h"
 
 ClassImp(AliITSsimulationSDD)
@@ -75,7 +78,6 @@ Int_t power(Int_t b, Int_t e) {
 void FastFourierTransform(AliITSetfSDD *alisddetf,Double_t *real,
                           Double_t *imag,Int_t direction) {
     // Do a Fast Fourier Transform
-    //printf("FFT: direction %d\n",direction);
 
     Int_t samples = alisddetf->GetSamples();
     Int_t l = (Int_t) ((log((Float_t) samples)/log(2.))+0.5);
@@ -165,29 +167,48 @@ AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source){
     // Copy constructor to satify Coding roules only.
 
     if(this==&source) return;
-    printf("Not allowed to make a copy of AliITSsimulationSDD "
-          "Using default creater instead\n");
+    Error("AliITSsimulationSSD","Not allowed to make a copy of "
+         "AliITSsimulationSDD Using default creater instead");
     AliITSsimulationSDD();
 }
 //______________________________________________________________________
-AliITSsimulationSDD& AliITSsimulationSDD::operator=(AliITSsimulationSDD &source){
+AliITSsimulationSDD& AliITSsimulationSDD::operator=(AliITSsimulationSDD &src){
     // Assignment operator to satify Coding roules only.
 
-    if(this==&source) return *this;
-    printf("Not allowed to make a = with AliITSsimulationSDD "
-          "Using default creater instead\n");
+    if(this==&src) return *this;
+    Error("AliITSsimulationSSD","Not allowed to make a = with "
+         "AliITSsimulationSDD Using default creater instead");
     return *this ;
 }
 //______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsegmentation *seg,AliITSresponse *resp){
+AliITSsimulationSDD::AliITSsimulationSDD(AliITSsegmentation *seg,
+                                        AliITSresponse *resp){
+    // Standard Constructor
+
+
+    fResponse      = 0;
+    fSegmentation  = 0;
+    fHis           = 0;
+    fHitMap1       = 0;
+    fHitMap2       = 0;
+    fElectronics   = 0;
+    fStream        = 0;
+    fInZR          = 0;
+    fInZI          = 0;
+    fOutZR         = 0;
+    fOutZI         = 0;
+    fNofMaps       = 0;
+    fMaxNofSamples = 0;
+    fITS           = 0;
+    fTreeB         = 0;
+
+    Init((AliITSsegmentationSDD*)seg,(AliITSresponseSDD*)resp);
+}
+//______________________________________________________________________
+void AliITSsimulationSDD::Init(AliITSsegmentationSDD *seg,
+                              AliITSresponseSDD *resp){
     // Standard Constructor
 
-    fHitMap1      = 0;     // zero just in case of an error
-    fHitMap2      = 0;     // zero just in case of an error
-    fElectronics  = 0;     // zero just in case of an error
-    fStream       = 0;     // zero just in case of an error
-    fHis          = 0;
-    fTreeB        = 0;
     fResponse     = resp;
     fSegmentation = seg;
     SetScaleFourier();
@@ -301,6 +322,37 @@ AliITSsimulationSDD::~AliITSsimulationSDD() {
     if(fOutZI) delete [] fOutZI;
 }
 //______________________________________________________________________
+void AliITSsimulationSDD::SDigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
+    // create maps to build the lists of tracks for each summable digit
+
+    TObjArray *fHits = mod->GetHits();
+    Int_t nhits      = fHits->GetEntriesFast();
+    fModule          = md;
+    fEvent           = ev;
+
+    if(!nhits) return;
+
+    AliITSpList *pList = new AliITSpList(2*fSegmentation->Npz(),
+                                        fScaleSize*fSegmentation->Npx());
+
+    // inputs to ListOfFiredCells.
+    TObjArray          *alist = new TObjArray();
+    fHitMap1->SetArray(alist);
+    static TClonesArray *padr = 0;
+    if(!padr)            padr = new TClonesArray("TVector",1000);
+
+    HitsToAnalogDigits(mod,alist,padr,pList);
+
+    WriteSDigits(pList);
+
+    // clean memory
+    alist->Delete();
+    delete alist;
+    padr->Delete();
+    fHitMap1->ClearMap();
+    fHitMap2->ClearMap();
+}
+//______________________________________________________________________
 void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
     // create maps to build the lists of tracks for each digit
 
@@ -316,13 +368,81 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
         return;
     } else if (!nhits) return;
 
+    AliITSpList *pList = new AliITSpList(2*fSegmentation->Npz(),
+                                        fScaleSize*fSegmentation->Npx());
+
+    // inputs to ListOfFiredCells.
+    TObjArray          *alist = new TObjArray();
+    fHitMap1->SetArray(alist);
+    static TClonesArray *padr = 0;
+    if(!padr)            padr = new TClonesArray("TVector",1000);
+
+    HitsToAnalogDigits(mod,alist,padr,pList);
+
+    FinishDigits(alist);
+
+    // clean memory
+    alist->Delete();
+    delete alist;
+    padr->Delete();
+    fHitMap1->ClearMap();
+    fHitMap2->ClearMap();
+}
+//______________________________________________________________________
+void AliITSsimulationSDD::SDigitsToDigits(AliITSpList *pList){
+    // Take Summable digits and create Digits.
+
     // inputs to ListOfFiredCells.
-    TObjArray *alist           = new TObjArray;
+    TObjArray          *alist = new TObjArray();
     fHitMap1->SetArray(alist);
     static TClonesArray *padr = 0;
     if(!padr)            padr = new TClonesArray("TVector",1000);
-    Int_t arg[6]              = {0,0,0,0,0,0};
+    Int_t              arg[6] = {0,0,0,0,0,0};
+    Double_t  timeAmplitude;
+    Int_t i,j;
+
+    // Fill maps from pList.
+    for(i=0;i<pList->GetMaxIndex();i++){
+       pList->GetMapIndex(i,arg[0],arg[1]);
+       for(j=0;j<pList->GetNEnteries();j++){
+           timeAmplitude = pList->GetTSignal(arg[0],arg[1],j);
+           if(timeAmplitude>0.0) continue;
+           arg[2] = pList->GetTrack(arg[0],arg[1],j);
+           arg[3] = pList->GetHit(arg[0],arg[1],j);
+           ListOfFiredCells(arg,timeAmplitude,alist,padr);
+       } // end for j
+       // Make sure map has full signal in it.
+       fHitMap2->SetHit(arg[0],arg[1],pList->GetSignal(arg[0],arg[1]));
+    } // end for i
+
+    FinishDigits(alist);
+
+    // clean memory
+    alist->Delete();
+    delete alist;
+    padr->Delete();
+    fHitMap1->ClearMap();
+    fHitMap2->ClearMap();
+}
+//______________________________________________________________________
+void AliITSsimulationSDD::FinishDigits(TObjArray *alist){
+    // introduce the electronics effects and do zero-suppression if required
+    Int_t nentries=alist->GetEntriesFast();
 
+    if(!nentries) return;
+    ChargeToSignal();
+    const char *kopt=fResponse->ZeroSuppOption();
+    ZeroSuppression(kopt);
+}
+//______________________________________________________________________
+void AliITSsimulationSDD::HitsToAnalogDigits(AliITSmodule *mod,TObjArray *alst,
+                                            TClonesArray *padr,
+                                            AliITSpList *pList){
+    // create maps to build the lists of tracks for each digit
+
+    TObjArray *fHits    = mod->GetHits();
+    Int_t      nhits    = fHits->GetEntriesFast();
+    Int_t      arg[6]   = {0,0,0,0,0,0};
     Int_t    dummy      = 0;
     Int_t    nofAnodes  = fNofMaps/2;
     Float_t  sddLength  = fSegmentation->Dx();
@@ -397,7 +517,8 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
        // continue if the particle did not lose energy
        // passing through detector
        if (!depEnergy) {
-           cout << "This particle has passed without losing energy!" << endl;
+           Warning("HitsToAnalogDigits", 
+                   "This particle has passed without losing energy!");
            continue;
        } // end if !depEnergy
 
@@ -408,7 +529,7 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
        if(drPath < 0) drPath = -drPath;
        drPath = sddLength-drPath;
        if(drPath < 0) {
-           cout << "Warning: negative drift path " << drPath << endl;
+           Warning("HitsToAnalogDigits","negative drift path %e",drPath);
            continue;
        } // end if drPath < 0
 
@@ -436,7 +557,8 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
            driftPath = sddLength-driftPath;
            detector  = 2*(hitDetector-1) + iWing;
            if(driftPath < 0) {
-               cout << "Warning: negative drift path " << driftPath << endl;
+               Warning("HitsToAnalogDigits","Warning: negative drift path %e",
+                       driftPath);
                continue;
            } // end if driftPath < 0
 
@@ -448,17 +570,19 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
            // the defusion.
            // timeSample = (Int_t) (fScaleSize*(drTime+tof)/timeStep + 1);
            if(timeSample > fScaleSize*fMaxNofSamples) {
-               cout << "Warning: Wrong Time Sample: " << timeSample << endl;
+               Warning("HItsToAnalogDigits","Wrong Time Sample: %e",
+                       timeSample);
                continue;
            } // end if timeSample > fScaleSize*fMaxNoofSamples
 
            //   Anode
            xAnode = 10000.*(avAnode)/anodePitch + nofAnodes/2;  // +1?
            if(xAnode*anodePitch > sddWidth || xAnode*anodePitch < 0.) 
-                         cout << "Warning: Z = " << xAnode*anodePitch << endl;
+                         Warning("HitsToAnalogDigits","Z = %e",
+                                 xAnode*anodePitch);
            iAnode = (Int_t) (1.+xAnode); // xAnode?
            if(iAnode < 1 || iAnode > nofAnodes) {
-               cout << "Warning: Wrong iAnode: " << iAnode << endl;
+               Warning("HitToAnalogDigits","Wrong iAnode: %d",iAnode);
                continue;
            } // end if iAnode < 1 || iAnode > nofAnodes
 
@@ -510,7 +634,10 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
            // Spread the charge in the anode-time window
            for(ka=jamin; ka <=jamax; ka++) {
                ia = (ka-1)/(fScaleSize*nsplit) + 1;
-               if(ia <= 0) { cout << "Warning: ia < 1: " << endl; continue; }
+               if(ia <= 0) {
+                   Warning("HitsToAnalogDigits","ia < 1: ");
+                   continue;
+               } // end if
                if(ia > nofAnodes) ia = nofAnodes;
                aExpo     = (aStep*(ka-0.5)-aConst);
                if(TMath::Abs(aExpo) > nsigma)  anodeAmplitude = 0.;
@@ -522,7 +649,10 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
                index = ((detector+1)%2)*nofAnodes+ia-1;
                if(anodeAmplitude) for(kt=jtmin; kt<=jtmax; kt++) {
                    it = (kt-1)/nsplit+1;  // it starts from 1
-                   if(it<=0){cout<<"Warning: it < 1: "<<endl; continue;} 
+                   if(it<=0){
+                       Warning("HitsToAnalogDigits","it < 1:");
+                       continue;
+                   } // end if 
                    if(it>fScaleSize*fMaxNofSamples)
                                                it = fScaleSize*fMaxNofSamples;
                    tExpo    = (tStep*(kt-0.5)-tConst);
@@ -539,26 +669,13 @@ void AliITSsimulationSDD::DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev){
                    arg[3]         = ii-1; // hit number.
                    timeAmplitude *= norm;
                    timeAmplitude *= 10;
-                   ListOfFiredCells(arg,timeAmplitude,alist,padr);
+                   ListOfFiredCells(arg,timeAmplitude,alst,padr);
+                   pList->AddSignal(index,it,itrack,ii-1,
+                                    mod->GetIndex(),timeAmplitude);
                } // end if anodeAmplitude and loop over time in window
            } // loop over anodes in window
        } // end loop over "sub-hits"
     } // end loop over hits
-
-    // introduce the electronics effects and do zero-suppression if required
-    Int_t nentries=alist->GetEntriesFast();
-    if (nentries) {
-       ChargeToSignal();
-       const char *kopt=fResponse->ZeroSuppOption();
-       ZeroSuppression(kopt);
-    } // end if netries
-
-    // clean memory
-    alist->Delete();
-    delete alist;
-    padr->Delete();
-    fHitMap1->ClearMap();
-    fHitMap2->ClearMap();
 }
 //______________________________________________________________________
 void AliITSsimulationSDD::ListOfFiredCells(Int_t *arg,Double_t timeAmplitude,
@@ -645,8 +762,7 @@ void AliITSsimulationSDD::ListOfFiredCells(Int_t *arg,Double_t timeAmplitude,
                trk[tr]   = Int_t(pptrk(0));
                htrk[tr]  = Int_t(pptrk(1));
                chtrk[tr] = (pptrk(2));
-               printf("nptracks %d \n",nptracks);
-                               // set printings
+               cout << "nptracks "<<nptracks << endl;
            } // end for tr
        } // end if nptracks
 #endif
@@ -690,7 +806,7 @@ void AliITSsimulationSDD::AddDigit(Int_t i, Int_t j, Int_t signal){
        TObjArray* trlist=(TObjArray*)obj->TrackList();
        Int_t nptracks=trlist->GetEntriesFast();
        if (nptracks > 20) {
-           cout<<"Attention - nptracks > 20 "<<nptracks<<endl;
+           Warning("AddDigit","nptracks=%d > 20 nptracks set to 20",nptracks);
            nptracks=20;
        } // end if nptracks > 20
        Int_t tr;
@@ -811,7 +927,9 @@ void AliITSsimulationSDD::ChargeToSignal() {
                } // end for kk
                newcont = maxcont;
                if (newcont >= maxadc) newcont = maxadc -1;
-               if(newcont >= baseline) cout << "newcont: " << newcont << endl;
+               if(newcont >= baseline){
+                   Warning("","newcont=%d>=baseline=%d",newcont,baseline);
+               } // end if
                // back to analog: ?
                fHitMap2->SetHit(i,k,newcont);
            }  // end for k
@@ -897,8 +1015,6 @@ void AliITSsimulationSDD::SetCompressParam(){
        fT1[i]  = cp[i+2];
        fT2[i]  = cp[i+4];
        fTol[i] = cp[i+6];
-//     printf("\n i, fD, fT1, fT2, fTol %d %d %d %d %d\n",
-//                                      i,fD[i],fT1[i],fT2[i],fTol[i]);
     } // end for i
 }
 //______________________________________________________________________
@@ -919,7 +1035,6 @@ void AliITSsimulationSDD::ReadBaseline(){
 //
     filtmp = gSystem->ExpandPathName(fFileName.Data());
     FILE *bline = fopen(filtmp,"r");
-//    printf("filtmp %s\n",filtmp);
     na = 0;
 
     if(bline) {
@@ -957,7 +1072,7 @@ Int_t AliITSsimulationSDD::Convert8to10(Int_t signal) const {
     // Undo the lossive 10 to 8 bit compression.
     // code from Davide C. and Albert W.
     if (signal < 0 || signal > 255) {
-       cout << "<Convert8to10> out of range "<< signal << endl;
+       Warning("Convert8to10","out of range signal=%d",signal);
        return 0;
     } // end if signal <0 || signal >255
 
@@ -1023,7 +1138,7 @@ void AliITSsimulationSDD::Init2D(){
     if(param) {
        while(fscanf(param,"%d %f %f",&pos, &mu, &sigma) != EOF) {
            if (pos != na+1) {
-               Error("Init2D ","Anode number not in increasing order!",filtmp);
+               Error("Init2D","Anode number not in increasing order!",filtmp);
                exit(1);
            } // end if pos != na+1
            savemu[na] = mu;
@@ -1041,7 +1156,7 @@ void AliITSsimulationSDD::Init2D(){
           na++;
        } // end while
     } else {
-       Error("Init2D "," THE FILE %s DOES NOT EXIST !",filtmp);
+       Error("Init2D","THE FILE %s DOES NOT EXIST !",filtmp);
        exit(1);
     } // end if(param)
 
@@ -1075,7 +1190,8 @@ void AliITSsimulationSDD::Compress2D(){
                nh++;
                Bool_t cond=kTRUE;
                FindCluster(i,j,signal,minval,cond);
-               if(cond&&j&&((TMath::Abs(fHitMap2->GetSignal(i,j-1))-th)>=minval)){
+               if(cond && j &&
+                  ((TMath::Abs(fHitMap2->GetSignal(i,j-1))-th)>=minval)){
                    if(do10to8) signal = Convert10to8(signal);
                    AddDigit(i,j,signal);
                } // end if cond&&j&&()
@@ -1164,7 +1280,7 @@ void AliITSsimulationSDD::Init1D(){
        fscanf(param,"%d %d %d %d ", &fT2[0], &fT2[1], &fTol[0], &fTol[1]);
        while(fscanf(param,"%d %f %f",&pos, &mu, &sigma) != EOF) {
            if (pos != na+1) {
-               Error("Init1D ","Anode number not in increasing order!",filtmp);
+               Error("Init1D","Anode number not in increasing order!",filtmp);
                exit(1);
            } // end if pos != na+1
            savemu[na]=mu;
@@ -1179,7 +1295,7 @@ void AliITSsimulationSDD::Init1D(){
            na++;
        } // end while
     } else {
-       Error("Init1D "," THE FILE %s DOES NOT EXIST !",filtmp);
+       Error("Init1D","THE FILE %s DOES NOT EXIST !",filtmp);
        exit(1);
     } // end if(param)
 
@@ -1305,8 +1421,6 @@ void AliITSsimulationSDD::CreateHistograms(Int_t scale){
           Char_t candNum[4];
           sprintf(candNum,"%d",i+1);
           sddName.Append(candNum);
-       //PH       (*fHis)[i] = new TH1F(sddName.Data(),"SDD maps",
-       //PH            scale*fMaxNofSamples,0.,(Float_t) scale*fMaxNofSamples);
           fHis->AddAt(new TH1F(sddName.Data(),"SDD maps",scale*fMaxNofSamples,
                                0.,(Float_t) scale*fMaxNofSamples), i);
       } // end for i
@@ -1332,7 +1446,6 @@ void AliITSsimulationSDD::ResetHistograms(){
     Int_t i;
 
     for (i=0;i<fNofMaps;i++ ) {
-       //PH    if ((*fHis)[i])    ((TH1F*)(*fHis)[i])->Reset();
        if (fHis->At(i))    ((TH1F*)fHis->At(i))->Reset();
     } // end for i
 }
@@ -1343,16 +1456,15 @@ TH1F *AliITSsimulationSDD::GetAnode(Int_t wing, Int_t anode) {
     if (!fHis) return 0;
 
     if(wing <=0 || wing > 2) {
-       cout << "Wrong wing number: " << wing << endl;
+       Warning("GetAnode","Wrong wing number: %d",wing);
        return NULL;
     } // end if wing <=0 || wing >2
     if(anode <=0 || anode > fNofMaps/2) {
-       cout << "Wrong anode number: " << anode << endl;
+       Warning("GetAnode","Wrong anode number: %d",anode);
        return NULL;
     } // end if ampde <=0 || andoe > fNofMaps/2
 
     Int_t index = (wing-1)*fNofMaps/2 + anode-1;
-    //PH  return (TH1F*)((*fHis)[index]); 
     return (TH1F*)(fHis->At(index));
 }
 //______________________________________________________________________
@@ -1363,7 +1475,6 @@ void AliITSsimulationSDD::WriteToFile(TFile *hfile) {
 
     hfile->cd();
     Int_t i;
-    //PH  for(i=0; i<fNofMaps; i++)  (*fHis)[i]->Write(); //fAdcs[i]->Write();
     for(i=0; i<fNofMaps; i++)  fHis->At(i)->Write(); //fAdcs[i]->Write();
     return;
 }
@@ -1423,6 +1534,20 @@ Float_t AliITSsimulationSDD::GetNoise() {
     cout << "rnoise : " << rnoise << endl;
     delete noisehist;
     return rnoise;
+}//______________________________________________________________________
+void AliITSsimulationSDD::WriteSDigits(AliITSpList *pList){
+    // Fills the Summable digits Tree
+    Int_t i,ni,j,nj;
+    static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
+
+    pList->GetMaxMapIndex(ni,nj);
+    for(i=0;i<ni;i++)for(j=0;j<nj;j++){
+       if(pList->GetSignalOnly(i,j)>0.5*fT1[0]){ // above small threshold.
+           aliITS->AddSumDigit(*(pList->GetpListItem(i,j)));
+//         cout << "pListSDD: " << *(pList->GetpListItem(i,j)) << endl;
+       } // end if
+    } // end for i,j
+    return;
 }
 //______________________________________________________________________
 void AliITSsimulationSDD::Print() {
index 4a57b4a..ad5158e 100644 (file)
@@ -15,12 +15,15 @@ class TVector;
 class TArrayI;
 class TArrayF;
 class AliITS;
+class AliITSpList;
 class AliITSMap;
 class AliITSMapA1;
 class AliITSMapA2;
 class AliITSetfSDD;
+class AliITSsegmentationSDD;
 class AliITSInStream;
 class AliITSresponse;
+class AliITSresponseSDD;
 
 class AliITSsimulationSDD : public AliITSsimulation {
 
@@ -33,6 +36,8 @@ class AliITSsimulationSDD : public AliITSsimulation {
     virtual ~AliITSsimulationSDD(); // Destructor
     // = opporator
     AliITSsimulationSDD& operator=(AliITSsimulationSDD &source);
+    // Initilize variables for this simulation
+    void Init(AliITSsegmentationSDD *seg,AliITSresponseSDD *resp);
 
     // get the address of the array mapping the signal or pointers to arrays
     virtual AliITSMap*  HitMap(Int_t i);
@@ -77,8 +82,19 @@ class AliITSsimulationSDD : public AliITSsimulation {
 
     // add baseline, noise, electronics and ADC saturation effects
     void ChargeToSignal();
+    // Summable Digitses a SDD module
+    void SDigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev);
+    // Writes summable digits
+    void WriteSDigits(AliITSpList *pList);
+    // Introduces electronics effects and does zero-suppresion if required
+    void FinishDigits(TObjArray *alist);
+    // Take the summable digits and create digits.
+    void SDigitsToDigits(AliITSpList *pList);
     // Digitses a SDD module
     void DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev);
+    // Spread charge in a SDD module
+    void HitsToAnalogDigits(AliITSmodule *mod,TObjArray *alist,
+                           TClonesArray *padr,AliITSpList *pList);
     // Sorts tracks for the 3 most highly contributed one to be added to digit.
     void SortTracks(Int_t *tracks,Float_t *charges,Int_t *hits,Int_t ntracks);
     // collects and returns the fired SDD cells (uses AliITSMapA2...).
index 357e0bc..ae297e7 100644 (file)
@@ -1,3 +1,21 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
 #include <iostream.h>
 #include <TRandom.h>
 #include <TH1.h>
 #include <TString.h>
 #include <TParticle.h>
 
-
 #include "AliRun.h"
 #include "AliITS.h"
 #include "AliITShit.h"
 #include "AliITSdigit.h"
 #include "AliITSmodule.h"
 #include "AliITSMapA2.h"
+#include "AliITSpList.h"
 #include "AliITSsimulationSPD.h"
 #include "AliITSsegmentation.h"
 #include "AliITSresponse.h"
+#include "AliITSsegmentationSPD.h"
+#include "AliITSresponseSPD.h"
 
 
 ClassImp(AliITSsimulationSPD)
@@ -26,699 +46,596 @@ ClassImp(AliITSsimulationSPD)
 //
 // AliITSsimulationSPD is the simulation of SPDs
 //
-//________________________________________________________________________
-
+//______________________________________________________________________
 AliITSsimulationSPD::AliITSsimulationSPD(){
-  // constructor
-  fResponse     = 0;
-  fSegmentation = 0;
-  fHis          = 0;
-  fThresh       = 0.;
-  fSigma        = 0.;
-  fCouplCol     = 0.;
-  fCouplRow     = 0.;
+    // Default constructor
+
+    fResponse     = 0;
+    fSegmentation = 0;
+    fHis          = 0;
+    fMapA2        = 0;
+/*
+    fThresh       = 0.;
+    fSigma        = 0.;
+    fCouplCol     = 0.;
+    fCouplRow     = 0.; */
 }
-//_____________________________________________________________________________
-
-AliITSsimulationSPD::AliITSsimulationSPD(AliITSsegmentation *seg, AliITSresponse *resp) {
-  // constructor
-      fResponse = resp;
-      fSegmentation = seg;
-
-      fResponse->Thresholds(fThresh,fSigma);
-      fResponse->GetNoiseParam(fCouplCol,fCouplRow);
-      
-      fMapA2 = new AliITSMapA2(fSegmentation);
-   
-      // 
-      fNPixelsZ=fSegmentation->Npz();
-      fNPixelsX=fSegmentation->Npx();
-      fHis=0;
+//______________________________________________________________________
+AliITSsimulationSPD::AliITSsimulationSPD(AliITSsegmentation *seg,
+                                        AliITSresponse *resp) {
+    // Standard constructor
+
+    fResponse     = 0;
+    fSegmentation = 0;
+    fHis          = 0;
+    fMapA2        = 0;
+/*
+    fThresh       = 0.;
+    fSigma        = 0.;
+    fCouplCol     = 0.;
+    fCouplRow     = 0.*/
+    Init((AliITSsegmentationSPD*)seg,(AliITSresponseSPD*)resp);
 }
-
-//_____________________________________________________________________________
-
+//______________________________________________________________________
+void AliITSsimulationSPD::Init(AliITSsegmentationSPD *seg,
+                              AliITSresponseSPD *resp) {
+    // Initilizes the variables of AliITSsimulation SPD.
+
+    fHis = 0;
+    fResponse     = resp;
+    fSegmentation = seg;
+    fMapA2 = new AliITSMapA2(fSegmentation);
+/*
+    fResponse->Thresholds(fThresh,fSigma);
+    fResponse->GetNoiseParam(fCouplCol,fCouplRow);
+    fNPixelsZ = fSegmentation->Npz();
+    fNPixelsX = fSegmentation->Npx();
+*/
+}
+//______________________________________________________________________
 AliITSsimulationSPD::~AliITSsimulationSPD() { 
-  // destructor
+    // destructor
 
-  delete fMapA2;
+    delete fMapA2;
 
-  if (fHis) {
-     fHis->Delete(); 
-     delete fHis;     
-  }                
+    if (fHis) {
+       fHis->Delete(); 
+       delete fHis;     
+    } // end if
 }
-
-//__________________________________________________________________________
+//______________________________________________________________________
 AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source){
-  //     Copy Constructor 
-  if(&source == this) return;
-  this->fMapA2 = source.fMapA2;
-  this->fThresh = source.fThresh;
-  this->fSigma = source.fSigma;
-  this->fCouplCol = source.fCouplCol;
-  this->fCouplRow = source.fCouplRow;
-  this->fNPixelsX = source.fNPixelsX;
-  this->fNPixelsZ = source.fNPixelsZ;
-  this->fHis = source.fHis;
-  return;
+    // Copy Constructor
+
+    if(&source == this) return;
+
+    this->fMapA2    = source.fMapA2;
+    this->fHis      = source.fHis;
+/*
+    this->fThresh   = source.fThresh;
+    this->fSigma    = source.fSigma;
+    this->fCouplCol = source.fCouplCol;
+    this->fCouplRow = source.fCouplRow;
+    this->fNPixelsX = source.fNPixelsX;
+    this->fNPixelsZ = source.fNPixelsZ;
+*/
+    return;
 }
+//______________________________________________________________________
+AliITSsimulationSPD& AliITSsimulationSPD::operator=(const AliITSsimulationSPD 
+                                                   &source) {
+    //    Assignment operator
+
+    if(&source == this) return *this;
+
+    this->fMapA2    = source.fMapA2;
+    this->fHis      = source.fHis;
+/*
+    this->fThresh   = source.fThresh;
+    this->fSigma    = source.fSigma;
+    this->fCouplCol = source.fCouplCol;
+    this->fCouplRow = source.fCouplRow;
+    this->fNPixelsX = source.fNPixelsX;
+    this->fNPixelsZ = source.fNPixelsZ;
+*/
+    return *this;
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::SDigitiseModule(AliITSmodule *mod, Int_t dummy0,
+                                             Int_t dummy1) {
+    // Sum digitize module
+    if (!(mod->GetNhits())) return; // if module has no hits then no Sdigits.
+    Int_t    number     = 10000;
+    Int_t    *frowpixel = new Int_t[number];
+    Int_t    *fcolpixel = new Int_t[number];
+    Double_t *fenepixel = new Double_t[number];
+
+    // Array of pointers to store the track index of the digits
+    // leave +1, otherwise pList crashes when col=256, row=192
+    AliITSpList *pList = new AliITSpList(GetNPixelsZ()+1,GetNPixelsX()+1);
+
+    HitsToAnalogDigits(mod,frowpixel,fcolpixel,fenepixel,pList);
+
+    WriteSDigits(pList);
+
+    // clean memory
+    delete[] frowpixel;
+    delete[] fcolpixel;
+    delete[] fenepixel;
+    fMapA2->ClearMap();
+    delete pList;
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t dummy0,
+                                             Int_t dummy1) {
+    // digitize module. Also need to digitize modules with only noise.
 
-//_________________________________________________________________________
-AliITSsimulationSPD& 
-  AliITSsimulationSPD::operator=(const AliITSsimulationSPD &source) {
-  //    Assignment operator
-  if(&source == this) return *this;
-  this->fMapA2 = source.fMapA2;
-  this->fThresh = source.fThresh;
-  this->fSigma = source.fSigma;
-  this->fCouplCol = source.fCouplCol;
-  this->fCouplRow = source.fCouplRow;
-  this->fNPixelsX = source.fNPixelsX;
-  this->fNPixelsZ = source.fNPixelsZ;
-  this->fHis = source.fHis;
-  return *this;
-  }
-//_____________________________________________________________________________
-
-void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t module,
-                                             Int_t dummy) {
-  // digitize module
-
-
-  TObjArray *fHits = mod->GetHits();
-  Int_t nhits = fHits->GetEntriesFast();
-  if (!nhits) return;
-
-
-  //printf("Module %d (%d hits) \n",module+1,nhits);
-
-
-  Int_t  number=10000;
-  Int_t    *frowpixel = new Int_t[number];
-  Int_t    *fcolpixel = new Int_t[number];
-  Double_t *fenepixel = new Double_t[number];
-
-  // Array of pointers to store the track index of the digits
-  // leave +1, otherwise pList crashes when col=256, row=192 
-    Int_t maxNdigits = fNPixelsX*fNPixelsZ+fNPixelsX+1;
-  Float_t  **pList = new Float_t* [maxNdigits];
-  memset(pList,0,sizeof(Float_t*)*maxNdigits);
-
-
-  // noise setting
-  SetFluctuations(pList);
+    Int_t    number     = 10000;
+    Int_t    *frowpixel = new Int_t[number];
+    Int_t    *fcolpixel = new Int_t[number];
+    Double_t *fenepixel = new Double_t[number];
+    Int_t    module     = mod->GetIndex();
 
+    // Array of pointers to store the track index of the digits
+    // leave +1, otherwise pList crashes when col=256, row=192 
+    AliITSpList *pList = new AliITSpList(GetNPixelsZ()+1,GetNPixelsX()+1);
 
+    // noise setting
+    SetFluctuations(pList,module);
 
-  // loop over hits in the module
-  Int_t hitpos;
-  for (hitpos=0;hitpos<nhits;hitpos++) {  
-     HitToDigit(mod,hitpos,module,frowpixel,fcolpixel,fenepixel,pList);
-  }// end loop over digits
+    HitsToAnalogDigits(mod,frowpixel,fcolpixel,fenepixel,pList);
 
-  CreateDigit(nhits,module,pList);
+    // apply mask to SPD module
+    SetMask();
 
-  // clean memory
-  delete[] frowpixel;
-  delete[] fcolpixel;
-  delete[] fenepixel;
-  fMapA2->ClearMap();
-  delete [] pList;
+    CreateDigit(module,pList);
 
+    // clean memory
+    delete[] frowpixel;
+    delete[] fcolpixel;
+    delete[] fenepixel;
+    fMapA2->ClearMap();
+    delete pList;
 }
-//_____________________________________________________________________________
+//______________________________________________________________________
+void AliITSsimulationSPD::SDigitsToDigits(Int_t module,AliITSpList *pList) {
+    // sum digits to Digits.
 
-void AliITSsimulationSPD::UpdateMap( Int_t row, Int_t col, Double_t ene) {
-//
-// updates the Map of signal, adding the energy  (ene) released by the current track
-//
-      Double_t signal; 
-      signal = fMapA2->GetSignal(row,col);
-      signal += ene;
-      fMapA2->SetHit(row,col,signal);
-                                         
- }
-//_____________________________________________________________________________  
-void AliITSsimulationSPD::HitToDigit(AliITSmodule *mod, Int_t hitpos, Int_t module, 
-                                        Int_t *frowpixel, Int_t *fcolpixel,
-                                       Double_t *fenepixel, Float_t **pList) {
-//
-//  Steering function to determine the digits associated to a given hit (hitpos)
-//  The digits are created by charge sharing (ChargeSharing) and by
-//  capacitive coupling (SetCoupling). At all the created digits is associated
-//  the track number of the hit (ntrack)
-//
+    FillMapFrompList(pList);
 
+    // noise setting
+    SetFluctuations(pList,module);
 
-   static Float_t x1l,y1l,z1l;
-   Float_t x2l,y2l,z2l,etot;
-   Int_t layer,r1,r2,c1,c2,row,col,npixel = 0;
-   Int_t ntrack,idhit;
-   Double_t ene;
-   const Float_t kconv = 10000.;     // cm -> microns
-   const Float_t kconv1= 0.277e9;     // GeV -> electrons equivalent  
+    // apply mask to SPD module
+    SetMask();
 
-   TObjArray *fHits = mod->GetHits();
-   AliITShit *hit = (AliITShit*) fHits->At(hitpos);
-   layer = hit->GetLayer();
-   etot=kconv1*hit->GetIonization();
-   ntrack=hit->GetTrack();
-   idhit=mod->GetHitHitIndex(hitpos);     
+    CreateDigit(module,pList);
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::UpdateMapSignal(Int_t row,Int_t col,Int_t trk,
+                                         Int_t hit,Int_t mod,Double_t ene,
+                                         AliITSpList *pList) {
+    // updates the Map of signal, adding the energy  (ene) released by
+    // the current track
+
+    fMapA2->AddSignal(row,col,ene);
+    pList->AddSignal(row,col,trk,hit,mod,ene);
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::UpdateMapNoise(Int_t row,Int_t col,Int_t mod,
+                                        Double_t ene,AliITSpList *pList) {
+    // updates the Map of noise, adding the energy  (ene) give my noise
 
+    fMapA2->AddSignal(row,col,ene);
+    pList->AddNoise(row,col,mod,ene);
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::HitsToAnalogDigits(AliITSmodule *mod,
+                                            Int_t *frowpixel,Int_t *fcolpixel,
+                                            Double_t *fenepixel,
+                                            AliITSpList *pList) {
+    // Loops over all hits to produce Analog/floting point digits. This
+    // is also the first task in producing standard digits.
     
+    // loop over hits in the module
+    Int_t hitpos,nhits = mod->GetNhits();
+    for (hitpos=0;hitpos<nhits;hitpos++) {
+       HitToDigit(mod,hitpos,frowpixel,fcolpixel,fenepixel,pList);
+    }// end loop over digits
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::HitToDigit(AliITSmodule *mod,Int_t hitpos,
+                                    Int_t *frowpixel,Int_t *fcolpixel,
+                                    Double_t *fenepixel,AliITSpList *pList) {
+    //  Steering function to determine the digits associated to a given
+    // hit (hitpos)
+    // The digits are created by charge sharing (ChargeSharing) and by
+    // capacitive coupling (SetCoupling). At all the created digits is
+    // associated the track number of the hit (ntrack)
+    Double_t x1l=0.0,y1l=0.0,z1l=0.0,x2l=0.0,y2l=0.0,z2l=0.0;
+    Int_t r1,r2,c1,c2,row,col,npixel = 0;
+    Int_t ntrack;
+    Double_t ene=0.0,etot=0.0;
+    const Float_t kconv = 10000.;     // cm -> microns
+    const Float_t kconv1= 0.277e9;    // GeV -> electrons equivalent
+
+    if(!(mod->LineSegmentL(hitpos,x1l,x2l,y1l,y2l,z1l,z2l,etot,ntrack)))return;
+
+    x2l += x1l; y2l += y1l; z2l += z1l; // Convert to ending coordinate.
+    // positions shifted and converted in microns
+    x1l   = x1l*kconv + fSegmentation->Dx()/2.;
+    z1l   = z1l*kconv + fSegmentation->Dz()/2.;
+    // positions  shifted and converted in microns
+    x2l   = x2l*kconv + fSegmentation->Dx()/2.;
+    z2l   = z2l*kconv + fSegmentation->Dz()/2.;
+    etot *= kconv1; // convert from GeV to electrons equivalent.
+    Int_t module = mod->GetIndex();
+
+    // to account for the effective sensitive area
+    // introduced in geometry 
+    if (z1l<0 || z1l>fSegmentation->Dz()) return;
+    if (z2l<0 || z2l>fSegmentation->Dz()) return;
+    if (x1l<0 || x1l>fSegmentation->Dx()) return;
+    if (x2l<0 || x2l>fSegmentation->Dx()) return;
+
+    //Get the col and row number starting from 1
+    // the x direction is not inverted for the second layer!!!
+    fSegmentation->GetPadIxz(x1l, z1l, c1, r1); 
+    fSegmentation->GetPadIxz(x2l, z2l, c2, r2);
+
+    // to account for unexpected equal entrance and 
+    // exit coordinates
+    if (x1l==x2l) x2l=x2l+x2l*0.000001;
+    if (z1l==z2l) z2l=z2l+z2l*0.000001;
+
+    if ((r1==r2) && (c1==c2)){
+       // no charge sharing
+       npixel = 1;              
+       frowpixel[npixel-1] = r1;
+       fcolpixel[npixel-1] = c1;
+       fenepixel[npixel-1] = etot;
+    } else {
+       // charge sharing
+       ChargeSharing(x1l,z1l,x2l,z2l,c1,r1,c2,r2,etot,
+                     npixel,frowpixel,fcolpixel,fenepixel);
+    } // end if r1==r2 && c1==c2.
+
+    for (Int_t npix=0;npix<npixel;npix++){
+       row = frowpixel[npix];
+       col = fcolpixel[npix];
+       ene = fenepixel[npix];
+       UpdateMapSignal(row,col,ntrack,hitpos,module,ene,pList); 
+       // Starting capacitive coupling effect
+       SetCoupling(row,col,ntrack,hitpos,module,pList); 
+    } // end for npix
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,
+                                       Float_t z2l,Int_t c1,Int_t r1,Int_t c2,
+                                       Int_t r2,Float_t etot,
+                                       Int_t &npixel,Int_t *frowpixel,
+                                       Int_t *fcolpixel,Double_t *fenepixel){
+    //  Take into account the geometrical charge sharing when the track
+    //  crosses more than one pixel.
+    //
+    //Begin_Html
     /*
-    printf("\n layer,etot,ntrack,status %d %f %d %d\n",layer,etot,ntrack,hit->GetTrackStatus()); //debug
-    Int_t idtrack; //debug
-    mod->GetHitTrackAndHitIndex(hitpos,idtrack,idhit);     
-    printf("idtrack,idhit %d %d\n",idtrack,idhit); //debug
-    printf("(Dx, Dz)=(%f, %f)\n",fSegmentation->Dx(),fSegmentation->Dz()); //debug
+      <img src="picts/ITS/barimodel_2.gif">
+      </pre>
+      <br clear=left>
+      <font size=+2 color=red>
+      <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
+      </font>
+      <pre>
     */
+    //End_Html
+    Float_t xa,za,xb,zb,dx,dz,dtot,dm,refr,refm,refc;
+    Float_t refn=0.;
+    Float_t arefm, arefr, arefn, arefc, azb, az2l, axb, ax2l;
+    Int_t   dirx,dirz,rb,cb;
+    Int_t flag,flagrow,flagcol;
+    Double_t epar;
+
+    npixel = 0;
+    xa     = x1l;
+    za     = z1l;
+    dx     = TMath::Abs(x1l-x2l);
+    dz     = TMath::Abs(z1l-z2l);
+    dtot   = TMath::Sqrt((dx*dx)+(dz*dz));   
+    dm     = (x2l - x1l) / (z2l - z1l);
+    dirx   = (Int_t) ((x2l - x1l) / dx);
+    dirz   = (Int_t) ((z2l - z1l) / dz);
+
+    // calculate the x coordinate of  the pixel in the next column    
+    // and the z coordinate of  the pixel in the next row
+    Float_t xpos, zpos;
+
+    fSegmentation->GetPadCxz(c1, r1-1, xpos, zpos); 
+
+    Float_t xsize = fSegmentation->Dpx(0);
+    Float_t zsize = fSegmentation->Dpz(r1-1);
     
+    if (dirx == 1) refr = xpos+xsize/2.;
+    else refr = xpos-xsize/2.;
+
+    if (dirz == 1) refn = zpos+zsize/2.;
+    else refn = zpos-zsize/2.;
+
+    flag = 0;
+    flagrow = 0;
+    flagcol = 0;
+    do{
+       // calculate the x coordinate of the intersection with the pixel
+       // in the next cell in row  direction
+       refm = (refn - z1l)*dm + x1l;
    
-
-        if (hit->GetTrackStatus()==66) {
-             hit->GetPositionL(x1l,y1l,z1l);
-          // positions shifted and converted in microns 
-          x1l = x1l*kconv + fSegmentation->Dx()/2.;
-          z1l = z1l*kconv + fSegmentation->Dz()/2.;
-          //printf("(x1l, z2l)=(%f, %f)\n",x1l,z1l); //debug
-        }
-        else {
-             hit->GetPositionL(x2l,y2l,z2l);         
-          // positions  shifted and converted in microns
-          x2l = x2l*kconv + fSegmentation->Dx()/2.;
-          z2l = z2l*kconv + fSegmentation->Dz()/2.;
-          //printf("(x2l, z2l)=(%f, %f)\n",x2l,z2l); //debug
-
-
-
-          // to account for the effective sensitive area
-          // introduced in geometry 
-          if (z1l<0 || z1l>fSegmentation->Dz()) return;
-          if (z2l<0 || z2l>fSegmentation->Dz()) return;
-          if (x1l<0 || x1l>fSegmentation->Dx()) return;
-          if (x2l<0 || x2l>fSegmentation->Dx()) return;
-
-          //Get the col and row number starting from 1
-          // the x direction is not inverted for the second layer!!!
-             fSegmentation->GetPadIxz(x1l, z1l, c1, r1); 
-             fSegmentation->GetPadIxz(x2l, z2l, c2, r2);
-
-          //printf("(c1, r1)=(%d, %d) (c2, r2)=(%d, %d)\n",c1,r1,c2,r2); //debug
-
-          // to account for unexpected equal entrance and 
-          // exit coordinates
-          if (x1l==x2l) x2l=x2l+x2l*0.000001;
-          if (z1l==z2l) z2l=z2l+z2l*0.000001;
-
-
-             if ((r1==r2) && (c1==c2)) 
-             {
-             // no charge sharing
-                npixel = 1;             
-                    frowpixel[npixel-1] = r1;
-                    fcolpixel[npixel-1] = c1;
-                    fenepixel[npixel-1] = etot;
-          }
-             else {
-             // charge sharing
-                ChargeSharing(x1l,z1l,x2l,z2l,c1,r1,c2,r2,etot,
-                                      npixel,frowpixel,fcolpixel,fenepixel);
-
-          }
-                  
-
-         for (Int_t npix=0;npix<npixel;npix++)
-             {
-                  row = frowpixel[npix];
-                  col = fcolpixel[npix];
-                  ene = fenepixel[npix];
-                  UpdateMap(row,col,ene);                   
-                  GetList(ntrack,idhit,pList,row,col); 
-                  // Starting capacitive coupling effect
-                  SetCoupling(row,col,ntrack,idhit,pList); 
-             }
-           x1l=x2l;
-           y1l=y2l;
-           z1l=z2l;                 
-        }
-}
-
-//_________________________________________________________________________
-
-void AliITSsimulationSPD::ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,
-                    Float_t z2l,Int_t c1,Int_t r1,Int_t c2,
-                                   Int_t r2,Float_t etot,
-                                   Int_t &npixel,Int_t *frowpixel,
-                                   Int_t *fcolpixel,Double_t *fenepixel){
-  //
-  //  Take into account the geometrical charge sharing when the track
-  //  crosses more than one pixel.
-  //
-  //Begin_Html
-  /*
-  <img src="picts/ITS/barimodel_2.gif">
-  </pre>
-  <br clear=left>
-  <font size=+2 color=red>
-  <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
-  </font>
-  <pre>
-  */
-  //End_Html
-
-
-   Float_t xa,za,xb,zb,dx,dz,dtot,dm,refr,refm,refc;
-   Float_t refn=0.;
-   Float_t arefm, arefr, arefn, arefc, azb, az2l, axb, ax2l;
-   Int_t   dirx,dirz,rb,cb;
-
-
-   Int_t flag,flagrow,flagcol;
-  
-   Double_t epar;
-
-
-   npixel = 0;
-   xa = x1l;
-   za = z1l;
-   dx = TMath::Abs(x1l-x2l);
-   dz = TMath::Abs(z1l-z2l);
-   dtot = TMath::Sqrt((dx*dx)+(dz*dz));   
-   dm = (x2l - x1l) / (z2l - z1l);
-
-   dirx = (Int_t) ((x2l - x1l) / dx);
-   dirz = (Int_t) ((z2l - z1l) / dz);
-   
-   
-   // calculate the x coordinate of  the pixel in the next column    
-   // and the z coordinate of  the pixel in the next row    
-
-   Float_t xpos, zpos;
-
-   fSegmentation->GetPadCxz(c1, r1-1, xpos, zpos); 
-
-   Float_t xsize = fSegmentation->Dpx(0);
-   Float_t zsize = fSegmentation->Dpz(r1-1);
-
-   if (dirx == 1) refr = xpos+xsize/2.;
-             else refr = xpos-xsize/2.;
-
-   if (dirz == 1) refn = zpos+zsize/2.;
-             else refn = zpos-zsize/2.;
-
-   
-   flag = 0;
-   flagrow = 0;
-   flagcol = 0;
-   do
-   {
-       
-      // calculate the x coordinate of the intersection with the pixel
-      // in the next cell in row  direction
-
-      refm = (refn - z1l)*dm + x1l;
-   
-      // calculate the z coordinate of the intersection with the pixel
-      // in the next cell in column direction 
-
-      refc = (refr - x1l)/dm + z1l;
-      
-      
-      arefm = refm * dirx;
-      arefr = refr * dirx;
-      arefn = refn * dirz;
-      arefc = refc * dirz;
-            
-
-      if ((arefm < arefr) && (arefn < arefc)){
-                
-         // the track goes in the pixel in the next cell in row direction
-            xb = refm;
-            zb = refn;
-            cb = c1;
-            rb = r1 + dirz;
-            azb = zb * dirz;
-         az2l = z2l * dirz;
-            if (rb == r2) flagrow=1;
-            if (azb > az2l) {
+       // calculate the z coordinate of the intersection with the pixel
+       // in the next cell in column direction
+       refc = (refr - x1l)/dm + z1l;
+
+       arefm = refm * dirx;
+       arefr = refr * dirx;
+       arefn = refn * dirz;
+       arefc = refc * dirz;
+
+       if ((arefm < arefr) && (arefn < arefc)){
+           // the track goes in the pixel in the next cell in row direction
+           xb = refm;
+           zb = refn;
+           cb = c1;
+           rb = r1 + dirz;
+           azb = zb * dirz;
+           az2l = z2l * dirz;
+           if (rb == r2) flagrow=1;
+           if (azb > az2l) {
                zb = z2l;
                xb = x2l;
-            }     
-
-         // shift to the pixel in the next cell in row direction
-         Float_t zsizeNext = fSegmentation->Dpz(rb-1);
-         //to account for cell at the borders of the detector
-         if(zsizeNext==0) zsizeNext = zsize;
-
-            refn += zsizeNext*dirz;
-
-      }
-      else {
-         
-         // the track goes in the pixel in the next cell in column direction
-            xb = refr;
-            zb = refc;
-            cb = c1 + dirx;
-            rb = r1;
-            axb = xb * dirx;
-         ax2l = x2l * dirx;
-         if (cb == c2) flagcol=1;
-            if (axb > ax2l) {
+           } // end if
+           // shift to the pixel in the next cell in row direction
+           Float_t zsizeNext = fSegmentation->Dpz(rb-1);
+           //to account for cell at the borders of the detector
+           if(zsizeNext==0) zsizeNext = zsize;
+           refn += zsizeNext*dirz;
+       }else {
+           // the track goes in the pixel in the next cell in column direction
+           xb = refr;
+           zb = refc;
+           cb = c1 + dirx;
+           rb = r1;
+           axb = xb * dirx;
+           ax2l = x2l * dirx;
+           if (cb == c2) flagcol=1;
+           if (axb > ax2l) {
                zb = z2l;
                xb = x2l;
-            }
-
-         // shift to the pixel in the next cell in column direction
-         Float_t xsizeNext = fSegmentation->Dpx(cb-1);
-         //to account for cell at the borders of the detector
-         if(xsizeNext==0) xsizeNext = xsize;
-
-            refr += xsizeNext*dirx;
-        
-      }
-      
-      //calculate the energy lost in the crossed pixel      
-      epar = TMath::Sqrt((xb-xa)*(xb-xa)+(zb-za)*(zb-za)); 
-      epar = etot*(epar/dtot);
-
-      //store row, column and energy lost in the crossed pixel
-      frowpixel[npixel] = r1;
-      fcolpixel[npixel] = c1;
-      fenepixel[npixel] = epar;
-      npixel++;
+           } // end ifaxb > ax2l
+
+           // shift to the pixel in the next cell in column direction
+           Float_t xsizeNext = fSegmentation->Dpx(cb-1);
+           //to account for cell at the borders of the detector
+           if(xsizeNext==0) xsizeNext = xsize;
+           refr += xsizeNext*dirx;
+       } // end if (arefm < arefr) && (arefn < arefc)
+
+       //calculate the energy lost in the crossed pixel      
+       epar = TMath::Sqrt((xb-xa)*(xb-xa)+(zb-za)*(zb-za)); 
+       epar = etot*(epar/dtot);
+
+       //store row, column and energy lost in the crossed pixel
+       frowpixel[npixel] = r1;
+       fcolpixel[npixel] = c1;
+       fenepixel[npixel] = epar;
+       npixel++;
  
-      // the exit point of the track is reached
-      if (epar == 0) flag = 1;
-      if ((r1 == r2) && (c1 == c2)) flag = 1;
-      if (flag!=1) {
-        r1 = rb;
-        c1 = cb;
-        xa = xb;
-        za = zb;
-      }
-   
-   } while (flag==0);
-
+       // the exit point of the track is reached
+       if (epar == 0) flag = 1;
+       if ((r1 == r2) && (c1 == c2)) flag = 1;
+       if (flag!=1) {
+           r1 = rb;
+           c1 = cb;
+           xa = xb;
+           za = zb;
+       } // end if flag!=1
+    } while (flag==0);
 }
-//___________________________________________________________________________
+//______________________________________________________________________
 void AliITSsimulationSPD::SetCoupling(Int_t row, Int_t col, Int_t ntrack,
-                                          Int_t idhit, Float_t **pList) {
-   //
-   //  Take into account the coupling between adiacent pixels.
-   //  The parameters probcol and probrow are the fractions of the
-   //  signal in one pixel shared in the two adjacent pixels along
-   //  the column and row direction, respectively.
-   //
-   //Begin_Html
-   /*
-   <img src="picts/ITS/barimodel_3.gif">
-   </pre>
-   <br clear=left>
-   <font size=+2 color=red>
-   <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
-   </font>
-   <pre>
-   */
-   //End_Html
-
-
-   Int_t j1,j2,flag=0;
-   Double_t pulse1,pulse2;
-                              
-
-   j1 = row;
-   j2 = col;
-  
-   pulse1 = fMapA2->GetSignal(row,col);
-   pulse2 = pulse1;
-
-   for (Int_t isign=-1;isign<=1;isign+=2)
-   {
-
-// loop in row direction
-      
-      do
-      {
-         j1 += isign;
-         pulse1 *= fCouplRow;                  
-      
-         if ((j1 < 0) || (j1 > fNPixelsZ-1) || (pulse1 < fThresh))
-         { 
-              pulse1 = fMapA2->GetSignal(row,col);
-              j1 = row;
-              flag = 1;
-         }
-          else{                
-                  UpdateMap(j1,col,pulse1);                   
-                  GetList(ntrack,idhit,pList,j1,col); 
-           flag = 0;
-            }
-        
-      } while(flag == 0);          
-      
-      
-// loop in column direction
-      
-      do
-      {
-         j2 += isign;
-         pulse2 *= fCouplCol;                  
-      
-         if ((j2 < 0) || (j2 > (fNPixelsX-1)) || (pulse2 < fThresh))
-         {                
-              pulse2 = fMapA2->GetSignal(row,col);
-              j2 = col;
-              flag = 1;
-         }
-          else{                
-                  UpdateMap(row,j2,pulse2);                   
-                  GetList(ntrack,idhit,pList,row,j2); 
-           flag = 0;
-            }
-        
-      } while(flag == 0);          
-   
-   }
-
+                                     Int_t idhit,Int_t module,
+                                     AliITSpList *pList) {
+    //  Take into account the coupling between adiacent pixels.
+    //  The parameters probcol and probrow are the fractions of the
+    //  signal in one pixel shared in the two adjacent pixels along
+    //  the column and row direction, respectively.
+    //
+    //Begin_Html
+    /*
+      <img src="picts/ITS/barimodel_3.gif">
+      </pre>
+      <br clear=left>
+      <font size=+2 color=red>
+      <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
+      </font>
+      <pre>
+    */
+    //End_Html
+    Int_t j1,j2,flag=0;
+    Double_t pulse1,pulse2;
+    Float_t couplR=0.0,couplC=0.0;
+
+    GetCouplings(couplR,couplC);
+    j1 = row;
+    j2 = col;
+    pulse1 = fMapA2->GetSignal(row,col);
+    pulse2 = pulse1;
+    for (Int_t isign=-1;isign<=1;isign+=2){// loop in row direction
+       do{
+           j1 += isign;
+           pulse1 *= couplR;
+           if ((j1<0) || (j1>GetNPixelsZ()-1) || (pulse1<GetThreshold())){
+               pulse1 = fMapA2->GetSignal(row,col);
+               j1 = row;
+               flag = 1;
+           }else{
+               UpdateMapSignal(j1,col,ntrack,idhit,module,pulse1,pList);
+               flag = 0;
+           } // end if
+       } while(flag == 0);
+       // loop in column direction
+      do{
+         j2 += isign;
+         pulse2 *= couplC;
+         if ((j2<0) || (j2>(GetNPixelsX()-1)) || (pulse2<GetThreshold())){
+             pulse2 = fMapA2->GetSignal(row,col);
+             j2 = col;
+             flag = 1;
+         }else{
+             UpdateMapSignal(row,j2,ntrack,idhit,module,pulse2,pList);
+             flag = 0;
+         } // end if
+      } while(flag == 0);
+    } // for isign
 }
-//___________________________________________________________________________
-void AliITSsimulationSPD::CreateDigit(Int_t nhits, Int_t module, Float_t
-**pList) {                                   
-  //
-  // The pixels are fired if the energy deposited inside them is above
-  // the threshold parameter ethr. Fired pixed are interpreted as digits
-  // and stored in the file digitfilename.
-  //
-
-   AliITS *aliITS  = (AliITS*)gAlice->GetModule("ITS");   
-   
-   Int_t digits[3];
-   Int_t tracks[3];
-   Int_t hits[3];
-   Float_t charges[3]; 
-   Int_t gi,j1;
-   
-   if (nhits > 0) {
-    
-     for (Int_t r=1;r<=fNPixelsZ;r++) {
-        for (Int_t c=1;c<=fNPixelsX;c++) {
-   
-           // check if the deposited energy in a pixel is above the threshold 
-           Float_t signal = (Float_t) fMapA2->GetSignal(r,c);
-          gi =r*fNPixelsX+c; // global index
-           if ( signal > fThresh) {
-                 digits[0] = r-1;  // digits starts from 0
-                 digits[1] = c-1;  // digits starts from 0
-                 //digits[2] = 1;  
-                 digits[2] =  (Int_t) signal;  // the signal is stored in electrons
-                 for(j1=0;j1<3;j1++){
-                   tracks[j1] = (Int_t)(*(pList[gi]+j1));
-                   hits[j1] = (Int_t)(*(pList[gi]+j1+6));
+//______________________________________________________________________
+void AliITSsimulationSPD::CreateDigit(Int_t module,AliITSpList *pList) {
+    // The pixels are fired if the energy deposited inside them is above
+    // the threshold parameter ethr. Fired pixed are interpreted as digits
+    // and stored in the file digitfilename. One also needs to write out
+    // cases when there is only noise (nhits==0).
+
+    static AliITS *aliITS  = (AliITS*)gAlice->GetModule("ITS");
+
+    Int_t digits[3];
+    Int_t tracks[3];
+    Int_t hits[3];
+    Float_t charges[3]; 
+    Int_t j1;
+
+    for (Int_t r=1;r<=GetNPixelsZ();r++) {
+       for (Int_t c=1;c<=GetNPixelsX();c++) {
+           // check if the deposited energy in a pixel is above the
+           // threshold 
+           Float_t signal = (Float_t) fMapA2->GetSignal(r,c);
+           if ( signal > GetThreshold()) {
+               digits[0] = r-1;  // digits starts from 0
+               digits[1] = c-1;  // digits starts from 0
+               //digits[2] = 1;  
+               digits[2] =  (Int_t) signal;  // the signal is stored in
+                                              //  electrons
+               for(j1=0;j1<3;j1++){
+                   tracks[j1] = pList->GetTrack(r,c,j1);
+                   hits[j1]   = pList->GetHit(r,c,j1);
                    charges[j1] = 0;
-                 }
-              /* debug
-              printf("digits %d %d %d\n",digits[0],digits[1],digits[2]); //debug
-              printf("tracks %d %d %d\n",tracks[0],tracks[1],tracks[2]); //debug
-              printf("hits %d %d %d\n",hits[0],hits[1],hits[2]); //debug
-              */
-              Float_t phys = 0;        
-             aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
-          }//endif of threshold condition
-          if(pList[gi]) delete [] pList[gi];
-        }
-     }// enddo on pixels
-    }
-    
-}
-//_____________________________________________________________________________
-
-void AliITSsimulationSPD::GetList(Int_t label,Int_t idhit, Float_t **pList,
-                                      Int_t row, Int_t col) {
-  // loop over nonzero digits
-
-  Int_t ix = col;
-  Int_t iz = row;
-  Int_t globalIndex;
-  Float_t signal;
-  Float_t highest,middle,lowest;
-
-          
-  signal=fMapA2->GetSignal(iz,ix);
-
-
-  globalIndex = iz*fNPixelsX+ix; // globalIndex starts from 1
-
-
-  if(!pList[globalIndex])
-  {
-     // 
-     // Create new list (9 elements - 3 signals and 3 tracks + 3 hits)
-     //
-
-     pList[globalIndex] = new Float_t [9];
-
-
-     // set list to -3 
-     *(pList[globalIndex]) = -3.;
-     *(pList[globalIndex]+1) = -3.;
-     *(pList[globalIndex]+2) = -3.;
-     *(pList[globalIndex]+3) =  0.;
-     *(pList[globalIndex]+4) =  0.;
-     *(pList[globalIndex]+5) =  0.;
-     *(pList[globalIndex]+6) = -1.;
-     *(pList[globalIndex]+7) = -1.;
-     *(pList[globalIndex]+8) = -1.;
-
-     *pList[globalIndex] = (float)label;
-     *(pList[globalIndex]+3) = signal;
-     *(pList[globalIndex]+6) = (float)idhit;
-  }
-  else{
-
-
-         // check the signal magnitude
-      highest = *(pList[globalIndex]+3);
-      middle  = *(pList[globalIndex]+4);
-      lowest  = *(pList[globalIndex]+5);
-
-
-      signal -= (highest+middle+lowest);
-
-
-         //
-         //  compare the new signal with already existing list
-         //
-      if(signal<lowest) return; // neglect this track
-
-      if (signal>highest)
-      {
-         *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
-         *(pList[globalIndex]+7) = *(pList[globalIndex]+6);
-         *(pList[globalIndex]+6) = idhit;
-         *(pList[globalIndex]+5) = middle;
-         *(pList[globalIndex]+4) = highest;
-         *(pList[globalIndex]+3) = signal;
-         *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
-         *(pList[globalIndex]+1) = *pList[globalIndex];
-         *(pList[globalIndex]) = label;
-         }
-        else if (signal>middle)
-      {
-         *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
-         *(pList[globalIndex]+7) = idhit;
-         *(pList[globalIndex]+5) = middle;
-         *(pList[globalIndex]+4) = signal;
-         *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
-         *(pList[globalIndex]+1) = label;
-         }
-        else
-      {
-         *(pList[globalIndex]+8) = idhit;
-         *(pList[globalIndex]+5) = signal;
-         *(pList[globalIndex]+2) = label;
-         }
-  }    
+               } // end for j1
+               Float_t phys = 0;        
+               aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
+           } // end if of threshold condition
+       } // for c
+    }// end do on pixels
 }
-//_________________________________________________________________________ 
-void AliITSsimulationSPD::SetFluctuations(Float_t **pList) {
-  //
-  //  Set the electronic noise and threshold non-uniformities to all the
-  //  pixels in a detector.
-  //  The parameter fSigma is the squared sum of the sigma due to noise
-  //  and the sigma of the threshold distribution among pixels.
-  //
-  //Begin_Html
-  /*
-  <img src="picts/ITS/barimodel_1.gif">
-  </pre>
-  <br clear=left>
-  <font size=+2 color=red>
-  <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
-  </font>
-  <pre>
-  */
-  //End_Html
-  
-  
-  Double_t signal;
-
-  Int_t iz,ix;
-  for(iz=1;iz<=fNPixelsZ;iz++){
-    for(ix=1;ix<=fNPixelsX;ix++){
-      signal = fSigma*gRandom->Gaus(); 
-      fMapA2->SetHit(iz,ix,signal);
-
-      // insert in the label-signal-hit list the pixels fired only by noise
-      if ( signal > fThresh) {
-        Int_t globalIndex = iz*fNPixelsX+ix; 
-        pList[globalIndex] = new Float_t [9];
-        *(pList[globalIndex]) = -2.;
-        *(pList[globalIndex]+1) = -2.;
-        *(pList[globalIndex]+2) = -2.;
-        *(pList[globalIndex]+3) =  signal;
-        *(pList[globalIndex]+4) =  0.;
-        *(pList[globalIndex]+5) =  0.;
-        *(pList[globalIndex]+6) =  -1.;
-        *(pList[globalIndex]+7) =  -1.;
-        *(pList[globalIndex]+8) =  -1.;
-      }
+//______________________________________________________________________
+void AliITSsimulationSPD::SetFluctuations(AliITSpList *pList,Int_t module) {
+    //  Set the electronic noise and threshold non-uniformities to all the
+    //  pixels in a detector.
+    //  The parameter fSigma is the squared sum of the sigma due to noise
+    //  and the sigma of the threshold distribution among pixels.
+    //
+    //Begin_Html
+    /*
+      <img src="picts/ITS/barimodel_1.gif">
+      </pre>
+      <br clear=left>
+      <font size=+2 color=red>
+      <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
+      </font>
+      <pre>
+    */
+    //End_Html
+    Float_t  thr=0.0,sigm=0.0;
+    Double_t signal,sigma;
+    Int_t iz,ix;
+
+    GetThresholds(thr,sigm);
+    sigma = (Double_t) sigm;
+    for(iz=1;iz<=GetNPixelsZ();iz++){
+       for(ix=1;ix<=GetNPixelsX();ix++){
+           signal = sigma*gRandom->Gaus(); 
+           fMapA2->SetHit(iz,ix,signal);
+           // insert in the label-signal-hit list the pixels fired
+           // only by noise
+           pList->AddNoise(iz,ix,module,signal);
+       } // end of loop on pixels
     } // end of loop on pixels
-  } // end of loop on pixels
-  
- }
-//____________________________________________
-
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::SetMask() {
+    //  Apply a mask to the SPD module. 1% of the pixel channels are
+    //  masked. When the database will be ready, the masked pixels
+    //  should be read from it.
+    Double_t signal;
+    Int_t iz,ix,im;
+    Float_t totMask;
+    Float_t perc = ((AliITSresponseSPD*)fResponse)->GetFractionDead();
+    // in this way we get the same set of random numbers for all runs.
+    // This is a cluge for now.
+    static TRandom *rnd = new TRandom();
+
+    totMask= perc*GetNPixelsZ()*GetNPixelsX();
+    for(im=1;im<totMask;im++){
+       do{
+           ix=(Int_t)(rnd->Rndm()*(GetNPixelsX()-1.) + 1.);
+       } while(ix<=0 || ix>GetNPixelsX());
+       do{
+           iz=(Int_t)(rnd->Rndm()*(GetNPixelsZ()-1.) + 1.);
+       } while(iz<=0 || iz>GetNPixelsZ());
+       signal = -1.;
+       fMapA2->SetHit(iz,ix,signal);
+    } // end loop on masked pixels
+}
+//______________________________________________________________________
 void AliITSsimulationSPD::CreateHistograms() {
-  // CreateHistograms
-
-      Int_t i;
-      fHis=new TObjArray(fNPixelsZ);
-      for(i=0;i<fNPixelsZ;i++) {
-          TString spdname("spd_");
-          Char_t candnum[4];
-          sprintf(candnum,"%d",i+1);
-          spdname.Append(candnum);
-       //PH       (*fHis)[i] = new TH1F(spdname.Data(),"SPD maps",
-       //PH                              fNPixelsX,0.,(Float_t) fNPixelsX);
-          fHis->AddAt(new TH1F(spdname.Data(),"SPD maps",
-                              fNPixelsX,0.,(Float_t) fNPixelsX), i);
-      }
+    // Create Histograms
+    Int_t i;
 
+    fHis=new TObjArray(GetNPixelsZ());
+    for(i=0;i<GetNPixelsZ();i++) {
+       TString spdname("spd_");
+       Char_t candnum[4];
+       sprintf(candnum,"%d",i+1);
+       spdname.Append(candnum);
+       (*fHis)[i] = new TH1F(spdname.Data(),"SPD maps",
+                             GetNPixelsX(),0.,(Float_t) GetNPixelsX());
+    } // end for i
 }
-
-//____________________________________________
-
+//______________________________________________________________________
 void AliITSsimulationSPD::ResetHistograms() {
-    //
     // Reset histograms for this detector
-    //
     Int_t i;
-    for(i=0;i<fNPixelsZ;i++ ) {
-      //PH     if ((*fHis)[i])    ((TH1F*)(*fHis)[i])->Reset();
-       if (fHis->At(i))    ((TH1F*)fHis->At(i))->Reset();
-    }
 
+    for(i=0;i<GetNPixelsZ();i++ ) {
+       if ((*fHis)[i])    ((TH1F*)(*fHis)[i])->Reset();
+    } // end for i
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::WriteSDigits(AliITSpList *pList){
+    // Fills the Summable digits Tree
+    Int_t i,ni,j,nj;
+    static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
+
+    pList->GetMaxMapIndex(ni,nj);
+    for(i=0;i<ni;i++)for(j=0;j<nj;j++){
+       if(pList->GetSignalOnly(i,j)>0.0){
+           aliITS->AddSumDigit(*(pList->GetpListItem(i,j)));
+//         cout << "pListSPD: " << *(pList->GetpListItem(i,j)) << endl;
+       } // end if
+    } // end for i,j
+    return;
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::FillMapFrompList(AliITSpList *pList){
+    // Fills fMap2A from the pList of Summable digits
+    Int_t k,ix;
+
+    for(k=0;k<GetNPixelsZ();k++)for(ix=0;ix<GetNPixelsX();ix++) 
+        fMapA2->AddSignal(k,ix,pList->GetSignal(k,ix));
+    return;
 }
index d44f015..35162ad 100644 (file)
 #ifndef ALIITSSIMULATIONSPD_H
 #define ALIITSSIMULATIONSPD_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
 
+/*
+$Id$
+*/
+#include "AliITSresponseSPD.h"
+#include "AliITSsegmentationSPD.h"
 #include "AliITSsimulation.h"
 
 class AliITSMapA2;
-class AliITSsegmentation;
-class AliITSresponse;
+class AliITSpList;
 class AliITSmodule;
 
 //-------------------------------------------------------------------
 
 class AliITSsimulationSPD : public AliITSsimulation {
 
-public:
-        
-  AliITSsimulationSPD();
-  AliITSsimulationSPD(AliITSsegmentation *seg, AliITSresponse *res);
-  ~AliITSsimulationSPD();
-  AliITSsimulationSPD(const AliITSsimulationSPD &source); // copy constructor
-  AliITSsimulationSPD& operator=(const AliITSsimulationSPD &source); // ass. operator
+ public:        
+    AliITSsimulationSPD(); // Default constructor
+    // Standard constructor
+    AliITSsimulationSPD(AliITSsegmentation *seg, AliITSresponse *res);
+    ~AliITSsimulationSPD();// destructor
+    AliITSsimulationSPD(const AliITSsimulationSPD &source); // copy constructo
+    // assignment operator
+    AliITSsimulationSPD& operator=(const AliITSsimulationSPD &source);
+    // Initilizes the variables
+    void Init(AliITSsegmentationSPD *seg, AliITSresponseSPD *resp);
 
-  void DigitiseModule(AliITSmodule *mod,Int_t module, Int_t dummy);
-  void SetFluctuations(Float_t **pList);
-  void HitToDigit(AliITSmodule *mod, Int_t hitpos, Int_t module, 
-              Int_t *frowpixel, Int_t *fcolpixel, Double_t *fenepixel,
-             Float_t **pList);
-            
-  void UpdateMap( Int_t row, Int_t col, Double_t ene); 
-  void ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,
-                    Float_t z2l,Int_t c1,Int_t r1,Int_t c2,
-                                   Int_t r2,Float_t etot,
-                                   Int_t &npixel,Int_t *frowpixel,
-                                   Int_t *fcolpixel,Double_t *fenepixel);
-  
-  void SetCoupling(Int_t row, Int_t col, Int_t ntrack, Int_t idhit, Float_t **pList);
-  void CreateDigit(Int_t nhits, Int_t module, Float_t **pList);
-  void GetList(Int_t track,Int_t idhit, Float_t **pList, Int_t row, Int_t col);
-
-  void CreateHistograms();
-  void ResetHistograms();
-  TObjArray*  GetHistArray() {
+    // Sum digitize module
+    void SDigitiseModule(AliITSmodule *mod, Int_t dummy0,Int_t dummy1);
+    // digitize module. Also need to digitize modules with only noise.
+    void DigitiseModule(AliITSmodule *mod,Int_t dummy0, Int_t dummy1);
+    // sum digits to Digits.
+    void SDigitsToDigits(Int_t module,AliITSpList *pList);
+    // updates the Map of signal, adding the energy  (ene) released by
+    // the current track
+    void UpdateMapSignal(Int_t row,Int_t col,Int_t trk,Int_t hit,Int_t mod,
+                        Double_t ene,AliITSpList *pList);
+    // updates the Map of noise, adding the energy  (ene) give my noise
+    void UpdateMapNoise(Int_t row,Int_t col,Int_t mod,Double_t ene,
+                       AliITSpList *pList);
+    // Loops over all hits to produce Analog/floting point digits. This
+    // is also the first task in producing standard digits.
+    void HitsToAnalogDigits(AliITSmodule *mod,Int_t *frowpixel,
+                           Int_t *fcolpixel,Double_t *fenepixel,
+                           AliITSpList *pList);
+    //  Steering function to determine the digits associated to a given
+    // hit (hitpos)
+    // The digits are created by charge sharing (ChargeSharing) and by
+    // capacitive coupling (SetCoupling). At all the created digits is
+    // associated the track number of the hit (ntrack)
+    void HitToDigit(AliITSmodule *mod, Int_t hitpos,Int_t *frowpixel,
+                   Int_t *fcolpixel, Double_t *fenepixel,AliITSpList *pList);
+    //  Take into account the geometrical charge sharing when the track
+    //  crosses more than one pixel.
+    void ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,Float_t z2l,
+                      Int_t c1,Int_t r1,Int_t c2,Int_t r2,Float_t etot,
+                      Int_t &npixel,Int_t *frowpixel,Int_t *fcolpixel,
+                      Double_t *fenepixel);
+    //  Take into account the coupling between adiacent pixels.
+    //  The parameters probcol and probrow are the fractions of the
+    //  signal in one pixel shared in the two adjacent pixels along
+    //  the column and row direction, respectively.
+    void SetCoupling(Int_t row,Int_t col,Int_t ntrack,Int_t idhit,Int_t module,
+                    AliITSpList *pList);
+    // The pixels are fired if the energy deposited inside them is above
+    // the threshold parameter ethr. Fired pixed are interpreted as digits
+    // and stored in the file digitfilename. One also needs to write out
+    // cases when there is only noise (nhits==0).
+    void CreateDigit(Int_t module,AliITSpList *pList);
+    //  Set the electronic noise and threshold non-uniformities to all the
+    //  pixels in a detector.
+    //  The parameter fSigma is the squared sum of the sigma due to noise
+    //  and the sigma of the threshold distribution among pixels.
+    void SetFluctuations(AliITSpList *pList,Int_t module);
+    //  Apply a mask to the SPD module. 1% of the pixel channels are
+    //  masked. When the database will be ready, the masked pixels
+    //  should be read from it.
+    void SetMask();
+    // Create Histograms
+    void CreateHistograms();
+    // Reset histograms for this detector
+    void ResetHistograms();
+    // Fills the Summable digits Tree
+    void WriteSDigits(AliITSpList *pList);
+    // Fills fMap2A from the pList of Summable digits
+    void FillMapFrompList(AliITSpList *pList);
     // get hist array
-    return fHis;
-  }
+    TObjArray*  GetHistArray() {return fHis;}
 
-private:
+ private:
+    // Getters for data kept in fSegmentation and fResponse.
+    // Returns the Threshold in electrons
+    Double_t GetThreshold(){Float_t a=0.0,b=0.0;
+    ((AliITSresponseSPD*)fResponse)->Thresholds(a,b); return a;}
+    // Returns the threshold and rms noise.
+    void GetThresholds(Float_t &t,Float_t &s){
+    ((AliITSresponseSPD*)fResponse)->Thresholds(t,s);}
+    // Returns the couplings Columb and Row.
+    void GetCouplings(Float_t &cc,Float_t cr){
+       ((AliITSresponseSPD*)fResponse)->GetNoiseParam(cc,cr);}
+    // Returns the number of pixels in x
+    Int_t GetNPixelsX(){return ((AliITSsegmentationSPD*)fSegmentation)->Npx();}
+    // Returns the number of pixels in z
+    Int_t GetNPixelsZ(){return ((AliITSsegmentationSPD*)fSegmentation)->Npz();}
 
-  AliITSMapA2  *fMapA2;        // MapA2
-  Float_t      fThresh;        // Threshold
-  Float_t      fSigma;         // Noise 
-  Float_t      fCouplCol;      // Coupling along columns
-  Float_t      fCouplRow;      // Coupling along rows
-  Int_t        fNPixelsX;      // NPixelsX
-  Int_t        fNPixelsZ;      // NPixelsZ
+ private:
+/*    Float_t      fThresh;   //! Threshold from fResponse
+    Float_t      fSigma;    //! Noise from fResponse
+    Float_t      fCouplCol; //! Coupling along columns from fResponse
+    Float_t      fCouplRow; //! Coupling along rows from fResponse
+    Int_t        fNPixelsX; //! NPixelsX from fSegmentation
+    Int_t        fNPixelsZ; //! NPixelsZ from fSegmentation
+*/
+    AliITSMapA2  *fMapA2;   //! MapA2 for Local internal use only
+    TObjArray    *fHis;     //! just in case for histogramming for Local
+                            // internal use only
 
-  TObjArray *fHis;             // just in case for histogramming
-    
-  ClassDef(AliITSsimulationSPD,1)  // Simulation of SPD clusters
+    ClassDef(AliITSsimulationSPD,1)  // Simulation of SPD clusters
 
 };
 
-#endif 
-
+#endif
index dee880f..487f6a9 100644 (file)
@@ -24,8 +24,9 @@
 
 #include "AliITSmodule.h"
 #include "AliITSMapA2.h"
-#include "AliITSsegmentationSSD.h"
+#include "AliITSpList.h"
 #include "AliITSresponseSSD.h"
+#include "AliITSsegmentationSSD.h"
 #include "AliITSdcsSSD.h"
 #include "AliITS.h"
 #include "AliRun.h"
@@ -45,8 +46,6 @@ AliITSsimulationSSD::AliITSsimulationSSD(){
     //default Constructor
 
     fDCS     = 0;
-    fNstrips = GetSegmentation()->Npx();
-    fPitch   = GetSegmentation()->Dpx(0);
     fDifConst[0] = fDifConst[1] = 0.0;
     fDriftVel[0] = fDriftVel[1] = 0.0;
     fMapA2   = 0;
@@ -56,14 +55,23 @@ AliITSsimulationSSD::AliITSsimulationSSD(AliITSsegmentation *seg,
                                          AliITSresponse *resp){
     // Constructor
 
+    fDCS     = 0;
+    fDifConst[0] = fDifConst[1] = 0.0;
+    fDriftVel[0] = fDriftVel[1] = 0.0;
+    fMapA2   = 0;
+    Init((AliITSsegmentationSSD*)seg,(AliITSresponseSSD*)resp);
+}
+//----------------------------------------------------------------------
+void AliITSsimulationSSD::Init(AliITSsegmentationSSD *seg,
+                              AliITSresponseSSD *resp){
+    // Constructor
+
     fSegmentation    = seg;
     fResponse        = resp;
     Float_t noise[2] = {0.,0.};
     fResponse->GetNoiseParam(noise[0],noise[1]); // retrieves noise parameters
     fDCS             = new AliITSdcsSSD(seg,resp); 
 
-    fNstrips         = GetSegmentation()->Npx();
-    fPitch           = GetSegmentation()->Dpx(0);
     SetDriftVelocity(); // use default values in .h file
     SetIonizeE();       // use default values in .h file
     SetDiffConst();     // use default values in .h file
@@ -78,8 +86,6 @@ AliITSsimulationSSD& AliITSsimulationSSD::operator=(
 
     this->fDCS         = new AliITSdcsSSD(*(s.fDCS));
     this->fMapA2       = s.fMapA2;
-    this->fNstrips     = s.fNstrips;
-    this->fPitch       = s.fPitch;
     this->fIonE        = s.fIonE;
     this->fDifConst[0] = s.fDifConst[0];
     this->fDifConst[1] = s.fDifConst[1];
@@ -100,32 +106,64 @@ AliITSsimulationSSD::~AliITSsimulationSSD() {
     delete fDCS;
 }
 //______________________________________________________________________
-void AliITSsimulationSSD::DigitiseModule(AliITSmodule *mod,Int_t module,
-                                         Int_t dummy) {
-    // Digitizes hits for one SSD module 
+void AliITSsimulationSSD::DigitiseModule(AliITSmodule *mod,
+                                        Int_t dummy0,Int_t dummy1) {
+    // Digitizes hits for one SSD module
+    Int_t module     = mod->GetIndex();
+    AliITSpList *pList = new AliITSpList(2,GetNStrips());
 
-    Int_t lay, lad, detect;
-    AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
-    AliITSgeom *geom = aliITS->GetITSgeom();
-    geom->GetModuleId(module,lay, lad, detect);
-    if ( lay == 6 ) GetSegmentation()->SetLayer(6);
-    if ( lay == 5 ) GetSegmentation()->SetLayer(5);
+    HitsToAnalogDigits(mod,pList);
+    SDigitToDigit(module,pList);
 
-    TObjArray *hits = mod->GetHits();
-    Int_t nhits     = hits->GetEntriesFast();
-    if (!nhits) return;
-  
-    Double_t x0=0.0, y0=0.0, z0=0.0;
-    Double_t x1=0.0, y1=0.0, z1=0.0;
-    Double_t de=0.0;
-    Int_t maxNdigits = 2*fNstrips;
-    Float_t  **pList = new Float_t* [maxNdigits]; 
-    memset(pList,0,sizeof(Float_t*)*maxNdigits);
+    delete pList;
+    fMapA2->ClearMap();
+}
+//______________________________________________________________________
+void AliITSsimulationSSD::SDigitiseModule(AliITSmodule *mod,Int_t dummy0,
+                                         Int_t dummy1) {
+    // Produces Summable/Analog digits and writes them to the SDigit tree.
+    AliITSpList *pList = new AliITSpList(2,GetNStrips()); 
+
+    HitsToAnalogDigits(mod,pList);
+
+    WriteSDigits(pList);
+
+    delete pList;
+    fMapA2->ClearMap();
+}
+//______________________________________________________________________
+void AliITSsimulationSSD::SDigitToDigit(Int_t module,AliITSpList *pList){
+    // Takes the pList and finishes the digitization.
+
+    FillMapFrompList(pList);
+
+    ApplyNoise(pList,module);
+    ApplyCoupling(pList,module);
+
+    ChargeToSignal(pList);
+}
+//______________________________________________________________________
+void AliITSsimulationSSD::HitsToAnalogDigits(AliITSmodule *mod,
+                                            AliITSpList *pList){
+    // Loops over all hits to produce Analog/floating point digits. This
+    // is also the first task in producing standard digits.
     Int_t indexRange[4] = {0,0,0,0};
     static Bool_t first = kTRUE;
     Int_t lasttrack     = -2;
     Int_t idtrack       = -2;
-    
+    Double_t x0=0.0, y0=0.0, z0=0.0;
+    Double_t x1=0.0, y1=0.0, z1=0.0;
+    Double_t de=0.0;
+    Int_t module = mod->GetIndex();
+
+    TObjArray *hits = mod->GetHits();
+    Int_t nhits     = hits->GetEntriesFast();
+    if (nhits<=0) return;
+
+    module = mod->GetIndex();
+    if ( mod->GetLayer() == 6 ) GetSegmentation()->SetLayer(6);
+    if ( mod->GetLayer() == 5 ) GetSegmentation()->SetLayer(5);
+
     for(Int_t i=0; i<nhits; i++) {    
        // LineSegmentL returns 0 if the hit is entering
        // If hits is exiting returns positions of entering and exiting hits
@@ -135,19 +173,13 @@ void AliITSsimulationSSD::DigitiseModule(AliITSmodule *mod,Int_t module,
            HitToDigit(module, x0, y0, z0, x1, y1, z1, de, indexRange, first);
        
            if (lasttrack != idtrack || i==(nhits-1)) {
-               GetList(idtrack,pList,indexRange);
+               GetList(idtrack,i,module,pList,indexRange);
                first=kTRUE;
            } // end if
            lasttrack=idtrack;
        } // end if
     }  // end loop over hits
-  
-    ApplyNoise();
-    ApplyCoupling();
-
-    ChargeToSignal(pList);
-
-    fMapA2->ClearMap();
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0, 
@@ -203,9 +235,9 @@ void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0,
                w = (x+(GetSegmentation()->Dx()*1.0E-4)/2) + 
                    (z-(GetSegmentation()->Dz()*1.0E-4)/2)*tang[k];
            } // end if
-           w = w / (fPitch*1.0E-4); // w is converted in units of pitch
+           w /= (GetStripPitch()*1.0E-4); // w is converted in units of pitch
 
-           if((w<(-0.5)) || (w>(fNstrips-0.5))) {
+           if((w<(-0.5)) || (w>(GetNStrips()-0.5))) {
                // this check rejects hits in regions not covered by strips
                // 0.5 takes into account boundaries 
                if(k==0) cout<<"AliITSsimulationSSD::HitToDigit: "
@@ -219,7 +251,7 @@ void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0,
            // sigma is the standard deviation of the diffusion gaussian
            if(tdrift[k]<0) return;
            sigma[k] = TMath::Sqrt(2*GetDiffConst(k)*tdrift[k]);
-           sigma[k] = sigma[k] /(fPitch*1.0E-4);  //units of Pitch
+           sigma[k] /= (GetStripPitch()*1.0E-4);  //units of Pitch
            if(sigma[k]==0.0) {         
                cout<<"AliITSsimulationSSD::DigitiseModule: Error: sigma=0"
                    <<endl; 
@@ -239,42 +271,52 @@ void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0,
     //delete seg;
 }
 //______________________________________________________________________
-void AliITSsimulationSSD::ApplyNoise() {
+void AliITSsimulationSSD::ApplyNoise(AliITSpList *pList,Int_t module){
     // Apply Noise.
-  
-    Double_t signal;
-    Double_t noise[2] = {0.,0.};
+    Int_t    k,ix;
+    Double_t signal,noise;
+    Double_t noiseP[2] = {0.,0.};
     Float_t a,b;
+
     fResponse->GetNoiseParam(a,b); // retrieves noise parameters
-    noise[0] = (Double_t) a; noise[1] = (Double_t) b;
-    for(Int_t k=0;k<2;k++){                    // both sides (0=Pside, 1=Nside)
-       for(Int_t ix=0;ix<fNstrips;ix++){      // loop over strips
-           signal = fMapA2->GetSignal(k,ix); // retrieves signal from map
-           signal += gRandom->Gaus(0,noise[k]);// add noise to signal
+    noiseP[0] = (Double_t) a; noiseP[1] = (Double_t) b;
+    for(k=0;k<2;k++){                    // both sides (0=Pside, 1=Nside)
+       for(ix=0;ix<GetNStrips();ix++){      // loop over strips
+           noise  = gRandom->Gaus(0,noiseP[k]);// get noise to signal
+           signal = noise + fMapA2->GetSignal(k,ix);//get signal from map
            if(signal<0.) signal=0.0;           // in case noise is negative...
            fMapA2->SetHit(k,ix,signal); // give back signal to map
+           if(signal>0.0) pList->AddNoise(k,ix,module,noise);
        } // loop over strip 
     } // loop over k (P or N side)
 }
 //______________________________________________________________________
-void AliITSsimulationSSD::ApplyCoupling() {
+void AliITSsimulationSSD::ApplyCoupling(AliITSpList *pList,Int_t module) {
     // Apply the effect of electronic coupling between channels
-    Double_t signalLeft=0, signalRight=0;
+    Int_t ix;
+    Double_t signalLeft=0, signalRight=0,signal=0;
 
-    for(Int_t ix=0;ix<fNstrips;ix++){
+    for(ix=0;ix<GetNStrips();ix++){
+       // P side coupling
        if(ix>0.)signalLeft = fMapA2->GetSignal(0,ix-1)*fDCS->GetCouplingPL();
        else signalLeft = 0.0;
-       if(ix<(fNstrips-1)) signalRight = fMapA2->GetSignal(0,ix+1)*
+       if(ix<(GetNStrips()-1)) signalRight = fMapA2->GetSignal(0,ix+1)*
                                                         fDCS->GetCouplingPR();
        else signalRight = 0.0;
-       fMapA2->AddSignal(0,ix,signalLeft + signalRight);
-    
+       signal = signalLeft + signalRight;
+       fMapA2->AddSignal(0,ix,signal);
+       if(signal>0.0) pList->AddNoise(0,ix,module,signal);
+
+       signalLeft = signalRight = signal = 0.0;
+       // N side coupling
        if(ix>0.) signalLeft = fMapA2->GetSignal(1,ix-1)*fDCS->GetCouplingNL();
        else signalLeft = 0.0;
-       if(ix<(fNstrips-1)) signalRight = fMapA2->GetSignal(1,ix+1)*
+       if(ix<(GetNStrips()-1)) signalRight = fMapA2->GetSignal(1,ix+1)*
                                                          fDCS->GetCouplingNR();
        else signalRight = 0.0;
-       fMapA2->AddSignal(1,ix,signalLeft + signalRight);
+       signal = signalLeft + signalRight;
+       fMapA2->AddSignal(1,ix,signal);
+       if(signal>0.0) pList->AddNoise(1,ix,module,signal);
     } // loop over strips 
 }
 //______________________________________________________________________
@@ -329,8 +371,8 @@ void AliITSsimulationSSD::IntegrateGaussian(Int_t k,Double_t par, Double_t w,
        // for the time being, signal is the charge
        // in ChargeToSignal signal is converted in ADC channel
        fMapA2->AddSignal(k,strip,dXCharge1);
-       if(((Int_t) strip) < (fNstrips-1)) {
-           // strip doesn't have to be the last (remind: last=fNstrips-1)
+       if(((Int_t) strip) < (GetNStrips()-1)) {
+           // strip doesn't have to be the last (remind: last=GetNStrips()-1)
            // otherwise part of the charge is lost
            fMapA2->AddSignal(k,(strip+1),dXCharge2);
        } // end if
@@ -406,126 +448,92 @@ Int_t AliITSsimulationSSD::NumOfSteps(Double_t x, Double_t y, Double_t z,
     return numOfSteps;
 }
 //----------------------------------------------------------------------
-void AliITSsimulationSSD::GetList(Int_t label,Float_t **pList,
-                                 Int_t *indexRange) {
+void AliITSsimulationSSD::GetList(Int_t label,Int_t hit,Int_t mod,
+                                 AliITSpList *pList,Int_t *indexRange) {
     // loop over nonzero digits
-    Int_t ix,globalIndex;
-    Float_t signal=0.;
-    Float_t highest,middle,lowest;
+    Int_t ix,i;
+    Double_t signal=0.;
 
     for(Int_t k=0; k<2; k++) {
        for(ix=indexRange[k*2+0];ix<indexRange[k*2+1]+1;ix++){
-           if(indexRange[k*2+0]<indexRange[k*2+1]) 
+//         if(indexRange[k*2+0]<indexRange[k*2+1]) 
                signal = fMapA2->GetSignal(k,ix);
-
-           globalIndex = k*fNstrips+ix; // globalIndex starts from 0!
-           if(!pList[globalIndex]){
-               // 
-               //Create new list (6 elements-3 signals and 3 tracks+total sig)
-               //
-               pList[globalIndex] = new Float_t [6];
-               // set list to -1
-               *pList[globalIndex] = -2.;
-               *(pList[globalIndex]+1) = -2.;
-               *(pList[globalIndex]+2) = -2.;
-               *(pList[globalIndex]+3) =  0.;
-               *(pList[globalIndex]+4) =  0.;
-               *(pList[globalIndex]+5) =  0.;
-               *pList[globalIndex] = (float)label;
-               *(pList[globalIndex]+3) = signal;
-           }else{
+               if(signal==0.0) continue;
                // check the signal magnitude
-               highest = *(pList[globalIndex]+3);
-               middle = *(pList[globalIndex]+4);
-               lowest = *(pList[globalIndex]+5);
-               signal -= (highest+middle+lowest);
-               //
+               for(i=0;i<pList->GetNSignals(k,ix);i++) 
+                   signal -= pList->GetTSignal(k,ix,i);
                //  compare the new signal with already existing list
-               //
-               if(signal<lowest) continue; // neglect this track
-               if (signal>highest){
-                   *(pList[globalIndex]+5) = middle;
-                   *(pList[globalIndex]+4) = highest;
-                   *(pList[globalIndex]+3) = signal;
-                   *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
-                   *(pList[globalIndex]+1) = *pList[globalIndex];
-                   *pList[globalIndex] = label;
-               }else if (signal>middle){
-                   *(pList[globalIndex]+5) = middle;
-                   *(pList[globalIndex]+4) = signal;
-                   *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
-                   *(pList[globalIndex]+1) = label;
-               }else{
-                   *(pList[globalIndex]+5) = signal;
-                   *(pList[globalIndex]+2) = label;
-               } // end if
-           } // end if
+               pList->AddSignal(k,ix,label,hit,mod,signal);
        } // end of loop pixels in x
     } // end of loop over pixels in z
 }
 //----------------------------------------------------------------------
-void AliITSsimulationSSD::ChargeToSignal(Float_t **pList) {
+void AliITSsimulationSSD::ChargeToSignal(AliITSpList *pList) {
     // charge to signal
-    AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
+    static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
     Float_t threshold = 0.;
-    Int_t digits[3], tracks[3],hits[3],gi,j1;
-    Float_t charges[3];
-    Float_t signal,phys;
+    Int_t   digits[3], tracks[3],hits[3],j1;
+    Float_t charges[3] = {0.0,0.0,0.0};
+    Float_t signal;
     Float_t noise[2] = {0.,0.};
 
-    fResponse->GetNoiseParam(noise[0],noise[1]);
-  
-    for(Int_t k=0;k<2;k++){         // both sides (0=Pside, 1=Nside)
+    ((AliITSresponseSSD*)fResponse)->GetNoiseParam(noise[0],noise[1]);
 
+    for(Int_t k=0;k<2;k++){         // both sides (0=Pside, 1=Nside)
        // Threshold for zero-suppression
        // It can be defined in AliITSresponseSSD
        //             threshold = (Float_t)fResponse->MinVal(k);
        // I prefer to think adjusting the threshold "manually", looking
        // at the scope, and considering noise standard deviation
-       threshold = 4.0*noise[k];      // 4 times noise is a choice
-       for(Int_t ix=0;ix<fNstrips;ix++){         // loop over strips
-
-           signal = (Float_t) fMapA2->GetSignal(k,ix);
-           gi =k*fNstrips+ix; // global index
-           if (signal > threshold) {
-               digits[0]=k;
-               digits[1]=ix;
-
-               // convert to ADC signal
-               // conversion factor are rather arbitrary (need tuning)
-               // minimum ionizing particle--> ~30000 pairs--> ADC channel 50
-               signal = signal*50.0/30000.0;        
-               if(signal>1000.) signal = 1000.0;//if exceeding, accumulate
-                                                 // last one
-               digits[2]=(Int_t) signal;
-               for(j1=0;j1<3;j1++){
-                   if (pList[gi]) {
-                       tracks[j1] = (Int_t)(*(pList[gi]+j1));
-                   } else {
-                       tracks[j1]=-2; //noise
-                   } // end if pList
-                   charges[j1] = 0;
-               } // end for j1
-
-               phys=0;
-
-               hits[0]=0;
-               hits[1]=0;
-               hits[2]=0;
-               // finally add digit
-               aliITS->AddSimDigit(2,phys,digits,tracks,hits,charges);
-           } // end if signal > threshold
-           if(pList[gi]) delete [] pList[gi];
+       threshold = 4.0*noise[k]; // 4 times noise is a choice
+       for(Int_t ix=0;ix<GetNStrips();ix++){     // loop over strips
+           if(fMapA2->GetSignal(k,ix) <= threshold) continue;
+           // convert to ADC signal
+           signal = ((AliITSresponseSSD*)fResponse)->DEvToADC(
+                                                  fMapA2->GetSignal(k,ix));
+           if(signal>1024.) signal = 1024.;//if exceeding, accumulate last one
+           digits[0] = k;
+           digits[1] = ix;
+           digits[2] = (Int_t) signal;
+           for(j1=0;j1<3;j1++){ // only three in digit.
+               tracks[j1]  = pList->GetTrack(k,ix,j1);
+               hits[j1]    = pList->GetHit(k,ix,j1);
+           } // end for j1
+           // finally add digit
+           aliITS->AddSimDigit(2,0,digits,tracks,hits,charges);
        } // end for ix
     } // end for k
-    delete [] pList;
+}
+//______________________________________________________________________
+void AliITSsimulationSSD::WriteSDigits(AliITSpList *pList){
+    // Fills the Summable digits Tree
+    Int_t i,ni,j,nj;
+    static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
+
+    pList->GetMaxMapIndex(ni,nj);
+    for(i=0;i<ni;i++)for(j=0;j<nj;j++){
+       if(pList->GetSignalOnly(i,j)>0.0){
+           aliITS->AddSumDigit(*(pList->GetpListItem(i,j)));
+//         cout << "pListSSD: " << *(pList->GetpListItem(i,j)) << endl;
+       } // end if
+    } // end for i,j
+    return;
+}
+//______________________________________________________________________
+void AliITSsimulationSSD::FillMapFrompList(AliITSpList *pList){
+    // Fills fMap2A from the pList of Summable digits
+    Int_t k,ix;
+
+    for(k=0;k<2;k++)for(ix=0;ix<GetNStrips();ix++) 
+       fMapA2->AddSignal(k,ix,pList->GetSignal(k,ix));
+    return;
 }
 //______________________________________________________________________
 void AliITSsimulationSSD::Print(ostream *os){
     //Standard output format for this class
 
     //AliITSsimulation::Print(os);
-    *os << fNstrips <<","<< fPitch <<","<< fIonE <<",";
+    *os << fIonE <<",";
     *os << fDifConst[0] <<","<< fDifConst[1] <<",";
     *os << fDriftVel[0] <<","<< fDriftVel[1];
     //*os <<","; fDCS->Print(os);
@@ -536,7 +544,7 @@ void AliITSsimulationSSD::Read(istream *is){
     // Standard output streaming function.
 
     //AliITSsimulation::Read(is);
-    *is >> fNstrips >> fPitch >> fIonE;
+    *is >> fIonE;
     *is >> fDifConst[0] >> fDifConst[1];
     *is >> fDriftVel[0] >> fDriftVel[1];
     //fDCS->Read(is);
@@ -556,3 +564,4 @@ istream &operator>>(istream &os,AliITSsimulationSSD &source){
     source.Read(&os);
     return os;
 }
+//______________________________________________________________________
index faf1328..3f1801f 100644 (file)
@@ -5,10 +5,13 @@
 /* $Id$ */
 
 #include "AliITSsimulation.h"
+#include "AliITSsegmentationSSD.h" // function used in inline functions
 
 class AliITSMapA2;
+class AliITSpList;
 class AliITSdcsSSD;
 class AliITSsegmentationSSD;
+class AliITSresponseSSD;
 
 class AliITSsimulationSSD: public AliITSsimulation {
 
@@ -21,19 +24,18 @@ class AliITSsimulationSSD: public AliITSsimulation {
     AliITSsimulationSSD(AliITSsegmentation *seg,AliITSresponse *resp);
     //Destructor
     virtual ~AliITSsimulationSSD();
+    // Initilize variables for this simulation
+    void Init(AliITSsegmentationSSD *seg,AliITSresponseSSD *resp);
     //Digitizes all of the hits in a module
-    void DigitiseModule(AliITSmodule *mod,Int_t imod,Int_t dummy);
+    void DigitiseModule(AliITSmodule *mod,Int_t dummy0,Int_t dummy1);
+    // Computes the Summable Digits
+    void SDigitiseModule(AliITSmodule *mod,Int_t module,Int_t dummy);
+    // Computes the Charge on each Strip/ Analog/summable digits
+    void HitsToAnalogDigits(AliITSmodule *mod,AliITSpList *pList);
     //Computes the signal from one hit
     void HitToDigit(Int_t module,Double_t x0,Double_t y0,Double_t z0, 
                    Double_t x,Double_t y,Double_t z,Double_t de,
                    Int_t *indexRange,Bool_t first);
-    // returns the number of steps needed to proplerly distribute the charge
-    // in a step
-    Int_t NumOfSteps(Double_t x,Double_t y,Double_t z,
-                    Double_t  &dex,Double_t &dey,Double_t &dez);
-    void GetList(Int_t track,Float_t **pList,Int_t *IndexRange);
-    // sets thresholds and fills digits
-    void ChargeToSignal(Float_t **pList);
     //returns a pointer to the SSD segmentation.
     AliITSsegmentationSSD *GetSegmentation() {
        return (AliITSsegmentationSSD*) fSegmentation;}
@@ -56,20 +58,39 @@ class AliITSsimulationSSD: public AliITSsimulation {
     // Standard ascii class read function
     void Read(istream *is);
 
- protected:
+ private:
+    // returns the number of steps needed to proplerly distribute the charge
+    // in a step
+    Int_t NumOfSteps(Double_t x,Double_t y,Double_t z,
+                    Double_t  &dex,Double_t &dey,Double_t &dez);
+    // Keepts track and orders tracks for a give strip.
+    void GetList(Int_t trk,Int_t ht,Int_t mod,AliITSpList *pLt,Int_t *indxRng);
+    // sets thresholds and fills digits
+    void ChargeToSignal(AliITSpList *pList);
+    // Writes Summable Digits to a root file for later use.
+    void WriteSDigits(AliITSpList *pList);
+    // ReadSDigits and create Digits
+    void SDigitToDigit(Int_t module,AliITSpList *pList);
+    // Fills fMapA2 from pList AliITSpList
+    void FillMapFrompList(AliITSpList *pList);
     // Diffuses the charge onto neighboring strips.
     void    IntegrateGaussian(Int_t k,Double_t par,Double_t av,Double_t sigma, 
                              Double_t inf, Double_t sup,
                              Int_t *indexRange, Bool_t first);
-    void    ApplyNoise(); // Applies noise to strips randomly
-    void    ApplyCoupling(); // Applies posible signal coupling between strips
+     // Applies noise to strips randomly
+    void    ApplyNoise(AliITSpList *pList,Int_t mod);
+     // Applies posible signal coupling between strips
+    void    ApplyCoupling(AliITSpList *pList,Int_t mod);
+    // Computes the integral of a gaussian using Error Function
     Float_t F(Float_t av, Float_t x, Float_t s);
+    // returns, from the segmentation, the number of stips
+    Int_t GetNStrips() {return GetSegmentation()->Npx();}
+    // returns, from the segmentation, the strip pitch
+    Float_t GetStripPitch() {return GetSegmentation()->Dpx(0);}
 
     // Data members
  protected:
     AliITSdcsSSD *fDCS;   // Class containing detector controle paramters
-    Int_t        fNstrips;//! number of strips, gotten from segmentation
-    Float_t      fPitch;  //! strip pitch spacing gotten from segmentation
 
  private:
     AliITSMapA2 *fMapA2;      //! Map of ionization, used localy only