Update of SSD simulation and reconstruction code by Boris and Enrico.
authornilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 1 May 2001 22:42:22 +0000 (22:42 +0000)
committernilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 1 May 2001 22:42:22 +0000 (22:42 +0000)
ITS/AliITSClusterFinderSSD.cxx
ITS/AliITSClusterFinderSSD.h
ITS/AliITSsegmentationSSD.cxx
ITS/AliITSsegmentationSSD.h
ITS/AliITSsimulationSSD.cxx
ITS/SSD_ntuple.C
ITS/SSDrecpointTest.C

index aab672ab6dff0bcfe89ac849d143c5f6ad2a77a7..42a7f84bad5835e83ec1a1eeff5fadccee43f7f3 100644 (file)
@@ -25,6 +25,8 @@
 #include "AliITSclusterSSD.h"
 #include "AliITSpackageSSD.h"
 #include "AliITSsegmentation.h"
+#include "AliITSgeom.h"
+#include "AliITSsegmentationSSD.h"
 
 const Bool_t AliITSClusterFinderSSD::fgkSIDEP=kTRUE;
 const Bool_t AliITSClusterFinderSSD::fgkSIDEN=kFALSE;
@@ -32,15 +34,15 @@ const Int_t debug=0;
 
 ClassImp(AliITSClusterFinderSSD)
 
-//____________________________________________________________________
+//______________________________________________________________________
 //
 //  Constructor
-//____________________________________________________________________
+//______________________________________________________________________
 //                                     
 
 
-AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesArray *digits)   
-{
+AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, 
+                                              TClonesArray *digits){
 //Standard constructor
 
     fSegmentation=seg;
@@ -58,7 +60,6 @@ AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesA
 
     fPackages =  new TClonesArray ("AliITSpackageSSD",200);    //packages  
     fNPackages = 0;
-
         
     fDigitsIndexP      =  new TArrayI(300);
     fNDigitsP          =  0;
@@ -66,22 +67,11 @@ AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesA
     fDigitsIndexN      =  new TArrayI(300);
     fNDigitsN          =  0;
     
-    //SetAlpha1(1000);
-    //SetAlpha2(1000);
-    //SetAlpha3(1000);
-
-    
     fPitch = fSegmentation->Dpx(0);
-    Float_t StereoP,StereoN;
-    fSegmentation->Angles(StereoP,StereoN);
-    fTanP=TMath::Tan(StereoP);
-    fTanN=TMath::Tan(StereoN);
-
     fPNsignalRatio=7./8.;         // warning: hard-wired number
 
 }
