Changes in SDD cluster finder for usage of calibration constants. Cleanup of AliITSdi...

diff --git a/ITS/AliITSClusterFinderSDD.cxx b/ITS/AliITSClusterFinderSDD.cxx
index 3c825108f6218886fb624bd9bd8f9c07b31c5956..41115ba683c95faa734a3e0a610b338a4a0708a7 100644 (file)
--- a/ITS/AliITSClusterFinderSDD.cxx
+++ b/ITS/AliITSClusterFinderSDD.cxx
@@ -81,13 +81,19 @@ void AliITSClusterFinderSDD::SetCutAmplitude(Int_t mod,Double_t nsigma){
     // set the signal threshold for cluster finder
     Double_t baseline,noiseAfterEl;
 
-    
+    AliITSresponseSDD* res  = (AliITSresponseSDD*)((AliITSCalibrationSDD*)GetResp(mod))->GetResponse();
+    const char *option=res->ZeroSuppOption();
     Int_t nanodes = GetResp(mod)->Wings()*GetResp(mod)->Channels()*GetResp(mod)->Chips();
     fCutAmplitude.Set(nanodes);
     for(Int_t ian=0;ian<nanodes;ian++){
-      baseline=GetResp(mod)->GetBaseline(ian);
       noiseAfterEl = ((AliITSCalibrationSDD*)GetResp(mod))->GetNoiseAfterElectronics(ian);
-      fCutAmplitude[ian] = (Int_t)((baseline + nsigma*noiseAfterEl));
+      if((strstr(option,"1D")) || (strstr(option,"2D"))){ 
+       fCutAmplitude[ian] = (Int_t)(nsigma*noiseAfterEl);
+      }
+      else{
+       baseline=GetResp(mod)->GetBaseline(ian);
+       fCutAmplitude[ian] = (Int_t)((baseline + nsigma*noiseAfterEl));
+      } 
     }
 }
 //______________________________________________________________________