-
-//-------------------------------------------------------
+//----------------------------------------------------------------------
 AliITSClusterFinderSSD::~AliITSClusterFinderSSD() {
 // Default destructor   
 
@@ -91,55 +81,50 @@ AliITSClusterFinderSSD::~AliITSClusterFinderSSD() {
     delete fDigitsIndexP;        
     delete fDigitsIndexN; 
     delete fMap;
-
 }
-
-//-------------------------------------------------------
-void AliITSClusterFinderSSD::InitReconstruction()
-{
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::InitReconstruction(){
 // initialization of the cluster finder
+    register Int_t i; //iterator
 
-  register Int_t i; //iterator
+    for (i=0;i<fNClusterP;i++){
+       fClusterP->RemoveAt(i);
+    } // end for i
+    fNClusterP  =0 ;
+    for (i=0;i<fNClusterN;i++){
+       fClusterN->RemoveAt(i);
+    } // end for i
+    fNClusterN=0;
 
-  for (i=0;i<fNClusterP;i++)
-    {
-      fClusterP->RemoveAt(i);
-    }
-  fNClusterP  =0;
-  for (i=0;i<fNClusterN;i++)
-    {
-      fClusterN->RemoveAt(i);
-    }
-  fNClusterN=0;
-
-  for (i=0;i<fNPackages;i++)
-    {
-      fPackages->RemoveAt(i);
-    }
+    for (i=0;i<fNPackages;i++){
+       fPackages->RemoveAt(i);
+    } // end for i
 
-  fNPackages = 0;
-  fNDigitsP=0;
-  fNDigitsN=0;
+    fNPackages = 0;
+    fNDigitsP  = 0;
+    fNDigitsN  = 0;
 
-  Float_t StereoP,StereoN;
-  fSegmentation->Angles(StereoP,StereoN);
+    Float_t StereoP,StereoN;
+    fSegmentation->Angles(StereoP,StereoN);
 
-  CalcStepFactor (StereoP,StereoN);
+    CalcStepFactor (StereoP,StereoN);
 
-  if (debug) cout<<"fSFF = "<<fSFF<<"  fSFB = "<<fSFB<<"\n";
+    if (debug) cout<<"fSFF = "<<fSFF<<"  fSFB = "<<fSFB<<"\n";
 }
-
-
-//---------------------------------------------
-void AliITSClusterFinderSSD::FindRawClusters() 
-{
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::FindRawClusters(Int_t module){
 // This function findes out all clusters belonging to one module
 // 1. Zeroes all space after previous module reconstruction
-// 2. Finds all neighbouring digits
+// 2. Finds all neighbouring digits, create clusters
 // 3. If necesery, resolves for each group of neighbouring digits 
 //    how many clusters creates it.
-// 4. Creates packages  
-// 5. Creates clusters 
+// 4. Colculate the x and z coordinate
+  Int_t lay, lad, detect;
+  AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
+  AliITSgeom *geom = aliITS->GetITSgeom();
+  geom->GetModuleId(module,lay, lad, detect);
+  if ( lay == 6 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(6);
+  if ( lay == 5 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(5);
 
   InitReconstruction();  //ad. 1
   fMap->FillMap();
@@ -151,441 +136,373 @@ void AliITSClusterFinderSSD::FindRawClusters()
   AliITSRecPoint rnew;
   fMap->ClearMap();
 }
-
-
-//-------------------------------------------------
-void AliITSClusterFinderSSD::FindNeighbouringDigits()
-{
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::FindNeighbouringDigits(){
 //If there are any digits on this side, create 1st Cluster,
 // add to it this digit, and increment number of clusters
-
-
- register Int_t i;
-
-
- if ((fNDigitsP>0 )  && (fNDigitsN > 0 )) {     
-
-   Int_t currentstripNo;
-   Int_t *dbuffer = new Int_t [300];   //buffer for strip numbers
-   Int_t dnumber;    //curent number of digits in buffer
-   TArrayI      &lDigitsIndexP = *fDigitsIndexP;
-   TArrayI      &lDigitsIndexN = *fDigitsIndexN;
-   TObjArray    &lDigits       = *(Digits());
-   TClonesArray &lClusterP     = *fClusterP;
-   TClonesArray &lClusterN     = *fClusterN;
-  
-   //process P side 
-   dnumber = 1;
-   dbuffer[0]=lDigitsIndexP[0];
-   //If next digit is a neighbour of previous, adds to last cluster this digit
-   for (i=1; i<fNDigitsP; i++) {
-     //reads new digit
-     currentstripNo = ((AliITSdigitSSD*)lDigits[lDigitsIndexP[i]])->
-                                                            GetStripNumber(); 
-     //check if it is a neighbour of a previous one
-     if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexP[i-1]])->GetStripNumber()) 
-           ==  (currentstripNo-1) ) dbuffer[dnumber++]=lDigitsIndexP[i];
-     else  { 
-       //create a new one side cluster
-       new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEP); 
-       dbuffer[0]=lDigitsIndexP[i];
-       dnumber = 1;
-     }
-   } // end loop over fNDigitsP
-   new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEP);
-
-
-   //process N side 
-   //for comments, see above
-   dnumber = 1;
-   dbuffer[0]=lDigitsIndexN[0];
-   //If next digit is a neighbour of previous, adds to last cluster this digit
-   for (i=1; i<fNDigitsN; i++) { 
-     currentstripNo = ((AliITSdigitSSD*)(lDigits[lDigitsIndexN[i]]))->
+    register Int_t i;
+
+    if ((fNDigitsP>0 )  && (fNDigitsN > 0 )) {     
+
+       Int_t currentstripNo;
+       Int_t *dbuffer = new Int_t [300];   //buffer for strip numbers
+       Int_t dnumber;    //curent number of digits in buffer
+       TArrayI      &lDigitsIndexP = *fDigitsIndexP;
+       TArrayI      &lDigitsIndexN = *fDigitsIndexN;
+       TObjArray    &lDigits       = *(Digits());
+       TClonesArray &lClusterP     = *fClusterP;
+       TClonesArray &lClusterN     = *fClusterN;
+
+       //process P side 
+       dnumber = 1;
+       dbuffer[0]=lDigitsIndexP[0];
+       // If next digit is a neighbour of previous, adds to last cluster
+       // this digit
+       for (i=1; i<fNDigitsP; i++) {
+           //reads new digit
+           currentstripNo = ((AliITSdigitSSD*)lDigits[lDigitsIndexP[i]])->
+                                                            GetStripNumber(); 
+           //check if it is a neighbour of a previous one
+           if((((AliITSdigitSSD*)lDigits[lDigitsIndexP[i-1]])->
+               GetStripNumber()) == (currentstripNo-1) ){
+               dbuffer[dnumber++]=lDigitsIndexP[i];
+           }else{ 
+               //create a new one side cluster
+               new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,
+                                                  dbuffer,Digits(),fgkSIDEP); 
+               dbuffer[0]=lDigitsIndexP[i];
+               dnumber = 1;
+           } // end if
+       } // end loop over fNDigitsP
+       new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,
+                                                     Digits(),fgkSIDEP);
+       //process N side 
+       //for comments, see above
+       dnumber = 1;
+       dbuffer[0]=lDigitsIndexN[0];
+       // If next digit is a neighbour of previous, adds to last cluster
+       // this digit
+       for (i=1; i<fNDigitsN; i++) { 
+           currentstripNo = ((AliITSdigitSSD*)(lDigits[lDigitsIndexN[i]]))->
                                                             GetStripNumber();
-     if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexN[i-1]])->GetStripNumber()) 
-           == (currentstripNo-1) ) dbuffer[dnumber++]=lDigitsIndexN[i];
-     else {
-       new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEN);
-       dbuffer[0]=lDigitsIndexN[i];
-       dnumber = 1;
-     }
-   } // end loop over fNDigitsN
-   new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEN);
-   delete [] dbuffer; 
- } // end condition on  NDigits 
-
- if (debug) cout<<"\n Found clusters: fNClusterP = "<<fNClusterP<<"  fNClusterN ="<<fNClusterN<<"\n";
-
-}  
-
-//--------------------------------------------------------------
-
-void AliITSClusterFinderSSD::SeparateOverlappedClusters()
-{
+           if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexN[i-1]])->
+                 GetStripNumber()) == (currentstripNo-1) ){
+               dbuffer[dnumber++]=lDigitsIndexN[i];
+           }else{
+               new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,
+                                                            Digits(),fgkSIDEN);
+               dbuffer[0]=lDigitsIndexN[i];
+               dnumber = 1;
+           } // end if
+       } // end loop over fNDigitsN
+       new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,
+                                                     Digits(),fgkSIDEN);
+       delete [] dbuffer;
+    } // end condition on  NDigits 
+
+    if (debug) cout<<"\n Found clusters: fNClusterP = "<<fNClusterP<<
+                  "  fNClusterN ="<<fNClusterN<<"\n";
+}
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::SeparateOverlappedClusters(){
 // overlapped clusters separation
-
-  register Int_t i; //iterator
-
-  Float_t  factor=0.75;            // How many percent must be lower signal 
-                                   // on the middle one digit
-                                   // from its neighbours
-  Int_t    signal0;                //signal on the strip before the current one
-  Int_t    signal1;                //signal on the current one signal
-  Int_t    signal2;                //signal on the strip after the current one
-  TArrayI *splitlist;              //  List of splits
-  Int_t    numerofsplits=0;        // number of splits
-  Int_t    initPsize = fNClusterP; //initial size of the arrays 
-  Int_t    initNsize = fNClusterN; //we have to keep it because it will grow 
-                                   // in this function and it doasn't make 
-                                   // sense to pass through it again
-
-  splitlist = new TArrayI(300);
-
-  for (i=0;i<initPsize;i++)
-  {
-    if (( ((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==1) continue;
-    if (( ((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==2) continue;
+    register Int_t i; //iterator
+    Float_t  factor=0.75;           // How many percent must be lower signal
+                                    // on the middle one digit
+                                    // from its neighbours
+    Int_t    signal0;               //signal on strip before the current one
+    Int_t    signal1;               //signal on the current one signal
+    Int_t    signal2;               //signal on the strip after the current one
+    TArrayI *splitlist;             //  List of splits
+    Int_t    numerofsplits=0;       // number of splits
+    Int_t    initPsize = fNClusterP;//initial size of the arrays 
+    Int_t    initNsize = fNClusterN;//we have to keep it because it will grow 
+                                    // in this function and it doasn't make 
+                                    // sense to pass through it again
+
+    splitlist = new TArrayI(300);
+
+    for (i=0;i<initPsize;i++){
+       if((((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==1) continue;
+       if((((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==2) continue;
         Int_t nj=(((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits()-1);
-        for (Int_t j=1; j<nj; j++)
-          {
+        for (Int_t j=1; j<nj; j++){
             signal1=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j);
             signal0=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j-1);
             signal2=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j+1);
             //if signal is less then factor*signal of its neighbours
-            if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) )
-             {                                                               
-               (*splitlist)[numerofsplits++]=j;  
-            }
-         } // end loop over number of digits
+            if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) ){
+               (*splitlist)[numerofsplits++]=j;  
+           } // end if
+       } // end loop over number of digits
           //split this cluster if necessary
-          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEP);
-         numerofsplits=0;
-
-         //in signed places (splitlist)
-  } // end loop over clusters on Pside
-
-  for (i=0;i<initNsize;i++) {
-    if (( ((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==1) continue;
-    if (( ((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==2) continue;
-       Int_t nj=(((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits()-1);
-       for (Int_t j=1; j<nj; j++)
-          {
+       if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEP);
+       numerofsplits=0;
+
+       //in signed places (splitlist)
+    } // end loop over clusters on Pside
+
+    for (i=0;i<initNsize;i++) {
+       if((((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==1) continue;
+       if((((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==2) continue;
+       Int_t nj=(((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits()-1);
+       for (Int_t j=1; j<nj; j++){
             signal1=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j);
             signal0=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j-1);
             signal2=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j+1);
             //if signal is less then factor*signal of its neighbours
             if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) ) 
-               (*splitlist)[numerofsplits++]=j;  
-          } // end loop over number of digits 
-          //split this cluster into more clusters
-          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEN);
-         numerofsplits=0;                                                              //in signed places (splitlist)
-  } // end loop over clusters on Nside
-
-  delete splitlist;
+               (*splitlist)[numerofsplits++]=j;  
+       } // end loop over number of digits 
+       //split this cluster into more clusters
+       if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEN);
+       numerofsplits=0;                                                              //in signed places (splitlist)
+    } // end loop over clusters on Nside
+
+    delete splitlist;
 }
-
-//-------------------------------------------------------
-void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits, Int_t index, Bool_t side)
-{
-  //This function splits one side cluster into more clusters
-  //number of splits is defined by "nsplits"
-  //Place of splits are defined in the TArray "list" 
-  
-  // For further optimisation: Replace this function by two 
-  // specialised ones (each for one side)
-  // save one "if"
-
-  //For comlete comments see AliITSclusterSSD::SplitCluster
-
-
-  register Int_t i; //iterator
-
-  AliITSclusterSSD* curentcluster;
-  Int_t   *tmpdigits = new Int_t[100];
-  Int_t    NN;
-  // side true means P side
-  if (side) {
-     curentcluster =((AliITSclusterSSD*)((*fClusterP)[index])) ;
-     for (i = nsplits; i>0 ;i--) {  
-         NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
-         new ((*fClusterP)[fNClusterP]) AliITSclusterSSD(NN,tmpdigits,Digits(),side);
-        ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
-                                                      SetLeftNeighbour(kTRUE);
-         //if left cluster had neighbour on the right before split 
-        //new should have it too
-        if ( curentcluster->GetRightNeighbour() ) 
-                     ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
-                                                     SetRightNeighbour(kTRUE);
-         else curentcluster->SetRightNeighbour(kTRUE); 
-        fNClusterP++;
-     } // end loop over nplits
-  } else {
-     curentcluster =((AliITSclusterSSD*)((*fClusterN)[index]));
-     for (i = nsplits; i>0 ;i--) {  
-         NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
-        new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(NN,tmpdigits,Digits(),side);
-        ((AliITSclusterSSD*)((*fClusterN)[fNClusterN]))->
-                                                    SetRightNeighbour(kTRUE);
-        if (curentcluster->GetRightNeighbour())
-                      ( (AliITSclusterSSD*)( (*fClusterN)[fNClusterN]) )->
-                                                     SetRightNeighbour(kTRUE);
-        else curentcluster->SetRightNeighbour(kTRUE);      
-        fNClusterN++;
-     } // end loop over nplits
-  } // end if side
-  delete []tmpdigits;
-
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits,
+                                         Int_t index, Bool_t side){
+    //This function splits one side cluster into more clusters
+    //number of splits is defined by "nsplits"
+    //Place of splits are defined in the TArray "list"
+    // For further optimisation: Replace this function by two 
+    // specialised ones (each for one side)
+    // save one "if"
+    //For comlete comments see AliITSclusterSSD::SplitCluster
+    register Int_t i; //iterator
+    AliITSclusterSSD* curentcluster;
+    Int_t   *tmpdigits = new Int_t[100];
+    Int_t    NN;
+    // side true means P side
+
+    if (side) {
+       curentcluster =((AliITSclusterSSD*)((*fClusterP)[index])) ;
+       for (i = nsplits; i>0 ;i--) {  
+           NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
+           new ((*fClusterP)[fNClusterP]) AliITSclusterSSD(NN,
+                                                     tmpdigits,Digits(),side);
+           ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
+               SetLeftNeighbour(kTRUE);
+           //if left cluster had neighbour on the right before split 
+           //new should have it too
+           if ( curentcluster->GetRightNeighbour() ) 
+               ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
+                   SetRightNeighbour(kTRUE);
+           else curentcluster->SetRightNeighbour(kTRUE); 
+           fNClusterP++;
+       } // end loop over nplits
+    } else {
+       curentcluster =((AliITSclusterSSD*)((*fClusterN)[index]));
+       for (i = nsplits; i>0 ;i--) {  
+           NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
+           new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(NN,
+                                                     tmpdigits,Digits(),side);
+           ((AliITSclusterSSD*)((*fClusterN)[fNClusterN]))->
+               SetRightNeighbour(kTRUE);
+           if (curentcluster->GetRightNeighbour())
+               ( (AliITSclusterSSD*)( (*fClusterN)[fNClusterN]) )->
+                   SetRightNeighbour(kTRUE);
+           else curentcluster->SetRightNeighbour(kTRUE);      
+           fNClusterN++;
+       } // end loop over nplits
+    } // end if side
+    delete []tmpdigits;
 }
-
-
-//-------------------------------------------------
-Int_t AliITSClusterFinderSSD::SortDigitsP(Int_t start, Int_t end)
-{
+//----------------------------------------------------------------------
+Int_t AliITSClusterFinderSSD::SortDigitsP(Int_t start, Int_t end){
 // sort digits on the P side
-
-  
-  Int_t right;
-  Int_t left;
-  if (start != (end - 1) ) 
-    {
-      left=this->SortDigitsP(start,(start+end)/2);
-      right=this->SortDigitsP((start+end)/2,end);  
-      return (left || right);
-    }
-  else
-   { 
-    left =  ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[start]]))->GetStripNumber();
-    right= ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[end]]))->GetStripNumber();  
-    if( left > right )
-     {
-       Int_t tmp = (*fDigitsIndexP)[start];
-       (*fDigitsIndexP)[start]=(*fDigitsIndexP)[end];
-       (*fDigitsIndexP)[end]=tmp;
-       return 1;
-     }
-    else return 0;
-   }
+    Int_t right;
+    Int_t left;
+    if (start != (end - 1) ){
+       left=this->SortDigitsP(start,(start+end)/2);
+       right=this->SortDigitsP((start+end)/2,end);  
+       return (left || right);
+    }else{ 
+       left = ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[start]]))->
+                                                             GetStripNumber();
+       right= ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[end]]))->
+                                                             GetStripNumber();
+       if( left > right ){
+           Int_t tmp = (*fDigitsIndexP)[start];
+           (*fDigitsIndexP)[start]=(*fDigitsIndexP)[end];
+           (*fDigitsIndexP)[end]=tmp;
+           return 1;
+       } // end if
+       else return 0;
+    } // end if
 }
-
-
-//--------------------------------------------------
-
-Int_t AliITSClusterFinderSSD::SortDigitsN(Int_t start, Int_t end)
-{
+//----------------------------------------------------------------------
+Int_t AliITSClusterFinderSSD::SortDigitsN(Int_t start, Int_t end){
 // sort digits on the N side
-
-  Int_t right;
-  Int_t left;
-  if (start != (end - 1)) 
-    {
-      left=this->SortDigitsN(start,(start+end)/2);
-      right=this->SortDigitsN((start+end)/2,end);  
-      return (left || right);
-    }
-  else 
-   {
-    left =((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[start]]))->GetStripNumber(); 
-    right=((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[end]]))->GetStripNumber();
-    if ( left > right )
-      {
-        Int_t tmp = (*fDigitsIndexN)[start];
-        (*fDigitsIndexN)[start]=(*fDigitsIndexN)[end];
-        (*fDigitsIndexN)[end]=tmp;
-        return 1;
-      }else return 0;
-   }  
+    Int_t right;
+    Int_t left;
+
+    if (start != (end - 1)){
+       left=this->SortDigitsN(start,(start+end)/2);
+       right=this->SortDigitsN((start+end)/2,end);  
+       return (left || right);
+    }else{
+       left =((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[start]]))->
+                                                            GetStripNumber(); 
+       right=((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[end]]))->
+                                                             GetStripNumber();
+       if ( left > right ){
+           Int_t tmp = (*fDigitsIndexN)[start];
+           (*fDigitsIndexN)[start]=(*fDigitsIndexN)[end];
+           (*fDigitsIndexN)[end]=tmp;
+           return 1;
+       }else return 0;
+    } // end if
 }