@@ -103,6 +109,9 @@ void AliITSClusterFinderSDD::Find1DClusters(){
     Double_t fSddLength   = GetSeg()->Dx();
     Double_t anodePitch   = GetSeg()->Dpz(dummy);
     AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
+    AliITSresponseSDD* res  = (AliITSresponseSDD*)((AliITSCalibrationSDD*)GetResp(fModule))->GetResponse();
+    const char *option=res->ZeroSuppOption();
+
     // map the signal
     Map()->ClearMap();
     Map()->SetThresholdArr(fCutAmplitude);
@@ -184,13 +193,14 @@ void AliITSClusterFinderSDD::Find1DClusters(){
                     Int_t   clusterMult   = 0;
                     Double_t clusterPeakAmplitude = 0.;
                     Int_t its,peakpos     = -1;
-                    //Double_t n, baseline;
-                    //GetResp(fModule)->GetNoiseParam(n,baseline);
-                   Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+                                  
                    for(its=tstart; its<=tstop; its++) {
                         fadc=(float)Map()->GetSignal(idx,its);
-                        if(fadc>baseline) fadc -= baseline;
-                        else fadc = 0.;
+                       if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+                         Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+                         if(fadc>baseline) fadc -= baseline;
+                         else fadc = 0.;
+                       }
                         clusterCharge += fadc;
                         // as a matter of fact we should take the peak
                         // pos before FFT
@@ -256,12 +266,14 @@ void AliITSClusterFinderSDD::Find1DClustersE(){
     Map()->SetThresholdArr( fCutAmplitude );
     Map()->FillMap2();
 
+    AliITSresponseSDD* res  = (AliITSresponseSDD*)cal->GetResponse();
+    const char *option=res->ZeroSuppOption();
+
     Int_t nClu = 0;
     //        cout << "Search  cluster... "<< endl;
     for( Int_t j=0; j<2; j++ ){
         for( Int_t k=0; k<fNofAnodes; k++ ){
-            Int_t idx = j*fNofAnodes+k;
-           Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+            Int_t idx = j*fNofAnodes+k;            
             Bool_t on = kFALSE;
             Int_t start = 0;
             Int_t nTsteps = 0;
@@ -287,8 +299,11 @@ void AliITSClusterFinderSDD::Find1DClustersE(){
                         nTsteps = 0;
                     } // end if on...
                     nTsteps++ ;
-                    if( fadc > baseline ) fadc -= baseline;
-                    else fadc=0.;
+                   if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+                     Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+                     if( fadc > baseline ) fadc -= baseline;
+                     else fadc=0.;
+                   }
                     charge += fadc;
                     time += fadc*l;
                     if( fadc > fmax ){ 
@@ -693,10 +708,10 @@ void AliITSClusterFinderSDD::ResolveClusters(){
     Double_t fTimeStep = GetSeg()->Dpx( dummy );
     Double_t fSddLength = GetSeg()->Dx();
     Double_t anodePitch = GetSeg()->Dpz( dummy );
-    //Double_t n, baseline;
-    //GetResp(fModule)->GetNoiseParam( n, baseline );
     Int_t electronics =GetResp(fModule)->GetElectronics(); // 1 = PASCAL, 2 = OLA
     AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
+    AliITSresponseSDD* res  = (AliITSresponseSDD*)cal->GetResponse();
+    const char *option=res->ZeroSuppOption();
     
 
     for( Int_t j=0; j<nofClusters; j++ ){ 
@@ -723,10 +738,12 @@ void AliITSClusterFinderSDD::ResolveClusters(){
         // make a local map from cluster region
         for( Int_t ianode=astart; ianode<=astop; ianode++ ){
             for( Int_t itime=tstart; itime<=tstop; itime++ ){
-                Double_t fadc = Map()->GetSignal( ianode, itime );
-               Double_t baseline=GetResp(fModule)->GetBaseline(ianode);
-                if( fadc > baseline ) fadc -= (Double_t)baseline;
-                else fadc = 0.;
+                Double_t fadc = Map()->GetSignal( ianode, itime );            
+               if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+                 Double_t baseline=GetResp(fModule)->GetBaseline(ianode);
+                 if( fadc > baseline ) fadc -= (Double_t)baseline;
+                 else fadc = 0.;
+               }
                 Int_t index = (itime-tstart+1)*zdim+(ianode-astart+1);
                 sp[index] = fadc;
             } // time loop

diff --git a/ITS/AliITSClusterFinderV2SDD.cxx b/ITS/AliITSClusterFinderV2SDD.cxx
index 0fd1cf10a22b480aa0bd45ee1582bb083e472be6..72f4827ffd9bfe9fcd7cc34a7740751ba3c2ab14 100644 (file)
--- a/ITS/AliITSClusterFinderV2SDD.cxx
+++ b/ITS/AliITSClusterFinderV2SDD.cxx
@@ -25,7 +25,7 @@
 #include "AliITSRecPoint.h"
 #include "AliITSDetTypeRec.h"
 #include "AliRawReader.h"
-#include "AliITSRawStreamSDDv3.h"
+#include "AliITSRawStreamSDD.h"
 #include "AliITSCalibrationSDD.h"
 #include "AliITSDetTypeRec.h"
 #include "AliITSsegmentationSDD.h"
@@ -68,21 +68,22 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(TClonesArray *digits) {
   bins[0]=new AliBin[kMAXBIN];
   bins[1]=new AliBin[kMAXBIN];
   AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
-  
+  AliITSresponseSDD* res  = (AliITSresponseSDD*)cal->GetResponse();
+  const char *option=res->ZeroSuppOption();
   AliITSdigitSDD *d=0;
   Int_t i, ndigits=digits->GetEntriesFast();
   for (i=0; i<ndigits; i++) {
      d=(AliITSdigitSDD*)digits->UncheckedAt(i);
-     Float_t baseline = cal->GetBaseline(d->GetCoord1());
-
      Int_t y=d->GetCoord2()+1;   //y
      Int_t z=d->GetCoord1()+1;   //z
      Int_t q=d->GetSignal();
-
-     if(q>baseline) q-=(Int_t)baseline;
-     else q=0;
+     if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+       Float_t baseline = cal->GetBaseline(d->GetCoord1());
+       if(q>baseline) q-=(Int_t)baseline;
+       else q=0;
+     }
      if(q<cal->GetThresholdAnode(d->GetCoord1())) continue;
- 
+     
      //if (q<3) continue;
 
      if (z <= fNzSDD) {
@@ -241,7 +242,7 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
          Float_t hit[5] = {y, z, 0.0030*0.0030, 0.0020*0.0020, q};
          Int_t  info[3] = {maxj-minj+1, maxi-mini+1, fNlayer[fModule]};
 
-         //if (c.GetQ() < 20.) continue; //noise cluster
+         if (c.GetQ() < 20.) continue; //noise cluster
         
         if (digits) {    
           //      AliBin *b=&bins[s][idx[k]];
@@ -276,7 +277,7 @@ void AliITSClusterFinderV2SDD::RawdataToClusters(AliRawReader* rawReader,TClones
   // This function creates ITS clusters from raw data
   //------------------------------------------------------------
   rawReader->Reset();
-  AliITSRawStreamSDDv3 inputSDD(rawReader);
+  AliITSRawStreamSDD inputSDD(rawReader);
   FindClustersSDD(&inputSDD,clusters);
 
 }

diff --git a/ITS/AliITSVertexer3D.h b/ITS/AliITSVertexer3D.h
index 1ff98fdc134e69706f3b9377a6e6e689cdb9a0de..8aa4b5c0e24976278c17aedf6d0885c9469bc89c 100644 (file)
--- a/ITS/AliITSVertexer3D.h
+++ b/ITS/AliITSVertexer3D.h
@@ -28,7 +28,7 @@ class AliITSVertexer3D : public AliITSVertexer {
   void SetCoarseDiffPhiCut(Float_t dphi = 0.5){fCoarseDiffPhiCut=dphi;}
   void SetCoarseMaxRCut(Float_t rad = 2.5){fCoarseMaxRCut=rad;}
   void SetMaxRCut(Float_t rad = 0.5){fMaxRCut=rad;}
-  void SetZCutDiamond(Float_t zcut = 5.3){fZCutDiamond=zcut;}
+  void SetZCutDiamond(Float_t zcut = 14.0){fZCutDiamond=zcut;}
   void SetMaxZCut(Float_t dz = 0.5){fMaxZCut=dz;}
   void SetDCAcut(Float_t dca=0.1){fDCAcut=dca;} 
   void SetDiffPhiMax(Float_t pm = 0.01){fDiffPhiMax = pm;}

diff --git a/ITS/AliITSdigit.cxx b/ITS/AliITSdigit.cxx
index ce81fe6bef236242bf5aac02b578c1d44bcdd68f..1689dc8367ab87947f6ee7bdcef32f09531a6bc9 100644 (file)
--- a/ITS/AliITSdigit.cxx
+++ b/ITS/AliITSdigit.cxx
@@ -32,6 +32,9 @@ fCoord1(0),
 fCoord2(0),
 fSignal(0){
   //default constructor. zero all values.
+  for(Int_t i=0;i<fgkSize;i++) fTracks[i] = 0;
+  for(Int_t i=0;i<fgkSize;i++) fHits[i]   = 0;
+  
 }
 
 
@@ -40,6 +43,9 @@ fCoord1(digits[0]),
 fCoord2(digits[1]),
 fSignal(digits[2]){
   // Creates a real data digit object
+  for(Int_t i=0;i<fgkSize;i++) fTracks[i] = 0;
+  for(Int_t i=0;i<fgkSize;i++) fHits[i]   = 0;
+
 
 }
 //______________________________________________________________________

diff --git a/ITS/AliITSdigit.h b/ITS/AliITSdigit.h
index 953711dc4eea69d2dfbbd01d07d3291e71a1315c..3045d5522bf59bf3a271a0c15ea3df66536fdb12 100644 (file)
--- a/ITS/AliITSdigit.h
+++ b/ITS/AliITSdigit.h
@@ -27,16 +27,16 @@ class AliITSdigit: public TObject  {
     //Destructor
     virtual ~AliITSdigit() { }
     // returns the array size used to store Tracks and Hits
-    // virtual Int_t GetNTracks() {return 0;}
+    static Int_t GetNTracks() {return fgkSize;}
     //returns pointer to array of tracks numbers
-    virtual Int_t *GetTracks() {return 0;}
+    virtual Int_t *GetTracks()  {return &fTracks[0];}
     // returns pointer to array of hits numbers for this module (as given by
     // AliITSmodule).
-    virtual Int_t *GetHits() {return 0;}
+    virtual Int_t *GetHits()  {return &fHits[0];}
     // returns track number kept in the array element i of fTracks 
-    virtual Int_t GetTrack(Int_t) const {return 0;}
+    virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
     // returns hit number kept in the array element i of fHits 
-    virtual Int_t GetHit(Int_t) const {return 0;}
+    virtual Int_t GetHit(Int_t i) const {return fHits[i];}
     virtual Int_t GetCoord1() const {return fCoord1;} // returns fCoord1
     virtual Int_t GetCoord2() const {return fCoord2;} // returns fCoord2
     virtual Int_t GetSignal() const {return fSignal;} // returns fSignal
@@ -44,18 +44,27 @@ class AliITSdigit: public TObject  {
     virtual void SetCoord1(Int_t i){fCoord1 = i;} // Sets fCoord1 value
     virtual void SetCoord2(Int_t i){fCoord2 = i;} // Sets fCoord12value
     virtual void SetSignal(Int_t i){fSignal = i;} // Sets fSignal value
-
+    virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
+    virtual void SetTracks(const Int_t *trks){
+       for(Int_t i=0;i<fgkSize;i++) fTracks[i]=trks[i];}
+    virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
+    virtual void SetHits(const Int_t *hits){
+       for(Int_t i=0;i<fgkSize;i++) fHits[i]=hits[i];}
     virtual void Print(Option_t *option="") const {TObject::Print(option);}
     virtual void Print(ostream *os); // Class ascii print function
     virtual Int_t Read(const char *name) {return TObject::Read(name);}
     virtual void Read(istream *os);  // Class ascii read function
 
  protected:
+    static const Int_t fgkSize = 10;//array size
+    Int_t   fTracks[fgkSize];   //[fgkSize] tracks making this digit 
+    Int_t   fHits[fgkSize];     //[fgkSize] hits associated to the tracks
+
     Int_t fCoord1; // Cell number on Z axis (SPD+SDD), flag for side type (SSD)
     Int_t fCoord2; // Cell number on X axis (SPD+SDD), strip number (SSD)
     Int_t fSignal; // Signal in ADC counts
 
-    ClassDef(AliITSdigit,1)     // Real data digit object for set:ITS
+    ClassDef(AliITSdigit,2)     // Real data digit object for set:ITS
 
 };
 // Input and output functions for standard C++ input/output.

diff --git a/ITS/AliITSdigitSDD.cxx b/ITS/AliITSdigitSDD.cxx
index 72112b4a352b9064bb42fa02343fd4a66801de1f..f77196e881d210e4026cfa1acd32e5fe267bbad1 100644 (file)
--- a/ITS/AliITSdigitSDD.cxx
+++ b/ITS/AliITSdigitSDD.cxx
@@ -39,9 +39,9 @@ fSignalExpanded(0){
     // be a valide track of hit number.
     Int_t i;
 
-    for(i=0;i<fgkSsdd;i++) fTracks[i] = -3;
-    for(i=0;i<fgkSsdd;i++) fHits[i]   = -1;
-    for(i=0;i<fgkSsdd;i++) fTcharges[i] = 0;
+    for(i=0;i<fgkSize;i++) fTracks[i] = -3;
+    for(i=0;i<fgkSize;i++) fHits[i]   = -1;
+    for(i=0;i<fgkSize;i++) fTcharges[i] = 0;
     SetSignalExpanded(-1000);
 }
 //________________________________________________________________________
@@ -50,8 +50,11 @@ fPhysics(phys),
 fSignalExpanded(0){
  
    // Creates a simulated SDD digit object to be updated
-
-    SetSignalExpanded(-1000);
+  for(Int_t i=0;i<fgkSize;i++) fTracks[i] = -3;
+  for(Int_t i=0;i<fgkSize;i++) fHits[i]   = -1;
+  for(Int_t i=0;i<fgkSize;i++) fTcharges[i] = 0;
+  
+  SetSignalExpanded(-1000);
 }
 
 //________________________________________________________________________
@@ -60,7 +63,7 @@ void AliITSdigitSDD::InitObject(Float_t phys,const Int_t *tracks,
 
   // Protected function used by standard constructors
   fPhysics = phys;
-  for(Int_t i=0; i<fgkSsdd; i++) {
+  for(Int_t i=0; i<fgkSize; i++) {
     fTcharges[i] = charges[i];
     fTracks[i]   = tracks[i];
     fHits[i]     = hits[i];
@@ -177,9 +180,9 @@ void AliITSdigitSDD::Print(ostream *os){
 
     AliITSdigit::Print(os);
     *os <<","<< fPhysics;
-    for(i=0; i<fgkSsdd; i++) *os <<","<< fTcharges[i];
-    for(i=0; i<fgkSsdd; i++) *os <<","<< fTracks[i];
-    for(i=0; i<fgkSsdd; i++) *os <<","<< fHits[i];
+    for(i=0; i<fgkSize; i++) *os <<","<< fTcharges[i];
+    for(i=0; i<fgkSize; i++) *os <<","<< fTracks[i];
+    for(i=0; i<fgkSize; i++) *os <<","<< fHits[i];
     *os <<","<< fSignalExpanded;
 }
 //______________________________________________________________________
@@ -190,9 +193,9 @@ void AliITSdigitSDD::Read(istream *os){
 
     AliITSdigit::Read(os);
     *os >>fPhysics;
-    for(i=0; i<fgkSsdd; i++) *os >> fTcharges[i];
-    for(i=0; i<fgkSsdd; i++) *os >> fTracks[i];
-    for(i=0; i<fgkSsdd; i++) *os >> fHits[i];
+    for(i=0; i<fgkSize; i++) *os >> fTcharges[i];
+    for(i=0; i<fgkSize; i++) *os >> fTracks[i];
+    for(i=0; i<fgkSize; i++) *os >> fHits[i];
     *os >>fSignalExpanded;
 }
 //______________________________________________________________________

diff --git a/ITS/AliITSdigitSDD.h b/ITS/AliITSdigitSDD.h
index 62019ec778b544cd49c52e11b743e33fc7595951..15e790c2b9cbb70d018fbcf9e0cf06fefd1e1d2b 100644 (file)
--- a/ITS/AliITSdigitSDD.h
+++ b/ITS/AliITSdigitSDD.h
@@ -28,31 +28,12 @@ class AliITSdigitSDD: public AliITSdigit {
                     AliITSCalibrationSDD *resp);
     virtual ~AliITSdigitSDD(){/* destructor*/}
     // returns the array size used to store Tracks and Hits
-    static Int_t GetNTracks() {return fgkSsdd;}
-    // returns pointer to the array of tracks which make this digit
-    virtual Int_t *GetTracks()  {return &fTracks[0];}
-    // returns the pointer to the array of hits which made this digit
-    virtual Int_t *GetHits()  {return &fHits[0];}
     virtual Int_t GetSignal() const {return fSignalExpanded;}
     virtual Int_t GetCompressedSignal() const {return fSignal;}
-    // returns track number kept in the array element i of fTracks 
-    virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
-    // returns hit number kept in the array element i of fHits 
-    virtual Int_t GetHit(Int_t i) const {return fHits[i];}
-    // Return charge deposited by this track/hit
+     // Return charge deposited by this track/hit
     virtual Float_t GetCharge(Int_t i) const {return fTcharges[i];}
     // returns TArrayI of unduplicated track numbers (summed over hits).
     virtual Int_t GetListOfTracks(TArrayI &t,TArrayF &c);
-    //copy the array trks[fgkSsdd] into fTracks
-    virtual void SetTracks(const Int_t *trks){
-       for(Int_t i=0;i<fgkSsdd;i++) fTracks[i]=trks[i];}
-    //copy the array hits[fgkSsdd] into fHits
-    virtual void SetHits(const Int_t *hits){
-       for(Int_t i=0;i<fgkSsdd;i++) fHits[i]=hits[i];}
-    //set array element i of fTracks to trk.
-    virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
-    //set array element i of fHits to hit.
-    virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
     void SetSignalExpanded(Int_t sig){fSignalExpanded = sig;}
     virtual void Print(ostream *os); // Class ascii print function
     virtual void Read(istream *os);  // Class ascii read function
@@ -62,16 +43,12 @@ class AliITSdigitSDD: public AliITSdigit {
  protected:
     void InitObject(Float_t phys,const Int_t *tracks,
                    const Int_t *hits,const Float_t *charges);
-    static const Int_t fgkSsdd = 10; // size of fTracks and fHits arrays
     
-    // debugging  -- goes to the dictionary
-    Int_t   fTracks[fgkSsdd];   //[fgkSsdd] tracks making this digit 
-    Int_t   fHits[fgkSsdd];     //[fgkSsdd] hits associated to the tracks
                             // 3 hits temporarily - it will be only 1
-    Float_t fTcharges[fgkSsdd];   //[fgkSsdd] charge per track making this digit 
+    Float_t fTcharges[fgkSize];   //[fgkSize] charge per track making this digit 
     Float_t fPhysics;       // signal particles contribution to signal
     Int_t fSignalExpanded;  // 10 bit signal
-    ClassDef(AliITSdigitSDD,3)   // Simulated digit object for SDD
+    ClassDef(AliITSdigitSDD,4)   // Simulated digit object for SDD
 
 };
 // Input and output functions for standard C++ input/output.

diff --git a/ITS/AliITSdigitSPD.cxx b/ITS/AliITSdigitSPD.cxx
index 2db9fca18977a469eeffe89e568bb76dfec3b66a..08fc5dd082e9a640f86bd1f76bca5bdc280e16ae 100644 (file)
--- a/ITS/AliITSdigitSPD.cxx
+++ b/ITS/AliITSdigitSPD.cxx
@@ -34,8 +34,8 @@ fSignalSPD(0){
     // be a valide track of hit number.
     Int_t i;
 
-    for(i=0;i<fgkSspd;i++) fTracks[i]  = -3;
-    for(i=0;i<fgkSspd;i++) fHits[i]    = -1;
+    for(i=0;i<fgkSize;i++) fTracks[i]  = -3;
+    for(i=0;i<fgkSize;i++) fHits[i]    = -1;
 }
 //______________________________________________________________________
 AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits):
@@ -43,8 +43,8 @@ fSignalSPD(digits[2]){
     // Creates a SPD digit object
     Int_t i;
 
-    for(i=0;i<fgkSspd;i++) fTracks[i]  = -3;
-    for(i=0;i<fgkSspd;i++) fHits[i]    = -1;
+    for(i=0;i<fgkSize;i++) fTracks[i]  = -3;
+    for(i=0;i<fgkSize;i++) fHits[i]    = -1;
     fCoord1       = digits[0];
     fCoord2       = digits[1];
     fSignal       = 1;
@@ -55,7 +55,7 @@ AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits,const Int_t *tracks,
 fSignalSPD(digits[2]){
     // Creates a simulated SPD digit object
 
-    for(Int_t i=0; i<fgkSspd; i++) {
+    for(Int_t i=0; i<fgkSize; i++) {
        fTracks[i] = tracks[i];
        fHits[i]   = hits[i];
     } // end for i
@@ -100,8 +100,8 @@ void AliITSdigitSPD::Print(ostream *os){
     Int_t i;
 
     AliITSdigit::Print(os);
-    for(i=0;i<fgkSspd;i++) *os <<","<< fTracks[i];
-    for(i=0;i<fgkSspd;i++) *os <<","<< fHits[i];
+    for(i=0;i<fgkSize;i++) *os <<","<< fTracks[i];
+    for(i=0;i<fgkSize;i++) *os <<","<< fHits[i];
     *os << "," << fSignalSPD;
 }
 //______________________________________________________________________
@@ -110,8 +110,8 @@ void AliITSdigitSPD::Read(istream *os){
     Int_t i;
 
     AliITSdigit::Read(os);
-    for(i=0;i<fgkSspd;i++) *os >> fTracks[i];
-    for(i=0;i<fgkSspd;i++) *os >> fHits[i];
+    for(i=0;i<fgkSize;i++) *os >> fTracks[i];
+    for(i=0;i<fgkSize;i++) *os >> fHits[i];
     *os >> fSignalSPD;
 }
 //______________________________________________________________________

diff --git a/ITS/AliITSdigitSPD.h b/ITS/AliITSdigitSPD.h
index edf8df7e9534bdd582e970128498077326f372d4..0262f07f39b15ca5975bfa2bbbfd3b3dc49ac2fd 100644 (file)
--- a/ITS/AliITSdigitSPD.h
+++ b/ITS/AliITSdigitSPD.h
@@ -16,46 +16,21 @@ class AliITSdigitSPD: public AliITSdigit {
     //standard creator with digits, tracks, and hits
     AliITSdigitSPD(const Int_t *digits,const Int_t *tracks,const Int_t *hits);
     virtual ~AliITSdigitSPD(){/*destructor*/}
-    // returns the array size used to store Tracks and Hits
-    static Int_t GetNTracks() {return fgkSspd;}
     // returns the signal in electrons
     Int_t GetSignalSPD() const {return fSignalSPD;}
-    // returns pointer to the array of tracks which make this digit
-    virtual Int_t *GetTracks()  {return &fTracks[0];}
-     //returns the pointer to the array of hits which made this digit
-    virtual Int_t *GetHits() {return &fHits[0];}
-    // returns track number kept in the array element i of fTracks 
-    virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
-    // returns hit number kept in the array element i of fHits 
-    virtual Int_t GetHit(Int_t i) const {return fHits[i];}
-    // returns TArrayI of unduplicated track numbers (summed over hits).
     virtual Int_t GetListOfTracks(TArrayI &t);
-    //copy the array trks[fgkSspd] into fTracks
-    virtual void SetTracks(const Int_t *trks){
-       for(Int_t i=0;i<fgkSspd;i++) fTracks[i]=trks[i];}
     // set signal in electrons
     void SetSignalSPD(Int_t sig) {fSignalSPD = sig;}
-    //copy the array hits[fgkSspd] into fHits
-    virtual void SetHits(const Int_t *hits){
-       for(Int_t i=0;i<fgkSspd;i++) fHits[i]=hits[i];}
-    //set array element i of fTracks to trk.
-    virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
-    //set array element i of fHits to hit.
-    virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
     virtual void Print(ostream *os); // Class ascii print function
     virtual void Print(Option_t *option="") const {TObject::Print(option);}
     virtual void Read(istream *os);  // Class ascii read function
     virtual Int_t Read(const char *name) {return TObject::Read(name);}
 
  protected:
-    static const Int_t fgkSspd = 10; // size of fTracks and fHits arrays
     
-    // debugging  -- goes to the dictionary
-    Int_t fTracks[fgkSspd]; //[fgkSspd] tracks making this digit 
-    Int_t fHits[fgkSspd];   //[fgkSspd] hits associated to the tracks
     Int_t fSignalSPD;   // Signal in electrons
 
-    ClassDef(AliITSdigitSPD,2)   // Simulated digit object for SPD
+    ClassDef(AliITSdigitSPD,3)   // Simulated digit object for SPD
 
 };
 // Input and output functions for standard C++ input/output.

diff --git a/ITS/AliITSdigitSSD.cxx b/ITS/AliITSdigitSSD.cxx
index dab748d24318f950f49cf7afe0b4ae927546929e..f6afe19122c2a5b61da7d1c9c9bbbf62dec9c2b3 100644 (file)
--- a/ITS/AliITSdigitSSD.cxx
+++ b/ITS/AliITSdigitSSD.cxx
@@ -31,8 +31,8 @@ AliITSdigitSSD::AliITSdigitSSD():AliITSdigit(){
     // default constructor
     Int_t i;
 
-    for(i=0; i<fgkSssd; i++) fTracks[i] = -3;
-    for(i=0; i<fgkSssd; i++) fHits[i] = -1;
+    for(i=0; i<fgkSize; i++) fTracks[i] = -3;
+    for(i=0; i<fgkSize; i++) fHits[i] = -1;
 }
 //__________________________________________________________________________
 AliITSdigitSSD::AliITSdigitSSD(const Int_t *digits):AliITSdigit(digits){
@@ -43,7 +43,7 @@ AliITSdigitSSD::AliITSdigitSSD(const Int_t *digits,const Int_t *tracks,
                               const Int_t *hits):AliITSdigit(digits){
     // Creates a simulated SSD digit object
 
-    for(Int_t i=0; i<fgkSssd; i++) {
+    for(Int_t i=0; i<fgkSize; i++) {
        fTracks[i] = tracks[i];
        fHits[i]   = hits[i];
     } // end for i
@@ -85,8 +85,8 @@ void AliITSdigitSSD::Print(ostream *os){
     Int_t i;
 
     AliITSdigit::Print(os);
-    for(i=0; i<fgkSssd; i++) *os <<","<< fTracks[i];
-    for(i=0; i<fgkSssd; i++) *os <<","<< fHits[i];
+    for(i=0; i<fgkSize; i++) *os <<","<< fTracks[i];
+    for(i=0; i<fgkSize; i++) *os <<","<< fHits[i];
 }
 //______________________________________________________________________
 void AliITSdigitSSD::Read(istream *os){
@@ -94,8 +94,8 @@ void AliITSdigitSSD::Read(istream *os){
     Int_t i;
 
     AliITSdigit::Read(os);
-    for(i=0; i<fgkSssd; i++) *os >> fTracks[i];
-    for(i=0; i<fgkSssd; i++) *os >> fHits[i];
+    for(i=0; i<fgkSize; i++) *os >> fTracks[i];
+    for(i=0; i<fgkSize; i++) *os >> fHits[i];
 }
 //______________________________________________________________________
 ostream &operator<<(ostream &os,AliITSdigitSSD &source){

diff --git a/ITS/AliITSdigitSSD.h b/ITS/AliITSdigitSSD.h
index f6a3d5dbbd210e06a5beb48698109d357db94766..34831189c9bf679aa18e6cf0999a2521bc229688 100644 (file)
--- a/ITS/AliITSdigitSSD.h
+++ b/ITS/AliITSdigitSSD.h
@@ -19,31 +19,14 @@ class AliITSdigitSSD: public AliITSdigit {
     AliITSdigitSSD(const Int_t *digits,const Int_t *tracks,const Int_t *hits);
     virtual ~AliITSdigitSSD(){/* destructor */}
     // returns the array size used to store Tracks and Hits
-    static Int_t GetNTracks() {return fgkSssd;}
+    // static Int_t GetNTracks() {return fgkSssd;}
     Int_t  GetSignal() const {/* returns signal*/return fSignal;}
     Int_t  GetStripNumber() const {/* returns strip number*/return fCoord2;}
     //returns 1  when side P and 0 when side N
     Int_t  IsSideP() const {if(fCoord1==0) return 1; else return 0; }
-    // returns pointer to the array of tracks which make this digit
-    virtual Int_t *GetTracks() {return &fTracks[0];}
     // returns the pointer to the array of hits which made this digit
-    virtual Int_t *GetHits() {return &fHits[0];}
-    // returns track number kept in the array element i of fTracks 
-    virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
-    // returns hit number kept in the array element i of fHits 
-    virtual Int_t GetHit(Int_t i) const {return fHits[i];}
     // returns TArrayI of unduplicated track numbers (summed over hits).
     virtual Int_t GetListOfTracks(TArrayI &t);
-    //copy the array trks[fgkSssd] into fTracks
-    virtual void SetTracks(const Int_t *trks){
-       for(Int_t i=0;i<fgkSssd;i++) fTracks[i]=trks[i];}
-    //copy the array hits[fgkSssd] into fHits
-    virtual void SetHits(const Int_t *hits){
-       for(Int_t i=0;i<fgkSssd;i++) fHits[i]=hits[i];}
-    //set array element i of fTracks to trk.
-    virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
-    //set array element i of fHits to hit.
-    virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
     void Print(ostream *os); // Class ascii print function
     void Read(istream *os);  // Class ascii read function
     virtual void Print(Option_t *option="") const {TObject::Print(option);}
@@ -51,14 +34,9 @@ class AliITSdigitSSD: public AliITSdigit {
 
 
  protected:
-    static const Int_t fgkSssd = 10; // size of fTracks and fHits arrays
     
-    // debugging  -- goes to the dictionary
-    Int_t fTracks[fgkSssd]; //[fgkSssd] tracks making this digit 
-    Int_t fHits[fgkSssd];   //[fgkSssd] hits associated to the tracks
-                        // 3 hits temporarily - it will be only 1
     
-    ClassDef(AliITSdigitSSD,2)   // Simulated digit object for SSD
+    ClassDef(AliITSdigitSSD,3)   // Simulated digit object for SSD
 
 };
 // Input and output functions for standard C++ input/output.

diff --git a/ITS/AliITSsimulationSDD.cxx b/ITS/AliITSsimulationSDD.cxx
index 7b60164582b9fb3715761e4843039bf170f8ee10..e5af80cf2018f790c17b0a483fc192017fc02fe4 100644 (file)
--- a/ITS/AliITSsimulationSDD.cxx
+++ b/ITS/AliITSsimulationSDD.cxx
@@ -26,7 +26,6 @@
 #include <TFile.h>
 #include <TRandom.h>
 #include <TROOT.h>
-
 #include "AliITS.h"
 #include "AliITSMapA2.h"
 #include "AliITSRawData.h"
@@ -804,7 +803,8 @@ void AliITSsimulationSDD::ListOfFiredCells(Int_t *arg,Double_t timeAmplitude,
 //____________________________________________
 void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
     // Adds a Digit.
-    Int_t size = AliITSdigitSPD::GetNTracks();
+    Int_t size = AliITSdigit::GetNTracks();
+
     Int_t digits[3];
     Int_t * tracks = new Int_t[size];
     Int_t * hits = new Int_t[size];
@@ -1090,7 +1090,6 @@ AliITSMap*   AliITSsimulationSDD::HitMap(Int_t i){
 //______________________________________________________________________
 void AliITSsimulationSDD::ZeroSuppression(const char *option) {
     // perform the zero suppresion
-
     if (strstr(option,"2D")) {
         //Init2D();              // activate if param change module by module
         Compress2D();
@@ -1410,7 +1409,7 @@ void AliITSsimulationSDD::StoreAllDigits(){
             digits[1] = j;
             digits[2] = signal;
             fITS->AddRealDigit(1,digits);
-        } // end for j
+       } // end for j
     } // end for i
 } 
 //______________________________________________________________________

diff --git a/ITS/AliITSsimulationSPD.cxx b/ITS/AliITSsimulationSPD.cxx
index c99a00cbcc7309ad2ad8d8407b98988a43988cbb..98a1d6a07bb0227b7fea65ae3ca4d18611299dc8 100644 (file)
--- a/ITS/AliITSsimulationSPD.cxx
+++ b/ITS/AliITSsimulationSPD.cxx
@@ -709,7 +709,7 @@ void AliITSsimulationSPD::FrompListToDigits(){
     Int_t j,ix,iz;
     Double_t  electronics;
     Double_t sig;
-    const Int_t    knmaxtrk=AliITSdigitSPD::GetNTracks();
+    const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
     static AliITSdigitSPD dig;
     AliITSCalibrationSPD* res = (AliITSCalibrationSPD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSPD());
     if(GetDebug(1)) Info("FrompListToDigits","()");