-
-
-//------------------------------------------------
-void AliITSClusterFinderSSD::FillDigitsIndex()
-{
- //Fill the indexes of the clusters belonging to a given ITS module
-
- Int_t PNs=0, NNs=0;
- Int_t tmp,bit,k;
- Int_t N;
- Int_t i;
- N = fDigits->GetEntriesFast();
-
- Int_t* PSidx = new Int_t [N*sizeof(Int_t)];
- Int_t* NSidx = new Int_t [N*sizeof(Int_t)]; 
- if (fDigitsIndexP==NULL) fDigitsIndexP = new TArrayI(N);
- if (fDigitsIndexN==NULL) fDigitsIndexN = new TArrayI(N);
- AliITSdigitSSD *dig; 
- for ( i = 0 ; i< N; i++ ) {
-      dig = (AliITSdigitSSD*)GetDigit(i);
-      if(dig->IsSideP()) { 
-           bit=1;
-           tmp=dig->GetStripNumber();
-          // I find this totally unnecessary - it's just a 
-          // CPU consuming double check
-           for( k=0;k<PNs;k++)
-            {
-             if (tmp==PSidx[k])
-              {
-                 if (debug) cout<<"Such a digit exists \n";
-                 bit=0;
-              }
-           }   
-          // end comment 
-        if(bit) {
-            fDigitsIndexP->AddAt(i,fNDigitsP++);
-            PSidx[PNs++]=tmp;
-       }
-      } else {
-         bit=1;
-         tmp=dig->GetStripNumber();
-        // same as above
-         for( k=0;k<NNs;k++)
-          {
-           if (tmp==NSidx[k])
-            {
-             if (debug) cout<<"Such a digit exists \n";
-             bit=0;
-            }
-          } 
-        // end comment
-         if (bit) {
-          fDigitsIndexN->AddAt(i,fNDigitsN++);
-          NSidx[NNs++] =tmp;
-        }
-      }
- }
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::FillDigitsIndex(){
+    //Fill the indexes of the clusters belonging to a given ITS module
+    Int_t PNs=0, NNs=0;
+    Int_t tmp,bit,k;
+    Int_t N;
+    Int_t i;
+
+    N = fDigits->GetEntriesFast();
+
+    Int_t* PSidx = new Int_t [N*sizeof(Int_t)];
+    Int_t* NSidx = new Int_t [N*sizeof(Int_t)]; 
+    if (fDigitsIndexP==NULL) fDigitsIndexP = new TArrayI(N);
+    if (fDigitsIndexN==NULL) fDigitsIndexN = new TArrayI(N);
+
+    AliITSdigitSSD *dig;
+
+    for ( i = 0 ; i< N; i++ ) {
+       dig = (AliITSdigitSSD*)GetDigit(i);
+       if(dig->IsSideP()) { 
+           bit=1;
+           tmp=dig->GetStripNumber();
+           // I find this totally unnecessary - it's just a 
+           // CPU consuming double check
+           for( k=0;k<PNs;k++){
+               if (tmp==PSidx[k]){
+                   if (debug) cout<<"Such a digit exists \n";
+                   bit=0;
+               } // end if
+           } // end if
+           // end comment 
+           if(bit) {
+               fDigitsIndexP->AddAt(i,fNDigitsP++);
+               PSidx[PNs++]=tmp;
+           } // end if bit
+       } else {
+           bit=1;
+           tmp=dig->GetStripNumber();
+           // same as above
+           for( k=0;k<NNs;k++){
+               if (tmp==NSidx[k]){
+                   if (debug) cout<<"Such a digit exists \n";
+                   bit=0;
+               } // end if
+           } // end for k
+           // end comment
+           if (bit) {
+               fDigitsIndexN->AddAt(i,fNDigitsN++);
+               NSidx[NNs++] =tmp;
+           } // end if bit
+       } // end for dig->IsSideP()
+    } // end for i
    
- delete [] PSidx;
- delete [] NSidx;
   delete [] PSidx;
   delete [] NSidx;
 
- if (debug) cout<<"Digits :  P = "<<fNDigitsP<<"   N = "<<fNDigitsN<<endl;
   if (debug) cout<<"Digits :  P = "<<fNDigitsP<<"   N = "<<fNDigitsN<<endl;
 
 }
-
-
-//-------------------------------------------
-
-void AliITSClusterFinderSSD::SortDigits()
-{
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::SortDigits(){
 // sort digits
+    Int_t i;
 
-  Int_t i;
-  if(fNDigitsP>1) 
-  for (i=0;i<fNDigitsP-1;i++)
-  if (SortDigitsP(0,(fNDigitsP-1-i))==0) break;
+    if(fNDigitsP>1) 
+       for (i=0;i<fNDigitsP-1;i++)
+           if (SortDigitsP(0,(fNDigitsP-1-i))==0) break;
 
-  if(fNDigitsN>1) 
-    for (i=0;i<fNDigitsN-1;i++)
-  if(SortDigitsN(0,(fNDigitsN-1-i))==0) break;
+    if(fNDigitsN>1) 
+       for (i=0;i<fNDigitsN-1;i++)
+           if(SortDigitsN(0,(fNDigitsN-1-i))==0) break;
 }
-
-
-
-//----------------------------------------------
-void AliITSClusterFinderSSD::FillClIndexArrays(Int_t* arrayP, Int_t *arrayN)
-{
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::FillClIndexArrays(Int_t* arrayP, Int_t *arrayN){
 // fill cluster index array
-
-  register Int_t i;
-  for (i=0; i<fNClusterP;i++)
-    {
-      arrayP[i]=i;
-    }
-  for (i=0; i<fNClusterN;i++)
-    {
-      arrayN[i]=i;
-    }
+    register Int_t i;
+
+    for (i=0; i<fNClusterP;i++){
+       arrayP[i]=i;
+    } // end for i
+    for (i=0; i<fNClusterN;i++){
+       arrayN[i]=i;
+    } // end for i
 }
-
-
-//------------------------------------------------------
-void AliITSClusterFinderSSD::SortClusters(Int_t* arrayP, Int_t *arrayN)
-{
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::SortClusters(Int_t* arrayP, Int_t *arrayN){
 // sort clusters
-
-  Int_t i;
-  if(fNClusterP>1) 
-    for (i=0;i<fNClusterP-1;i++)
-      if (SortClustersP(0,(fNClusterP-1),arrayP)==0)  break;
-    
-    
-  if(fNClusterN>1) 
-    for (i=0;i<fNClusterN-1;i++)
-      if (SortClustersN(0,(fNClusterN-1),arrayN)==0)  break;
-
+    Int_t i;
+
+    if(fNClusterP>1) 
+       for (i=0;i<fNClusterP-1;i++)
+           if (SortClustersP(0,(fNClusterP-1),arrayP)==0)  break;
+    if(fNClusterN>1) 
+       for (i=0;i<fNClusterN-1;i++)
+           if (SortClustersN(0,(fNClusterN-1),arrayN)==0)  break;
 }
-
-
-
-//---------------------------------------------------
-Int_t AliITSClusterFinderSSD::SortClustersP(Int_t start, Int_t end, Int_t *array)
-{
+//----------------------------------------------------------------------
+Int_t AliITSClusterFinderSSD::SortClustersP(Int_t start, Int_t end,
+                                           Int_t *array){
 //Sort P side clusters
-
-
-  Int_t right;
-  Int_t left;
-  if (start != (end - 1) ) {
-      left=this->SortClustersP(start,(start+end)/2,array);
-      right=this->SortClustersP((start+end)/2,end,array);  
-      return (left || right);
-  } else {
-      left =((AliITSclusterSSD*)((*fClusterP)[array[start]]))->
-                                                         GetDigitStripNo(0);
-      right=((AliITSclusterSSD*)((*fClusterP)[array[ end ]]))->
-                                                         GetDigitStripNo(0);
-      if(left>right) {
-         Int_t tmp = array[start];
-        array[start]=array[end];
-        array[end]=tmp;
-        return 1;
-      } else return 0;
-  }
-
+    Int_t right;
+    Int_t left;
+
+    if (start != (end - 1) ) {
+       left=this->SortClustersP(start,(start+end)/2,array);
+       right=this->SortClustersP((start+end)/2,end,array);  
+       return (left || right);
+    } else {
+       left =((AliITSclusterSSD*)((*fClusterP)[array[start]]))->
+           GetDigitStripNo(0);
+       right=((AliITSclusterSSD*)((*fClusterP)[array[ end ]]))->
+           GetDigitStripNo(0);
+       if(left>right) {
+           Int_t tmp = array[start];
+           array[start]=array[end];
+           array[end]=tmp;
+           return 1;
+       } else return 0;
+    } // end for start
 }
-
-
-
 //-------------------------------------------------------
-Int_t AliITSClusterFinderSSD::SortClustersN(Int_t start, Int_t end, Int_t *array)
-{
+Int_t AliITSClusterFinderSSD::SortClustersN(Int_t start, Int_t end,
+                                           Int_t *array){
 //Sort N side clusters
-
-
-  Int_t right;
-  Int_t left;
-  
-  if (start != (end - 1) ) {
-      left=this->SortClustersN(start,(start+end)/2,array);
-      right=this->SortClustersN((start+end)/2,end,array);  
-      return (left || right);
-  } else {
-      left =((AliITSclusterSSD*)((*fClusterN)[array[start]]))->
-                                                         GetDigitStripNo(0);
-      right=((AliITSclusterSSD*)((*fClusterN)[array[ end ]]))->
-                                                         GetDigitStripNo(0);
-      if( left > right) {
-         Int_t tmp = array[start];
-         array[start]=array[end];
-         array[end]=tmp;
-         return 1;
-      } else return 0;
-    } 
-
+    Int_t right;
+    Int_t left;
+
+    if (start != (end - 1) ) {
+       left=this->SortClustersN(start,(start+end)/2,array);
+       right=this->SortClustersN((start+end)/2,end,array);  
+       return (left || right);
+    } else {
+       left =((AliITSclusterSSD*)((*fClusterN)[array[start]]))->
+           GetDigitStripNo(0);
+       right=((AliITSclusterSSD*)((*fClusterN)[array[ end ]]))->
+           GetDigitStripNo(0);
+       if( left > right) {
+           Int_t tmp = array[start];
+           array[start]=array[end];
+           array[end]=tmp;
+           return 1;
+       } else return 0;
+    } // end for start
 }
-    
-
-
-//-------------------------------------------------------
-void AliITSClusterFinderSSD::ClustersToPackages()
-{  
-// fill packages   
-    
+//----------------------------------------------------------------------
+void AliITSClusterFinderSSD::ClustersToPackages(){  
+// fill packages    
   Int_t *oneSclP = new Int_t[fNClusterP]; //I want to have sorted 1 S clusters
   Int_t *oneSclN = new Int_t[fNClusterN]; //I can not sort it in TClonesArray
                                           //so, I create table of indexes and 
@@ -604,7 +521,6 @@ void AliITSClusterFinderSSD::ClustersToPackages()
 //Sorts filled Arrays
   SortClusters(oneSclP,oneSclN);                   
 
-
   fNPackages=1;      
   new ((*fPackages)[0]) AliITSpackageSSD(fClusterP,fClusterN);
   //currentpkg = (AliITSpackageSSD*)((*fPackages)[0]);
@@ -615,15 +531,12 @@ void AliITSClusterFinderSSD::ClustersToPackages()
       currentP = GetPSideCluster(oneSclP[j1]);
       Double_t xP = currentP->GetPosition();
       //Int_t NxP = currentP->GetNumOfDigits();
-      //cout<<"ClusterToP:New NxP,xP ="<<NxP<<","<<xP<<endl;
       Float_t signalP = currentP->GetTotalSignal();
     for (j2=0;j2<fNClusterN;j2++) {  
       currentN = GetNSideCluster(oneSclN[j2]);
       Double_t xN = currentN->GetPosition();
       //Int_t NxN = currentN->GetNumOfDigits();
-      //cout<<"ClusterToP:New NxN,xN ="<<NxN<<","<<xN<<endl;
       Float_t signalN = currentN->GetTotalSignal();
-      //cout<<"ClusterToP: signalP,signalN ="<<signalP<<","<<signalN<<endl;
       CreateNewRecPoint(xP,1,xN,1,signalP,signalN,currentP, currentN, 0.75);
 
     }
@@ -651,20 +564,17 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
   const Float_t kRMSx = 20.0*kconv; 
   const Float_t kRMSz = 800.0*kconv; 
 
-  Int_t stripP, stripN;
   Int_t n=0;
   Int_t *tr;
   if (GetCrossing(P,N)) {
   
-     GetCrossingError(dP,dN);
+    //GetCrossingError(dP,dN);
      AliITSRawClusterSSD cnew;
      Int_t nstripsP=clusterP->GetNumOfDigits();
      Int_t nstripsN=clusterN->GetNumOfDigits();
-     //Float_t signalP=clusterP->GetTotalSignal();
-     //Float_t signalN=clusterN->GetTotalSignal();
-
      Float_t signal = 0;
      Float_t dedx = 0;
+
      if(SigP>SigN) {
        signal = SigP;
        dedx = SigP*kADCtoKeV;
@@ -672,10 +582,9 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
        signal = SigN;
        dedx = SigN*kADCtoKeV;
      }        
+
      Float_t signalCut = TMath::Abs((SigP-SigN)/signal);
 
-  //cnew.fSignalP=signalP;
-  //cnew.fSignalN=signalN;
      cnew.fSignalP=SigP;
      cnew.fSignalN=SigN;
      cnew.fMultiplicity=nstripsP;
@@ -688,13 +597,7 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
      // the cut of the signals difference in P and N sides to
      // remove the "ghosts"
 
-     fSegmentation->GetPadIxz(P,N,stripP,stripN);
-
-     //cout<<"NewRec: P,N microns,stripP,stripN ="<<P<<","<<N<<","<<stripP<<","<<stripN<<endl;
-
      tr = (Int_t*) clusterP->GetTracks(n);
-     //cout<<"!!!! ntr,tr0,tr1,tr2 ="<<n<<","<<tr[0]<<","<<tr[1]<<","<<tr[2]<<endl; 
-     //cout<<"NewRec:AddRecP: xL,zL cm ="<<P*kconv<<","<<N*kconv<<endl;
 
      AliITSRecPoint rnew;
      rnew.SetX(P*kconv);
@@ -703,8 +606,6 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
      rnew.SetdEdX(dedx);
      rnew.SetSigmaX2( kRMSx* kRMSx); 
      rnew.SetSigmaZ2( kRMSz* kRMSz);
-     //rnew.SetSigmaX2(1);   //This has to be verified
-     //rnew.SetSigmaZ2(1);   //This has to be verified
      rnew.fTracks[0]=tr[0];
      rnew.fTracks[1]=tr[1];
      rnew.fTracks[2]=tr[2];
@@ -796,31 +697,22 @@ Bool_t AliITSClusterFinderSSD::GetCrossing (Float_t &P, Float_t &N)
   Float_t z;  // z = zL + Dz/2
   Float_t xP; // x coordinate in the P side from the first P strip
   Float_t xN; // x coordinate in the N side from the first N strip
+  Float_t StereoP,StereoN;
+
+  fSegmentation->Angles(StereoP,StereoN);
+  fTanP=TMath::Tan(StereoP);
+  fTanN=TMath::Tan(StereoN);
   Float_t kP = fTanP; // Tangent of 0.0075 mrad
   Float_t kN = fTanN; // Tangent of 0.0275 mrad
 
-  //cout<<"1 GetCros: strP,srtN,fPitch,Dx ="<<P<<","<<N<<","<<fPitch<<","<<fSegmentation->Dx()<<endl;
-
-
     P *= fPitch;
     N *= fPitch; 
     xP = N;      // change the mistake for the P/N
     xN = P;      // coordinates correspondence in this function
-    //cout<<"2 GetCross: xP,xN,fTanP,fTanN ="<<xP<<","<<xN<<","<<fTanP<<","<<fTanN<<endl;     
-
-    /*
-    Float_t x = xP + 0.21428*(1100-xP+xN);
-    Float_t z = 31428.571 - (xP-xN)/0.035;    
-    */
-
     x = xP + kP*(Dz*kN-xP+xN)/(kP+kN);
     z = (Dz*kN-xP+xN)/(kP+kN); 
     xL = x - Dx/2;
     zL = z - Dz/2;
-
-    //cout<<"3 GetCross: x,z,xL,zL ="<<x<<","<<z<<","<<xL<<","<<zL<<endl;     
-
     P = xL;
     N = zL;  
 
index 85b877d178bba7db5b87591c535fac7632a34423..0e69d197bf5840504b02c00b39d88c3f7aeb5555 100644 (file)
@@ -20,7 +20,7 @@ public:
   virtual ~AliITSClusterFinderSSD();
 
 
-  void FindRawClusters();    
+  void FindRawClusters(Int_t mod);
 
   /*
   void SetAlpha1(Float_t a) {fAlpha1 =a;}
index 716c06a11f351bf1fbeceff4456d02573b12a9d0..38347a5c1c6ef3fd153d2487707ffecf127b3562 100644 (file)
@@ -14,6 +14,9 @@
  **************************************************************************/
 /*
 $Log$
+Revision 1.9  2001/04/27 14:16:50  nilsen
+Remove dead and/or unused code and printout lines. i.e. cleaned it up a bit.
+
 */
 
 #include <TMath.h>
@@ -25,37 +28,42 @@ $Log$
 ClassImp(AliITSsegmentationSSD)
 AliITSsegmentationSSD::AliITSsegmentationSSD(){
     // default constructor
-    fGeom=0;
-    fCorr=0;
+    fGeom  = 0;
+    fCorr  = 0;
+    fLayer = 0;
 }
 //----------------------------------------------------------------------
 AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSgeom *geom){
     // constuctor
-    fGeom=geom;
-    fCorr=0;
+    fGeom = geom;
+    fCorr = 0;
     SetDetSize();
     SetPadSize();
     SetNPads();
-    Init();
-
+    SetAngles();
+    fLayer = 0;
 }
 //______________________________________________________________________
 AliITSsegmentationSSD& AliITSsegmentationSSD::operator=(
-                                      AliITSsegmentationSSD &source){
-    // Operator =
+                                             AliITSsegmentationSSD &source){
+// Operator =
     if(this==&source) return *this;
     this->fNstrips = source.fNstrips;
     this->fStereoP = source.fStereoP;
     this->fStereoN = source.fStereoN;
+    this->fStereoPl5 = source.fStereoPl5;
+    this->fStereoNl5 = source.fStereoNl5;
+    this->fStereoPl6 = source.fStereoPl6;
+    this->fStereoNl6 = source.fStereoNl6;
+    this->fLayer   = source.fLayer;
     this->fPitch   = source.fPitch;
     this->fDz      = source.fDz;
     this->fDx      = source.fDx;
     this->fDy      = source.fDy;
+    this->fLayer   = source.fLayer;
     this->fGeom    = source.fGeom; // copy only the pointer
-    // make a proper copy
-    if(source.fCorr!=0) this->fCorr = new TF1(*(source.fCorr));
-    else this->fCorr    = 0;
-    return *this;
+    this->fCorr    = new TF1(*(source.fCorr)); // make a proper copy
+    return *this;     
 }
 //______________________________________________________________________
 AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSsegmentationSSD &source){
@@ -71,6 +79,24 @@ void AliITSsegmentationSSD::Init(){
     SetAngles();
 }
 //----------------------------------------------------------------------
+void AliITSsegmentationSSD::Angles(Float_t &aP,Float_t &aN){
+
+    if (fLayer == 5){
+       aP = fStereoPl5;
+       aN = fStereoNl5;
+    } // end if
+    if (fLayer == 6){
+       aP = fStereoPl6;
+       aN = fStereoNl6;
+    } // end if
+}
+//----------------------------------------------------------------------
+void AliITSsegmentationSSD::SetLayer(Int_t l){
+
+    if (l==5) fLayer =5;
+    if (l==6) fLayer =6;
+}
+//----------------------------------------------------------------------
 void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z){
     // returns P and N sided strip numbers for a given location.
     // Transformation from microns detector center local coordinates
@@ -106,7 +132,7 @@ void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z){
 }
 //----------------------------------------------------------------------
 void AliITSsegmentationSSD::GetPadIxz(Float_t x,Float_t z,Int_t &iP,Int_t &iN){
-    // returns P and N sided strip numbers for a given location.
+  // returns P and N sided strip numbers for a given location.
     /*                       _-  Z
                     + angle /    ^
         fNstrips           v     |   N-Side        ...0
@@ -129,37 +155,47 @@ void AliITSsegmentationSSD::GetPadIxz(Float_t x,Float_t z,Int_t &iP,Int_t &iN){
     // expects x, z in microns
   */ 
 
-    this->GetPadTxz(x,z);  // use existing routine.
-    iP = (Int_t) x;
+    Float_t StereoP, StereoN;
+    Angles(StereoP,StereoN);
+    Float_t tanP=TMath::Tan(StereoP);
+    Float_t tanN=TMath::Tan(StereoN);
+    Float_t x1=x,z1=z;
+    x1 += fDx/2;
+    z1 += fDz/2;
+    Float_t  ldX = x1 - z1*tanP;          // distance from left-down edge 
+    iP = (Int_t)(ldX/fPitch);
     iP = (iP<0)? -1: iP;      
     iP = (iP>fNstrips)? -1: iP;
-    iN = (Int_t) z;
+
+    ldX = x1 - tanN*(fDz - z1);
+    iN = (Int_t)(ldX/fPitch);
     iN = (iN<0)? -1: iN;
     iN = (iN>fNstrips)? -1: iN;
+
 }
-//----------------------------------------------------------------------
+//-------------------------------------------------------
 void AliITSsegmentationSSD::GetPadCxz(Int_t iP,Int_t iN,Float_t &x,Float_t &z){
     // actually this is the GetCrossing(Float_t &,Float_t &)
-    // returns x, z  in microns !
-
-    Float_t flag=2*fDx;
-    Float_t tanP=TMath::Tan(fStereoP);
-    Float_t tanN=TMath::Tan(fStereoN);
-    Float_t dx = 0.1;
-
-    x = iP*fPitch;
-    z = iN*fPitch; 
-
-    if(tanP + tanN  == 0) {x=z=flag; return ;}
-
-    z = (z - x + tanN * fDz) / (tanP + tanN);    
-    x = x + tanP * z;                         
+    // returns local x, z  in microns !
 
-    x -= fDx/2;
-    z -= fDz/2;
+    Float_t Dx = fDx; // detector size in x direction, microns
+    Float_t Dz = fDz; // detector size in z direction, microns
+    Float_t xP; // x coordinate in the P side from the first P strip
+    Float_t xN; // x coordinate in the N side from the first N strip
+    Float_t StereoP, StereoN;
+    Angles(StereoP,StereoN);
+    Float_t kP=TMath::Tan(StereoP);
+    Float_t kN=TMath::Tan(StereoN);
 
-    if ( ( z < -(fDz/2+dx) ) || ( z > (fDz/2+dx) ) ) {x=z=flag; return ;}
-    if ( ( x < -(fDx/2+dx) ) || ( x > (fDx/2+dx) ) ) {x=z=flag; return ;}
+    xP=iP*fPitch;
+    xN=iN*fPitch; 
+    x = xP + kP*(Dz*kN-xP+xN)/(kP+kN);
+    z = (Dz*kN-xP+xN)/(kP+kN); 
+    x -= Dx/2;
+    z -= Dz/2;
+    if(TMath::Abs(z) > Dz/2) cout<<"Warning, wrong z local ="<<z<<endl; 
+    // Check that zL is inside the detector for the 
+    // correspondent xP and xN coordinates
 
     return;   
 }
index d4137c8edf72f4535b65f47bc898843c27aadc85..912682b7723e13980aeb9bea8cdb47702aa0b5f9 100644 (file)
@@ -17,8 +17,8 @@ public AliITSsegmentation {
 
 
     // Detector size: x,z,y 
-    virtual void   SetDetSize(Float_t p1=72960.,Float_t p2=40000.,
-                             Float_t p3= 300.) 
+    virtual void    SetDetSize(Float_t p1=72960.,Float_t p2=40000.,
+                              Float_t p3= 300.) 
                         {fDx=p1; fDz=p2; fDy=p3;}
 
     // Strip size  
@@ -34,7 +34,14 @@ public AliITSsegmentation {
 
     // Set stereo angles Pside-Nside 
     virtual void    SetAngles(Float_t pa=0.0175, Float_t na=0.0175) 
-                         {fStereoP=pa; fStereoN=na;}
+                         {fStereoPl5=pa; fStereoNl5=na;
+                        fStereoPl6=na; fStereoNl6=pa;}
+
+    virtual void    SetAnglesLay5(Float_t pa=0.0075, Float_t na=0.0275) 
+                         {fStereoPl5=pa; fStereoNl5=na;}
+
+    virtual void    SetAnglesLay6(Float_t pa=0.0275, Float_t na=0.0075) 
+                         {fStereoPl6=pa; fStereoNl6=na;}
 
     // Set stereo angles Pside-Nside 
     // Transform from real coordinates to strips
@@ -59,7 +66,7 @@ public AliITSsegmentation {
     // their correxlation matrix c[2][2].
     virtual Bool_t  GetCrossing(Int_t iP,Int_t iN,Float_t &x,Float_t &z,
                                Float_t c[2][2]);
-    //
+
     virtual void Init();
 
     // Detector type geometry
@@ -79,15 +86,26 @@ public AliITSsegmentation {
     // Maximum number of Strips in z
     virtual Int_t    Npz(){return 1;}
 
+    // Angles : Pside stereo angle-Nside stereo angle
+     virtual void Angles(Float_t &aP,Float_t &aN);
+     virtual void SetLayer(Int_t l);
+     virtual Int_t GetLayer() const {return fLayer;}
+
   protected:
 
   Int_t      fNstrips;       // Number of strips in x 
   Float_t    fStereoP;       // Stereo angle for Pside (rad)
   Float_t    fStereoN;       // Stereo angle for Nside (rad)
-  Float_t    fPitch;         // Pitch of the strips (microns)
+  Float_t    fPitch;         // Pitch of the strips
   Float_t    fDz;            // Full width of the detector (z axis)- microns
   Float_t    fDx;            // Full length of the detector (x axis)- microns
-  Float_t    fDy;            // Full thickness of the detector (y axis) -um
+  Float_t    fDy;            // Full thickness of the detector (y axis) -um 
+  
+  Float_t    fStereoPl5;       // Stereo angle for Pside
+  Float_t    fStereoNl5;       // Stereo angle for Nside
+  Float_t    fStereoPl6;       // Stereo angle for Pside
+  Float_t    fStereoNl6;       // Stereo angle for Nside
+  Int_t      fLayer;
 
   AliITSgeom *fGeom;         //! pointer to the geometry class
   TF1*       fCorr;          // correction function
index 918174859074097e38daf0604ce52de2959e819f..074a18e44aa95c03dc4498b31b955f3a241eda57 100644 (file)
@@ -14,7 +14,7 @@
 #include "AliITSdcsSSD.h"
 #include "AliITS.h"
 #include "AliRun.h"
-
+#include "AliITSgeom.h"
 
 ClassImp(AliITSsimulationSSD);
 ////////////////////////////////////////////////////////////////////////
@@ -24,570 +24,503 @@ ClassImp(AliITSsimulationSSD);
 //
 // AliITSsimulationSSD is the simulation of SSDs.
 
-//------------------------------------------------------------
+//----------------------------------------------------------------------
 AliITSsimulationSSD::AliITSsimulationSSD(AliITSsegmentation *seg,
                                          AliITSresponse *resp){
-  // Constructor
+    // Constructor
 
     fSegmentation = seg;
     fResponse = resp;
-  Float_t noise[2] = {0.,0.};
-  fResponse->GetNoiseParam(noise[0],noise[1]);   // retrieves noise parameters
-  cout<<"nois1,2 ="<<noise[0]<<","<<noise[1]<<endl;    
-  fDCS = new AliITSdcsSSD(seg,resp); 
+    Float_t noise[2] = {0.,0.};
+    fResponse->GetNoiseParam(noise[0],noise[1]); // retrieves noise parameters
+    fDCS = new AliITSdcsSSD(seg,resp); 
 
     fNstrips = fSegmentation->Npx();
     fPitch = fSegmentation->Dpx(0);
-    cout<<" Dx,Dz ="<<fSegmentation->Dx()<<","<<fSegmentation->Dz()<<endl;
-    cout<<"fNstrips="<<fNstrips<<" fPitch="<<fPitch<<endl;
-
-    //fP = new TArrayF(fNstrips+1); 
-    //fN = new TArrayF(fNstrips+1);
-
     fMapA2 = new AliITSMapA2(fSegmentation);
      
-    //fTracksP = new AliITSdictSSD[fNstrips+1];
-    //fTracksN = new AliITSdictSSD[fNstrips+1];
-    
     fSteps  = 100;   // still hard-wired - set in SetDetParam and get it via  
                      // fDCS together with the others eventually    
 }
-
-//___________________________________________________________________________
+//______________________________________________________________________
 AliITSsimulationSSD& AliITSsimulationSSD::operator=(AliITSsimulationSSD 
                                                                       &source){
-// Operator =
+    // Operator =
 
     if(this==&source) return *this;
 
-    this->fDCS = new AliITSdcsSSD(*(source.fDCS));
-    //this->fN   = new TArrayF(*(source.fN));
-    //this->fP   = new TArrayF(*(source.fP));
-    this->fMapA2 = source.fMapA2;
-    //this->fTracksP = new AliITSdictSSD(*(source.fTracksP));
-    //this->fTracksN = new AliITSdictSSD(*(source.fTracksN));
+    this->fDCS     = new AliITSdcsSSD(*(source.fDCS));
+    this->fMapA2   = source.fMapA2;
     this->fNstrips = source.fNstrips;
     this->fPitch   = source.fPitch;
     this->fSteps   = source.fSteps;
     return *this;
 }
-//_____________________________________________________________
+//_____________________________________________________________---------
 AliITSsimulationSSD::AliITSsimulationSSD(AliITSsimulationSSD &source){
-  // copy constructor
+    // copy constructor
 
-   *this = source;
+    *this = source;
 }
-//____________________________________________________________________________
+//______________________________________________________________________
 AliITSsimulationSSD::~AliITSsimulationSSD() {
-  // destructor    
-  //if(fP) delete fP;
-  //if(fN) delete fN;
+    // destructor
     delete fMapA2;
-    //if(fTracksP) delete [] fTracksP;
-    //if(fTracksN) delete [] fTracksN;
     delete fDCS;
-} 
-
-//_______________________________________________________________
+}
+//_______________________________________________________________-------
 void AliITSsimulationSSD::DigitiseModule(AliITSmodule *mod,Int_t module,
                                          Int_t dummy) {
-  // Digitizes hits for one SSD module 
-
-  TObjArray *hits = mod->GetHits();
-  Int_t nhits = hits->GetEntriesFast();
-  if (!nhits) return;
-  //cout<<"!! module, nhits ="<<module<<","<<nhits<<endl; //b.b.
+    // Digitizes hits for one SSD module 
+
+    Int_t lay, lad, detect;
+    AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
+    AliITSgeom *geom = aliITS->GetITSgeom();
+    geom->GetModuleId(module,lay, lad, detect);
+    if ( lay == 6 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(6);
+    if ( lay == 5 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(5);
+
+    TObjArray *hits = mod->GetHits();
+    Int_t nhits = hits->GetEntriesFast();
+    if (!nhits) return;
+    //cout<<"!! module, nhits ="<<module<<","<<nhits<<endl; 
   
-  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);
-  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 maxNdigits = 2*fNstrips; 
+    Float_t  **pList = new Float_t* [maxNdigits]; 
+    memset(pList,0,sizeof(Float_t*)*maxNdigits);
+    Int_t indexRange[4] = {0,0,0,0};
+    static Bool_t first=kTRUE;
+    Int_t lasttrack = -2;
+    Int_t idtrack = -2;
     
-  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
-    // Returns also energy loss
-    if (mod->LineSegmentL(i, x0, x1, y0, y1, z0, z1, de, idtrack)) {
-      //cout<<"!! befor HitToDigit: hit ="<<i<<endl; //b.b.
-      HitToDigit(module, x0, y0, z0, x1, y1, z1, de, indexRange, first);
+    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
+       // Returns also energy loss
+
+       if (mod->LineSegmentL(i, x0, x1, y0, y1, z0, z1, de, idtrack)) {
+           HitToDigit(module, x0, y0, z0, x1, y1, z1, de, indexRange, first);
        
-      if (lasttrack != idtrack || i==(nhits-1)) {
-       GetList(idtrack,pList,indexRange);
-       first=kTRUE;
-      }
-      lasttrack=idtrack;
-    }
-  }  // end loop over hits
+           if (lasttrack != idtrack || i==(nhits-1)) {
+               GetList(idtrack,pList,indexRange);
+               first=kTRUE;
+           } // end if
+           lasttrack=idtrack;
+       } // end if
+    }  // end loop over hits
   
-  ApplyNoise();
-  ApplyCoupling();
+    ApplyNoise();
+    ApplyCoupling();
 
-  ChargeToSignal(pList);
+    ChargeToSignal(pList);
 
-  fMapA2->ClearMap();
+    fMapA2->ClearMap();
 }
-
-//---------------------------------------------------------------
+//----------------------------------------------------------------------
 void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0, 
                                     Double_t z0, Double_t x1, Double_t y1, 
                                     Double_t z1, Double_t de,
                                     Int_t *indexRange, Bool_t first) {
-  // Turns hits in SSD module into one or more digits.
-
-  AliITSsegmentationSSD *seg = new AliITSsegmentationSSD();
-  // AliITSresponseSSD *res = new AliITSresponseSSD();
-
-  Float_t tang[2] = {0.0,0.0};
-  seg->Angles(tang[0], tang[1]); // stereo<<  -> tan(stereo)~=stereo
-  //fSegmentation->Angles(tang[0], tang[1]); // stereo<<  -> tan(stereo)~=stereo
-  Double_t x, y, z;
-  Double_t dex=0.0, dey=0.0, dez=0.0;
-  Double_t pairs;
-  Double_t  ionE = 3.62E-9;   // ionization energy of Si (GeV)
-  //ionE = (Double_t)  res->GetIonE();     
+    // Turns hits in SSD module into one or more digits.
+
+    Float_t tang[2] = {0.0,0.0};
+    fSegmentation->Angles(tang[0], tang[1]);// stereo<<  -> tan(stereo)~=stereo
+    Double_t x, y, z;
+    Double_t dex=0.0, dey=0.0, dez=0.0;
+    Double_t pairs;
+    Double_t ionE = 3.62E-9;   // ionization energy of Si (GeV)
     
-  Double_t sigma[2] = {0.,0.};  // standard deviation of the diffusion gaussian
-
-  Double_t D[2] = {11.,30.};                // diffusion constant {h,e} (cm**2/sec)
-  //D[0] = (Double_t) res->GetDiffusionConstantP();
-  //D[1] = (Double_t) res->GetDiffusionConstantN();
-
-  Double_t tdrift[2] = {0.,0.}; // time of drift
-  Double_t vdrift[2] = {0.86E6,2.28E6};          // drift velocity (cm/sec)   
-  //vdrift[0] = (Double_t) res->GetDriftVelocityP();
-  //vdrift[1] = (Double_t) res->GetDriftVelocityN();
-
-  Double_t w;
-  Double_t inf[2], sup[2], par0[2];                 
-  // Steps in the module are determined "manually" (i.e. No Geant)
-  // NumOfSteps divide path between entering and exiting hits in steps 
-  Int_t numOfSteps = NumOfSteps(x1, y1, z1, dex, dey, dez);
+    Double_t sigma[2] = {0.,0.};// standard deviation of the diffusion gaussian
+
+    Double_t D[2] = {11.,30.}; // diffusion constant {h,e} (cm**2/sec)
+    Double_t tdrift[2] = {0.,0.}; // time of drift
+    Double_t vdrift[2] = {0.86E6,2.28E6};  // drift velocity (cm/sec)   
+    Double_t w;
+    Double_t inf[2], sup[2], par0[2];                 
+    // Steps in the module are determined "manually" (i.e. No Geant)
+    // NumOfSteps divide path between entering and exiting hits in steps 
+    Int_t numOfSteps = NumOfSteps(x1, y1, z1, dex, dey, dez);
   
-  // Enery loss is equally distributed among steps
-  de = de/numOfSteps;
-  pairs = de/ionE;             // e-h pairs generated
-
-  //cout<<"Dy ="<<seg->Dy()<<endl;
-  //cout<<"numOfSteps ="<<numOfSteps<<endl;
-  //cout<<"dex,dey,dez ="<<dex<<","<<dey<<","<<dez<<endl;
-  //cout<<"y0,y1 ="<<y0<<","<<y1<<endl;
-  for(Int_t j=0; j<numOfSteps; j++) {     // stepping
-    //    cout<<"step number ="<<j<<endl;
-    x = x0 + (j+0.5)*dex;
-    y = y0 + (j+0.5)*dey;
-    if ( y > (seg->Dy()/2 +10)*1.0E-4 ) {
-      //if ( y > (seg->Dy()*1.0E-4/2) ) {
-      //if ( y > (fSegmentation->Dy()*1.0E-4/2) ) {
-      // check if particle is within the detector
-      cout<<"AliITSsimulationSSD::HitToDigit: Warning: hit out of detector y0,y,dey,j ="<<y0<<","<<y<<","<<dey<<","<<j<<endl;
-      return;
-    };
-    z = z0 + (j+0.5)*dez;
-
-    // calculate drift time
-    tdrift[0] = (y+(seg->Dy()*1.0E-4)/2) / vdrift[0]; // y is the minimum path
-    tdrift[1] = ((seg->Dy()*1.0E-4)/2-y) / vdrift[1]; // y is the minimum path
-    //tdrift[0] = (y+(fSegmentation->Dy()*1.0E-4)/2) / vdrift[0]; // y is the minimum path
-    //tdrift[1] = ((fSegmentation->Dy()*1.0E-4)/2-y) / vdrift[1]; // y is the minimum path
-
-    for(Int_t k=0; k<2; k++) {   // both sides    remember: 0=Pside 1=Nside
-
-      tang[k]=TMath::Tan(tang[k]);
-
-      // w is the coord. perpendicular to the strips
-      if(k==0) {
-       w = (x+(seg->Dx()*1.0E-4)/2) - (z+(seg->Dz()*1.0E-4)/2)*tang[k]; 
-       //w = (x+(fSegmentation->Dx()*1.0E-4)/2) - (z+(fSegmentation->Dz()*1.0E-4)/2)*tang[k]; 
-       //cout<<"k,x,z,w ="<<k<<","<<x<<","<<z<<","<<w<<endl;
-      }
-      else {
-       w = (x+(seg->Dx()*1.0E-4)/2) + (z-(seg->Dz()*1.0E-4)/2)*tang[k]; 
-       //w = (x+(fSegmentation->Dx()*1.0E-4)/2) + (z-(fSegmentation->Dz()*1.0E-4)/2)*tang[k]; 
-       //cout<<"k,x,z,w ="<<k<<","<<x<<","<<z<<","<<w<<endl;
-      }
-      w = w / (fPitch*1.0E-4); // w is converted in units of pitch
-
-      if((w<(-0.5)) || (w>(fNstrips-0.5))) {
-       // this check rejects hits in regions not covered by strips
-       // 0.5 takes into account boundaries 
-       if(k==0) cout<<"AliITSsimulationSSD::HitToDigit: Warning: no strip in this region of P side"<<endl;
-       else cout<<"AliITSsimulationSSD::HitToDigit: Warning: no strip in this region of N side"<<endl;
-       return;
-      }
-
-      // sigma is the standard deviation of the diffusion gaussian
-
-      if(tdrift[k]<0) return;
-
-      sigma[k] = TMath::Sqrt(2*D[k]*tdrift[k]);
-      sigma[k] = sigma[k] /(fPitch*1.0E-4);  //units of Pitch
-      if(sigma[k]==0.0) {      
-       cout<<"AliITSsimulationSSD::DigitiseModule: Error: sigma=0"<<endl; 
-       exit(0);
-      }
-
-      par0[k] = pairs;
-      // we integrate the diffusion gaussian from -3sigma to 3sigma 
-      inf[k] = w - 3*sigma[k];      // 3 sigma from the gaussian average  
-      sup[k] = w + 3*sigma[k];      // 3 sigma from the gaussian average
-      // IntegrateGaussian does the actual integration of diffusion gaussian
-      IntegrateGaussian(k, par0[k], w, sigma[k], inf[k], sup[k], 
-                       indexRange, first);
-    }  // end for loop over side (0=Pside, 1=Nside)      
-  } // end stepping
-  delete seg;
+    // Enery loss is equally distributed among steps
+    de = de/numOfSteps;
+    pairs = de/ionE;             // e-h pairs generated
+
+    for(Int_t j=0; j<numOfSteps; j++) {     // stepping
+       //    cout<<"step number ="<<j<<endl;
+       x = x0 + (j+0.5)*dex;
+       y = y0 + (j+0.5)*dey;
+       //if ( y > (seg->Dy()/2 +10)*1.0E-4 ) {
+       if ( y > (fSegmentation->Dy()/2+10)*1.0E-4 ) {
+           // check if particle is within the detector
+           cout<<"AliITSsimulationSSD::HitToDigit: Warning: hit "
+               "out of detector y0,y,dey,j ="
+               <<y0<<","<<y<<","<<dey<<","<<j<<endl;
+           return;
+       } // end if
+       z = z0 + (j+0.5)*dez;
+
+       // calculate drift time
+       // y is the minimum path
+       tdrift[0] = (y+(fSegmentation->Dy()*1.0E-4)/2) / vdrift[0];
+       tdrift[1] = ((fSegmentation->Dy()*1.0E-4)/2-y) / vdrift[1];
+
+       for(Int_t k=0; k<2; k++) {   // both sides    remember: 0=Pside 1=Nside
+
+           tang[k]=TMath::Tan(tang[k]);
+
+           // w is the coord. perpendicular to the strips
+           if(k==0) {
+               //w=(x+(seg->Dx()*1.0E-4)/2)-(z+(seg->Dz()*1.0E-4)/2)*tang[k]; 
+               w = (x+(fSegmentation->Dx()*1.0E-4)/2) -
+                   (z+(fSegmentation->Dz()*1.0E-4)/2)*tang[k]; 
+           }else{
+               //w =(x+(seg->Dx()*1.0E-4)/2)+(z-(seg->Dz()*1.0E-4)/2)*tang[k];
+               w = (x+(fSegmentation->Dx()*1.0E-4)/2) + 
+                   (z-(fSegmentation->Dz()*1.0E-4)/2)*tang[k]; 
+               //cout<<"k,x,z,w ="<<k<<","<<x<<","<<z<<","<<w<<endl;
+           } // end if
+           w = w / (fPitch*1.0E-4); // w is converted in units of pitch
+
+           if((w<(-0.5)) || (w>(fNstrips-0.5))) {
+               // this check rejects hits in regions not covered by strips
+               // 0.5 takes into account boundaries 
+               if(k==0) cout<<"AliITSsimulationSSD::HitToDigit: "
+                            "Warning: no strip in this region of P side"
+                            <<endl;
+               else cout<<"AliITSsimulationSSD::HitToDigit: "
+                        "Warning: no strip in this region of N side"<<endl;
+               return;
+           } // end if
+
+           // sigma is the standard deviation of the diffusion gaussian
+
+           if(tdrift[k]<0) return;
+
+           sigma[k] = TMath::Sqrt(2*D[k]*tdrift[k]);
+           sigma[k] = sigma[k] /(fPitch*1.0E-4);  //units of Pitch
+           if(sigma[k]==0.0) {         
+               cout<<"AliITSsimulationSSD::DigitiseModule: Error: sigma=0"
+                   <<endl; 
+               exit(0);
+           } // end if
+
+           par0[k] = pairs;
+           // we integrate the diffusion gaussian from -3sigma to 3sigma 
+           inf[k] = w - 3*sigma[k]; // 3 sigma from the gaussian average  
+           sup[k] = w + 3*sigma[k]; // 3 sigma from the gaussian average
+                                    // IntegrateGaussian does the actual
+                                     // integration of diffusion gaussian
+           IntegrateGaussian(k, par0[k], w, sigma[k], inf[k], sup[k], 
+                             indexRange, first);
+       }  // end for loop over side (0=Pside, 1=Nside)      
+    } // end stepping
+    //delete seg;
 }
-
-//____________________________________________________________________
-
+//____________________________________________________________________--
 void AliITSsimulationSSD::ApplyNoise() {
-  // Apply Noise.
+    // Apply Noise.
   
-  Float_t signal;
-  Float_t noise[2] = {0.,0.};
-  fResponse->GetNoiseParam(noise[0],noise[1]);   // retrieves noise parameters
+    Float_t signal;
+    Float_t noise[2] = {0.,0.};
+    fResponse->GetNoiseParam(noise[0],noise[1]); // retrieves noise parameters
 
-  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 = (Float_t) fMapA2->GetSignal(k,ix);// retrieves signal from map
+    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 = (Float_t) fMapA2->GetSignal(k,ix);// retrieves signal
+                                                       // from map
 
-      signal += gRandom->Gaus(0,noise[k]);       // add noise to signal
-      if(signal<0.) signal=0.0;                  // in case noise is negative...
+           signal += gRandom->Gaus(0,noise[k]);// add noise to signal
+           if(signal<0.) signal=0.0;           // in case noise is negative...
 
-      fMapA2->SetHit(k,ix,(Double_t)signal);     // give back signal to map
-    } // loop over strip 
-  } // loop over k (P or N side)
+           fMapA2->SetHit(k,ix,(Double_t)signal); // give back signal to map
+       } // loop over strip 
+    } // loop over k (P or N side)
 }
-
-//_________________________________________________________________________
-
+//______________________________________________________________________
 void AliITSsimulationSSD::ApplyCoupling() {
-  // Apply the effect of electronic coupling between channels    
-  Float_t signal, signalLeft=0, signalRight=0;
-
-  for(Int_t ix=0;ix<fNstrips;ix++){
-    if(ix>0.) signalLeft  = (Float_t) fMapA2->GetSignal(0,ix-1)*fDCS->GetCouplingPL();
-    else signalLeft = 0.0;
-    if(ix<(fNstrips-1)) signalRight = (Float_t) fMapA2->GetSignal(0,ix+1)*fDCS->GetCouplingPR();
-    else signalRight = 0.0;
-    signal = (Float_t) fMapA2->GetSignal(0,ix);
-    signal += signalLeft + signalRight;
-    fMapA2->SetHit(0,ix,(Double_t)signal);
+    // Apply the effect of electronic coupling between channels
+    Float_t signal, signalLeft=0, signalRight=0;
+
+    for(Int_t ix=0;ix<fNstrips;ix++){
+       if(ix>0.) signalLeft  = (Float_t) fMapA2->GetSignal(0,ix-1)*
+                                                       fDCS->GetCouplingPL();
+       else signalLeft = 0.0;
+       if(ix<(fNstrips-1)) signalRight = (Float_t) fMapA2->GetSignal(0,ix+1)*
+                                                        fDCS->GetCouplingPR();
+       else signalRight = 0.0;
+       signal = (Float_t) fMapA2->GetSignal(0,ix);
+       signal += signalLeft + signalRight;
+       fMapA2->SetHit(0,ix,(Double_t)signal);
     
-    if(ix>0.) signalLeft  = (Float_t) fMapA2->GetSignal(1,ix-1)*fDCS->GetCouplingNL();
-    else signalLeft = 0.0;
-    if(ix<(fNstrips-1)) signalRight = (Float_t) fMapA2->GetSignal(1,ix+1)*fDCS->GetCouplingNR();
-    else signalRight = 0.0;
-    signal = (Float_t) fMapA2->GetSignal(1,ix);
-    signal += signalLeft + signalRight;
-    fMapA2->SetHit(1,ix,(Double_t)signal);
-  } // loop over strips 
+       if(ix>0.) signalLeft  = (Float_t) fMapA2->GetSignal(1,ix-1)*
+                                                        fDCS->GetCouplingNL();
+       else signalLeft = 0.0;
+       if(ix<(fNstrips-1)) signalRight = (Float_t) fMapA2->GetSignal(1,ix+1)*
+                                                         fDCS->GetCouplingNR();
+       else signalRight = 0.0;
+       signal = (Float_t) fMapA2->GetSignal(1,ix);
+       signal += signalLeft + signalRight;
+       fMapA2->SetHit(1,ix,(Double_t)signal);
+    } // loop over strips 
 }
-
-//____________________________________________________________________________
+//______________________________________________________________________
 Float_t AliITSsimulationSSD::F(Float_t av, Float_t x, Float_t s) {
-  // Computes the integral of a gaussian using Error Function
-  Float_t sqrt2 = TMath::Sqrt(2.0);
-  Float_t sigm2 = sqrt2*s;
-  Float_t integral;
+    // Computes the integral of a gaussian using Error Function
+    Float_t sqrt2 = TMath::Sqrt(2.0);
+    Float_t sigm2 = sqrt2*s;
+    Float_t integral;
 
-  integral = 0.5 * TMath::Erf( (x - av) / sigm2);
-  return integral;
-} 
-
-//_________________________________________________________________________
+    integral = 0.5 * TMath::Erf( (x - av) / sigm2);
+    return integral;
+}
+//______________________________________________________________________
 void AliITSsimulationSSD::IntegrateGaussian(Int_t k,Double_t par, Double_t w,
                                            Double_t sigma, 
                                            Double_t inf, Double_t sup,
                                            Int_t *indexRange, Bool_t first) {
-  // integrate the diffusion gaussian
-  // remind: inf and sup are w-3sigma and w+3sigma
-  //         we could define them here instead of passing them
-  //         this way we are free to introduce asimmetry
-
-  Double_t a=0.0, b=0.0;
-  Double_t signal = 0.0, dXCharge1 = 0.0, dXCharge2 = 0.0;
-  // dXCharge1 and 2 are the charge to two neighbouring strips
-  // Watch that we only involve at least two strips
-  // Numbers greater than 2 of strips in a cluster depend on
-  //  geometry of the track and delta rays, not charge diffusion!   
+    // integrate the diffusion gaussian
+    // remind: inf and sup are w-3sigma and w+3sigma
+    //         we could define them here instead of passing them
+    //         this way we are free to introduce asimmetry
+
+    Double_t a=0.0, b=0.0;
+    Double_t signal = 0.0, dXCharge1 = 0.0, dXCharge2 = 0.0;
+    // dXCharge1 and 2 are the charge to two neighbouring strips
+    // Watch that we only involve at least two strips
+    // Numbers greater than 2 of strips in a cluster depend on
+    //  geometry of the track and delta rays, not charge diffusion!   
   
-  Double_t strip = TMath::Floor(w);         // clostest strip on the left
-
-  if ( TMath::Abs((strip - w)) < 0.5) { 
-    // gaussian mean is closer to strip on the left
-    a = inf;                         // integration starting point
-    if((strip+0.5)<=sup) {
-      // this means that the tail of the gaussian goes beyond
-      // the middle point between strips ---> part of the signal
-      // is given to the strip on the right
-      b = strip + 0.5;               // integration stopping point
-      dXCharge1 = F( w, b, sigma) - F(w, a, sigma);    
-      dXCharge2 = F( w, sup, sigma) - F(w ,b, sigma); 
-    }
-    else { 
-      // this means that all the charge is given to the strip on the left
-      b = sup;
-      dXCharge1 = 0.9973;   // gaussian integral at 3 sigmas
-      dXCharge2 = 0.0;
-    }
-
-    dXCharge1 = par * dXCharge1;  // normalize by mean of number of carriers
-    dXCharge2 = par * dXCharge2;
-
-    // for the time being, signal is the charge
-    // in ChargeToSignal signal is converted in ADC channel
-    signal = fMapA2->GetSignal(k,strip);
-    signal += dXCharge1;
-
-    fMapA2->SetHit(k,strip,(Double_t)signal);
-    if(((Int_t) strip) < (fNstrips-1)) {
-      // strip doesn't have to be the last (remind: last=fNstrips-1)
-      // otherwise part of the charge is lost
-      signal = fMapA2->GetSignal(k,(strip+1));
-      signal += dXCharge2;
-      fMapA2->SetHit(k,(strip+1),(Double_t)signal);
-    }
+    Double_t strip = TMath::Floor(w);         // clostest strip on the left
+
+    if ( TMath::Abs((strip - w)) < 0.5) { 
+       // gaussian mean is closer to strip on the left
+       a = inf;                         // integration starting point
+       if((strip+0.5)<=sup) {
+           // this means that the tail of the gaussian goes beyond
+           // the middle point between strips ---> part of the signal
+           // is given to the strip on the right
+           b = strip + 0.5;               // integration stopping point
+           dXCharge1 = F( w, b, sigma) - F(w, a, sigma);
+           dXCharge2 = F( w, sup, sigma) - F(w ,b, sigma); 
+       }else { 
+           // this means that all the charge is given to the strip on the left
+           b = sup;
+           dXCharge1 = 0.9973;   // gaussian integral at 3 sigmas
+           dXCharge2 = 0.0;
+       } // end if
+
+       dXCharge1 = par * dXCharge1;// normalize by mean of number of carriers
+       dXCharge2 = par * dXCharge2;
+
+       // for the time being, signal is the charge
+       // in ChargeToSignal signal is converted in ADC channel
+       signal = fMapA2->GetSignal(k,strip);
+       signal += dXCharge1;
+
+       fMapA2->SetHit(k,strip,(Double_t)signal);
+       if(((Int_t) strip) < (fNstrips-1)) {
+           // strip doesn't have to be the last (remind: last=fNstrips-1)
+           // otherwise part of the charge is lost
+           signal = fMapA2->GetSignal(k,(strip+1));
+           signal += dXCharge2;
+           fMapA2->SetHit(k,(strip+1),(Double_t)signal);
+       } // end if
     
-    if(dXCharge1 > 1.) {
-      if (first) {
-       indexRange[k*2+0]=indexRange[k*2+1]=(Int_t) strip;
-       first=kFALSE;
-      }
-
-      indexRange[k*2+0]=TMath::Min(indexRange[k*2+0],(Int_t) strip);
-      indexRange[k*2+1]=TMath::Max(indexRange[k*2+1],(Int_t) strip);
-    }      // dXCharge > 1 e-
-
-  }
-  else {
-    // gaussian mean is closer to strip on the right
-    strip++;     // move to strip on the rigth
-    b = sup;     // now you know where to stop integrating
-    if((strip-0.5)>=inf) { 
-      // tail of diffusion gaussian on the left goes left of
-      // middle point between strips
-      a = strip - 0.5;        // integration starting point
-      dXCharge1 = F(w, b, sigma) - F(w, a, sigma);
-      dXCharge2 = F(w, a, sigma) - F(w, inf, sigma);
-    }
-    else {
-      a = inf;
-      dXCharge1 = 0.9973;   // gaussian integral at 3 sigmas
-      dXCharge2 = 0.0;
-    }
+       if(dXCharge1 > 1.) {
+           if (first) {
+               indexRange[k*2+0]=indexRange[k*2+1]=(Int_t) strip;
+               first=kFALSE;
+           } // end if first
+
+           indexRange[k*2+0]=TMath::Min(indexRange[k*2+0],(Int_t) strip);
+           indexRange[k*2+1]=TMath::Max(indexRange[k*2+1],(Int_t) strip);
+       }      // dXCharge > 1 e-
+
+    }else{
+       // gaussian mean is closer to strip on the right
+       strip++;     // move to strip on the rigth
+       b = sup;     // now you know where to stop integrating
+       if((strip-0.5)>=inf) { 
+           // tail of diffusion gaussian on the left goes left of
+           // middle point between strips
+           a = strip - 0.5;        // integration starting point
+           dXCharge1 = F(w, b, sigma) - F(w, a, sigma);
+           dXCharge2 = F(w, a, sigma) - F(w, inf, sigma);
+       }else {
+           a = inf;
+           dXCharge1 = 0.9973;   // gaussian integral at 3 sigmas
+           dXCharge2 = 0.0;
+       } // end if
     
-    dXCharge1 = par * dXCharge1;    // normalize by means of carriers
-    dXCharge2 = par * dXCharge2;
-
-    // for the time being, signal is the charge
-    // in ChargeToSignal signal is converted in ADC channel
-    signal = fMapA2->GetSignal(k,strip);
-    signal += dXCharge1;
-    fMapA2->SetHit(k,strip,(Double_t)signal);
-    if(((Int_t) strip) > 0) {
-      // strip doesn't have to be the first
-      // otherwise part of the charge is lost
-      signal = fMapA2->GetSignal(k,(strip-1));
-      signal += dXCharge2;
-      fMapA2->SetHit(k,(strip-1),(Double_t)signal);
-    }
+       dXCharge1 = par * dXCharge1;    // normalize by means of carriers
+       dXCharge2 = par * dXCharge2;
+
+       // for the time being, signal is the charge
+       // in ChargeToSignal signal is converted in ADC channel
+       signal = fMapA2->GetSignal(k,strip);
+       signal += dXCharge1;
+       fMapA2->SetHit(k,strip,(Double_t)signal);
+       if(((Int_t) strip) > 0) {
+           // strip doesn't have to be the first
+           // otherwise part of the charge is lost
+           signal = fMapA2->GetSignal(k,(strip-1));
+           signal += dXCharge2;
+           fMapA2->SetHit(k,(strip-1),(Double_t)signal);
+       } // end if
     
-    if(dXCharge1 > 1.) {
-      if (first) {
-       indexRange[k*2+0]=indexRange[k*2+1]=(Int_t) strip;
-       first=kFALSE;
-      }
-
-      indexRange[k*2+0]=TMath::Min(indexRange[k*2+0],(Int_t) strip);
-      indexRange[k*2+1]=TMath::Max(indexRange[k*2+1],(Int_t) strip);
-    }      // dXCharge > 1 e-
-  }
+       if(dXCharge1 > 1.) {
+           if (first) {
+               indexRange[k*2+0]=indexRange[k*2+1]=(Int_t) strip;
+               first=kFALSE;
+           } // end if first
+
+           indexRange[k*2+0]=TMath::Min(indexRange[k*2+0],(Int_t) strip);
+           indexRange[k*2+1]=TMath::Max(indexRange[k*2+1],(Int_t) strip);
+       }      // dXCharge > 1 e-
+    } // end if
 }
-
-
-  //_________________________________________________________________________
-
+//______________________________________________________________________
 Int_t AliITSsimulationSSD::NumOfSteps(Double_t x, Double_t y, Double_t z,
-                                Double_t & dex,Double_t & dey,Double_t & dez) {  
-  // number of steps
-  // it also returns steps for each coord
-  //AliITSsegmentationSSD *seg = new AliITSsegmentationSSD();
+                                Double_t & dex,Double_t & dey,Double_t & dez){
+    // number of steps
+    // it also returns steps for each coord
+    //AliITSsegmentationSSD *seg = new AliITSsegmentationSSD();
 
-  Double_t step = 25E-4;
-  //step = (Double_t) seg->GetStepSize();  // step size (cm)
-  Int_t numOfSteps = (Int_t) (TMath::Sqrt(x*x+y*y+z*z)/step); 
+    Double_t step = 25E-4;
+    //step = (Double_t) seg->GetStepSize();  // step size (cm)
+    Int_t numOfSteps = (Int_t) (TMath::Sqrt(x*x+y*y+z*z)/step); 
 
-  if (numOfSteps < 1) numOfSteps = 1;       // one step, at least
+    if (numOfSteps < 1) numOfSteps = 1;       // one step, at least
 
-  // we could condition the stepping depending on the incident angle
-  // of the track
-  dex = x/numOfSteps;
-  dey = y/numOfSteps;
-  dez = z/numOfSteps;
-
-  return numOfSteps;
+    // we could condition the stepping depending on the incident angle
+    // of the track
+    dex = x/numOfSteps;
+    dey = y/numOfSteps;
+    dez = z/numOfSteps;
 
+    return numOfSteps;
 }
-
-//---------------------------------------------
-void AliITSsimulationSSD::GetList(Int_t label,Float_t **pList,Int_t *indexRange) {
-  // loop over nonzero digits
-  Int_t ix,globalIndex;
-  Float_t signal=0.;
-  Float_t highest,middle,lowest;
+//----------------------------------------------------------------------
+void AliITSsimulationSSD::GetList(Int_t label,Float_t **pList,
+                                 Int_t *indexRange) {
+    // loop over nonzero digits
+    Int_t ix,globalIndex;
+    Float_t signal=0.;
+    Float_t highest,middle,lowest;
   // printf("SPD-GetList: indexRange[0] indexRange[1] indexRange[2] indexRange[3] %d %d %d %d\n",indexRange[0], indexRange[1], indexRange[2], indexRange[3]);
 
-  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]) 
-       signal=fMapA2->GetSignal(k,ix);
+    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]) 
+               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{
-       
-       // 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) 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 of loop pixels in x
-  } // end of loop over pixels in z
+           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{
+               // 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) 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
+       } // end of loop pixels in x
+    } // end of loop over pixels in z
 }
-
-//---------------------------------------------
+//----------------------------------------------------------------------
 void AliITSsimulationSSD::ChargeToSignal(Float_t **pList) {
-  // charge to signal  
-
-  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;
-  Float_t noise[2] = {0.,0.};
-  fResponse->GetNoiseParam(noise[0],noise[1]);
+    // charge to signal
+    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;
+    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)
-
-    // 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
-    //cout<<"SSD: k,thresh ="<<k<<","<<threshold<<endl;
-    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;        
-       //cout<<"SSD: 1 signal ="<<signal<<endl;
-       if(signal>1000.) signal = 1000.0; // if exceeding, accumulate last one
-       //cout<<"SSD: 2 signal ="<<signal<<endl;
-       digits[2]=(Int_t) signal;
-
-       //gi =k*fNstrips+ix; // global index
-       for(j1=0;j1<3;j1++){
-         if (pList[gi]) {
-           tracks[j1] = (Int_t)(*(pList[gi]+j1));
-         }       
-         else {
-           tracks[j1]=-2; //noise
-         }
-         charges[j1] = 0;
-       }
-
-       phys=0;
-
-       hits[0]=0;
-       hits[1]=0;
-       hits[2]=0;
-       aliITS->AddSimDigit(2,phys,digits,tracks,hits,charges);  // finally add digit
-
-       //if(pList[gi]) delete [] pList[gi];
-      }
-      if(pList[gi]) delete [] pList[gi];
-    }
-  }
-  delete [] pList;
+    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;
+
+               //gi =k*fNstrips+ix; // global index
+               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);
+
+               //if(pList[gi]) delete [] pList[gi];
+           } // end if signal > threshold
+           if(pList[gi]) delete [] pList[gi];
+       } // end for ix
+    } // end for k
+    delete [] pList;
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
index 75e2f675a43ce84e626e5a101f20dc244cdd125e..1ef7d97efbfa82da0a82f3ab00f9669bc6edd6e1 100644 (file)
@@ -60,7 +60,7 @@ gPad->SetFillColor(33);
       ntuple->Draw("dz","lay == 6 && hitprim == 1&&abs(dz)<5000");
 
 
-      /*
+/*
 c2->cd(1);
 gPad->SetFillColor(33);
       ntuple1->SetFillColor(42);
@@ -77,7 +77,7 @@ c2->cd(4);
 gPad->SetFillColor(33);
       ntuple1->SetFillColor(46);
       ntuple1->Draw("nxN","lay == 6 && noverprim>=0");
-      */
+*/
 
 /*
 c2->cd(1);
@@ -104,12 +104,12 @@ gPad->SetFillColor(33);
       /*
 c2->cd(1);
 gPad->SetFillColor(33);
-      adcPadcN5all->SetFillColor(42);
-      adcPadcN5all->Draw();
+      ntuple1->SetFillColor(42);
+      ntuple1->Draw("qclP","noverprim>=0");
 c2->cd(2);
 gPad->SetFillColor(33);
-      adcPadcN6all->SetFillColor(46);
-      adcPadcN6all->Draw();
+      ntuple1->SetFillColor(42);
+      ntuple1->Draw("qclN","noverprim>=0");
 c2->cd(3);
 gPad->SetFillColor(33);
       adcPadcN5cut->SetFillColor(42);
index 525cfee83a5cf4adc737a3abdb4e34e965d3eec2..cd88fe7092a1f0f0d05356417249920396c5df5a 100644 (file)
@@ -229,7 +229,8 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
      printf("det type %d first2, last2 %d %d \n",2,first2,last2);
 
      // module loop for the SSD
-     for (mod=first2; mod<last2+1; mod++) {
+     for (mod=first2; mod<last2+1; mod++) {  // for the "ALL" option
+     //for (mod=0; mod<last2-first2+1; mod++) { //for the "SSD" option
 
        TTree *TR = gAlice->TreeR();
        Int_t nentrec=TR->GetEntries();
@@ -248,16 +249,21 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
        Int_t nrecp = ITSrec->GetEntries();
        totpoints += nrecp;
        if (nrecp) printf("Found %d rec points for module %d\n",nrecp,mod);
-       if (!nrecp) continue;
+       //if (!nrecp) continue;
        Int_t nclusters = ITSclu->GetEntries();
        totclust += nclusters;
        //if (nclusters) printf("Found %d clusters for module %d\n",nrecc,mod);
        
+       //AliITSmodule *Mod = (AliITSmodule *)fITSmodules->At(mod+first2);
+       // for the "SSD" option
+
        AliITSmodule *Mod = (AliITSmodule *)fITSmodules->At(mod);
+       // for the "ALL" option
+
        //       printf("Mod: %X\n",Mod);
        Int_t nhits = Mod->GetNhits();
        Float_t epart = 0;
-       cout <<" module,nrecp,nclusters,nhits ="<<mod<<","<<nrecp<<","<<nclusters<<","<<nhits<< endl;
+       //cout <<" module,nrecp,nclusters,nhits ="<<mod<<","<<nrecp<<","<<nclusters<<","<<nhits<< endl;
 
        // ---------------- cluster/hit analysis ---------------------
 
@@ -377,18 +383,19 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
 
 
          // x,z resolution colculation
-          if((hitstat == 68 || hitsat == 33) && parent < 0)  {
+          if(hitstat == 68 || hitsat == 33) {
             Float_t xmed = (xhit + xhit0)/2;
             Float_t zmed = (zhit + zhit0)/2;
             Float_t xdif = xmed - xrec;
             Float_t zdif = zmed - zrec;
 
-            hitprim = 1; // hitprim=1 for the primery particles
-
-            noverprim += 1;
-
+            if(parent < 0)  {
+             hitprim = 1; // hitprim=1 for the primery particles
+             noverprim += 1;
+           }
             pathInSSD = TMath::Sqrt((xhit0-xhit)*(xhit0-xhit)+(yhit0-yhit)*(yhit0-yhit)+(zhit0-zhit)*(zhit0-zhit));
 
+            //cout<<"lay,pnt,hit,xmed,xrec,xdif,zmed,zrec,zdif ="<<hitlayer<<","<<pnt<<","<<hit<<","<<xmed<<","<<xrec<<","<<xdif<<","<<zmed<<","<<zrec<<","<<zdif<<endl;
 
         // fill ntuple
              ntuple_st.lay = hitlayer;
@@ -402,14 +409,17 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
              ntuple_st.dz = zdif;
              ntuple_st.pmod = pmod;
 
-             if(qcut < 0.18) ntuple->Fill();
+             //if(qcut < 0.18) ntuple->Fill();
+             ntuple->Fill();
 
-           if(hitlayer == 5 && qcut < 0.18) {
+            //if(hitlayer == 5 && qcut < 0.18) {
+           if(hitlayer == 5 ) {
              Xres5->Fill(xdif);
              Zres5->Fill(zdif);
              Path5->Fill(pathInSSD);
-            }
-            if(hitlayer == 6 && qcut < 0.18) {
+           }
+            //if(hitlayer == 6 && qcut < 0.18) {
+            if(hitlayer == 6) {
              Xres6->Fill(xdif);
              Zres6->Fill(zdif);
              Path6->Fill(pathInSSD);
@@ -442,7 +452,8 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
          ntuple1_st.noverlaps = noverlaps;
          ntuple1_st.noverprim = noverprim;
 
-         if(qcut < 0.18) ntuple1->Fill();
+         //if(qcut < 0.18) ntuple1->Fill();
+         ntuple1->Fill();
 
           Float_t de = dedx*300./pathInSSD;
           dEdX->Fill(de);