SDD digits modified. Both compressed and decompressed ADC values are stored - Tempora...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Feb 2004 16:57:00 +0000 (16:57 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Feb 2004 16:57:00 +0000 (16:57 +0000)
ITS/AliITS.cxx
ITS/AliITSDDLRawData.cxx
ITS/AliITSclustererV2.cxx
ITS/AliITSclustererV2.h
ITS/AliITSdigit.h
ITS/AliITSdigitSDD.cxx
ITS/AliITSdigitSDD.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h

index 554f1b2..d44865f 100644 (file)
@@ -1332,38 +1332,40 @@ void AliITS::AddSimDigit(Int_t id, AliITSdigit *d){
 //______________________________________________________________________
 void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,
                          Int_t *hits,Float_t *charges){
-    //   Add a simulated digit to the list.
-    // Inputs:
-    //      Int_t id        Detector type number.
-    //      Float_t phys    Physics indicator. See AliITSdigits.h
-    //      Int_t *digits   Integer array containing the digits info. See 
-    //                      AliITSdigit.h
-    //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
-    //                      containing the track numbers that contributed to
-    //                      this digit.
-    //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
-    //                      containing the hit numbers, from AliITSmodule, that
-    //                      contributed to this digit.
-    //      Float_t *charge Floating point array of the signals contributed
-    //                      to this digit by each track.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
+  //   Add a simulated digit to the list.
+  // Inputs:
+  //      Int_t id        Detector type number.
+  //      Float_t phys    Physics indicator. See AliITSdigits.h
+  //      Int_t *digits   Integer array containing the digits info. See 
+  //                      AliITSdigit.h
+  //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
+  //                      containing the track numbers that contributed to
+  //                      this digit.
+  //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
+  //                      containing the hit numbers, from AliITSmodule, that
+  //                      contributed to this digit.
+  //      Float_t *charge Floating point array of the signals contributed
+  //                      to this digit by each track.
+  // Outputs:
+  //      none.
+  // Return:
+  //      none.
 
-    TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
-    switch(id){
-    case 0:
-        new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
-        break;
-    case 1:
-        new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
-                                                   hits,charges);
-        break;
-    case 2:
-        new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
-        break;
-    } // end switch id
+  TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
+  AliITSresponseSDD *resp = 0;
+  switch(id){
+  case 0:
+    new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
+    break;
+  case 1:
+    resp = (AliITSresponseSDD*)DetType(1)->GetResponseModel();
+    new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
+                                              hits,charges,resp);
+    break;
+  case 2:
+    new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
+    break;
+  } // end switch id
 }
 //______________________________________________________________________
 void AliITS::MakeTreeC(Option_t *option){
index 0da200d..0afd33d 100644 (file)
@@ -87,7 +87,7 @@ void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod,Int_t modR
       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
       iz=digs->GetCoord1();  // If iz==0, N side and if iz=1 P side
       ix=digs->GetCoord2();  // Strip Numbar
-      is=digs->GetSignal();  // ADC Signal
+      is=digs->GetCompressedSignal();  // ADC Signal
       // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
       if (fVerbose==2)
        ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
@@ -131,7 +131,7 @@ void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR
       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
       iz=digs->GetCoord1();  // Anode
       ix=digs->GetCoord2();  // Time
-      is=digs->GetSignal();  // ADC Signal
+      is=digs->GetCompressedSignal();  // ADC Signal
       if (fVerbose==2)
        ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl;
       //      cout<<"Amplitude value:"<<is<<" Time Bucket:"<<ix<<" Anode:"<<iz<<endl;
index b35ef68..7b8b131 100644 (file)
@@ -36,7 +36,6 @@ AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom) {
 
   fEvent=0;
   fI=0;
-  f8to10SDD=kTRUE;
 
   Int_t mmax=geom->GetIndexMax();
   if (mmax>2200) {
@@ -93,27 +92,6 @@ AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom) {
   fTanN=0.0075;
 }
 
-Int_t AliITSclustererV2::Convert8to10(Int_t signal) {
-    // Taken from AliITSsimulationSDD.cxx
-    // Undo the lossive 10 to 8 bit compression.
-    // code from Davide C. and Albert W.
-    if (signal < 0 || signal > 255) {
-        ::Warning("Convert8to10","out of range signal=%d",signal);
-        return 0;
-    } // end if signal <0 || signal >255
-
-    if (signal < 128) return signal;
-    if (signal < 192) {
-        if (TMath::Odd(signal)) return (128+((signal-128)<<1));
-        else  return (128+((signal-128)<<1)+1);
-    } // end if signal < 192
-    if (signal < 224) {
-        if (TMath::Odd(signal)) return (256+((signal-192)<<3)+3);
-        else  return (256+((signal-192)<<3)+4);
-    } // end if signal < 224
-    if (TMath::Odd(signal)) return (512+((signal-224)<<4)+7);
-    return (512+((signal-224)<<4)+8);
-}
 
 Int_t AliITSclustererV2::Digits2Clusters(TTree *dTree, TTree *cTree) {
   //------------------------------------------------------------
@@ -811,7 +789,6 @@ FindClustersSDD(const TClonesArray *digits, TClonesArray *clusters) {
      Int_t z=d->GetCoord1()+1;   //z
      Int_t q=d->GetSignal();
 
-     if (f8to10SDD) q=Convert8to10(q);
 
      if (z <= fNzSDD) {
        bins[0][y*kNzBins+z].SetQ(q);
index 8f030f3..f6e469b 100644 (file)
@@ -22,7 +22,7 @@ class AliITSRawStream;
 
 class AliITSclustererV2 : public TObject {
 public:
-  AliITSclustererV2(){ fEvent=0; fI=0; f8to10SDD=kTRUE;}
+  AliITSclustererV2(){ fEvent=0; fI=0;}
   AliITSclustererV2(const AliITSgeom *geom);
 
   void SetEvent(Int_t event) { fEvent=event; }
@@ -32,8 +32,6 @@ public:
   void FindClustersSPD(AliITSRawStream* input, TClonesArray** clusters);
   void FindClustersSDD(const TClonesArray *dig, TClonesArray *cls);
   void FindClustersSDD(AliITSRawStream* input, TClonesArray** clusters);
-  void Set8to10SDD(Bool_t flag=kTRUE) {f8to10SDD=flag;}
-  static Int_t Convert8to10(Int_t signal);
   void FindClustersSSD(const TClonesArray *dig, TClonesArray *cls);
   void FindClustersSSD(AliITSRawStream* input, TClonesArray** clusters);
 
@@ -118,7 +116,6 @@ private:
   Float_t fHwSDD;         //half width of the SDD detector
   Float_t fHlSDD;         //half length of the SDD detector
   Float_t fYoffSDD;       //some delay in the drift channel   
-  Bool_t f8to10SDD;       // 8 -> 10 conversion flag
 
   //SSD related values:
   Int_t fLastSSD1;        //index of the last SSD1 detector   
index cb5ef8c..ca1cd88 100644 (file)
@@ -40,6 +40,7 @@ class AliITSdigit: public TObject  {
     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
+    virtual Int_t GetCompressedSignal() const {return GetSignal();} // overloaded in AliITSdigitSDD
     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
index ec8b697..35a55c1 100644 (file)
@@ -14,6 +14,7 @@
  **************************************************************************/
 
 #include <AliITSdigitSDD.h>
+#include <AliITSresponseSDD.h>
 #include <TArrayI.h>
 #include <TArrayF.h>
 #include <TMath.h>
@@ -27,6 +28,8 @@
 ///////////////////////////////////////////////////////////////////
 
 ClassImp(AliITSdigitSDD)
+
+
 //______________________________________________________________________
 AliITSdigitSDD::AliITSdigitSDD():AliITSdigit(){
     // default constructor, zero coordinates and set array
@@ -38,6 +41,7 @@ AliITSdigitSDD::AliITSdigitSDD():AliITSdigit(){
     for(i=0;i<fgkSsdd;i++) fHits[i]   = -1;
     fPhysics = 0;
     for(i=0;i<fgkSsdd;i++) fTcharges[i] = 0;
+    SetSignalExpanded(-1000);
 }
 //________________________________________________________________________
 AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits):
@@ -45,21 +49,49 @@ AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits):
     // Creates a simulated SDD digit object to be updated
 
     fPhysics = phys;
+    SetSignalExpanded(-1000);
 }
+
+//________________________________________________________________________
+void AliITSdigitSDD::InitObject(Float_t phys,const Int_t *tracks,
+                          const Int_t *hits,const Float_t *charges){
+  // Protected function used by standard constructors
+  fPhysics = phys;
+  for(Int_t i=0; i<fgkSsdd; i++) {
+    fTcharges[i] = charges[i];
+    fTracks[i]   = tracks[i];
+    fHits[i]     = hits[i];
+  }
+}
 //_____________________________________________________________________________
 AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits,
                               const Int_t *tracks,const Int_t *hits,
                               const Float_t *charges):
     AliITSdigit(digits){
-    // Creates a simulated SDD digit object
+  // standard constructor
+  InitObject(phys,tracks,hits,charges);
+  SetSignalExpanded(-1000);
+}
+//_____________________________________________________________________________
+AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
+    const Int_t *tracks,const Int_t *hits,const Float_t *charges, Int_t sige):
+    AliITSdigit(digits) {
+  //constructor setting also fSignalExpanded
+  InitObject(phys,tracks,hits,charges);
+  SetSignalExpanded(sige);
+}
 
-    fPhysics = phys;
-    for(Int_t i=0; i<fgkSsdd; i++) {
-       fTcharges[i] = charges[i];
-       fTracks[i]   = tracks[i];
-       fHits[i]     = hits[i];
-    } // end for i
+//_____________________________________________________________________________
+AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
+    const Int_t *tracks,const Int_t *hits,const Float_t *charges,
+    AliITSresponseSDD* resp):
+    AliITSdigit(digits) {
+  //constructor setting fSignalExpanded through AliITSresponseSDD
+  InitObject(phys,tracks,hits,charges);
+  SetSignalExpanded(resp->Convert8to10(digits[2]));
 }
+
 //______________________________________________________________________
 Int_t AliITSdigitSDD::GetListOfTracks(TArrayI &t,TArrayF &c){
     // Fills the TArrayI t with the tracks found in fTracks removing
@@ -123,6 +155,8 @@ Int_t AliITSdigitSDD::GetListOfTracks(TArrayI &t,TArrayF &c){
     //
     return n;
 }
+
+
 //______________________________________________________________________
 void AliITSdigitSDD::Print(ostream *os){
     //Standard output format for this class
@@ -133,6 +167,7 @@ void AliITSdigitSDD::Print(ostream *os){
     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];
+    *os <<","<< fSignalExpanded;
 }
 //______________________________________________________________________
 void AliITSdigitSDD::Read(istream *os){
@@ -144,6 +179,7 @@ void AliITSdigitSDD::Read(istream *os){
     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];
+    *os >>fSignalExpanded;
 }
 //______________________________________________________________________
 ostream &operator<<(ostream &os,AliITSdigitSDD &source){
index 3fd85c9..9e054b7 100644 (file)
@@ -5,16 +5,25 @@
 
 #include <AliITSdigit.h>
 
+class AliITSresponseSDD;
+
 //______________________________________________________________________
 class AliITSdigitSDD: public AliITSdigit {
 
  public:
     AliITSdigitSDD(); //default creator
-    //standard creator  with digits and "phys"
+    //standard c.tor  with digits and "phys"
     AliITSdigitSDD(Float_t phys,const Int_t *digits);
-    //standard creator with digits, tracls, hits, "phys", and charge
+    //standard c.tor with digits, tracls, hits, "phys", and charge
     AliITSdigitSDD( Float_t phys,const Int_t *digits,const Int_t *tracks,
                    const Int_t *hits,const Float_t *charges);
+    //constructor setting also fSignalExpanded
+    AliITSdigitSDD( Float_t phys,const Int_t *digits,const Int_t *tracks,
+                   const Int_t *hits,const Float_t *charges, Int_t sige);
+    //constructor setting fSignalExpanded through AliITSresponseSDD
+    AliITSdigitSDD( Float_t phys,const Int_t *digits,const Int_t *tracks,
+                   const Int_t *hits,const Float_t *charges, 
+                    AliITSresponseSDD *resp);
     virtual ~AliITSdigitSDD(){/* destructor*/}
     // returns the array size used to store Tracks and Hits
     static Int_t GetNTracks() {return fgkSsdd;}
@@ -22,6 +31,8 @@ class AliITSdigitSDD: public AliITSdigit {
     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 
@@ -40,10 +51,13 @@ class AliITSdigitSDD: public AliITSdigit {
     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;}
     void Print(ostream *os); // Class ascii print function
     void Read(istream *os);  // Class ascii read function
 
  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
@@ -52,8 +66,8 @@ class AliITSdigitSDD: public AliITSdigit {
                             // 3 hits temporarily - it will be only 1
     Float_t fTcharges[fgkSsdd];   //[fgkSsdd] charge per track making this digit 
     Float_t fPhysics;       // signal particles contribution to signal
-
-    ClassDef(AliITSdigitSDD,2)   // Simulated digit object for SDD
+    Int_t fSignalExpanded;  // 10 bit signal
+    ClassDef(AliITSdigitSDD,3)   // Simulated digit object for SDD
 
 };
 // Input and output functions for standard C++ input/output.
index 7578ac7..ad29999 100644 (file)
@@ -138,6 +138,34 @@ AliITSresponseSDD::~AliITSresponseSDD() {
 
   if(fGaus) delete fGaus;
 }
+
+//______________________________________________________________________
+Int_t AliITSresponseSDD::Convert8to10(Int_t signal) const {
+  // Undo the lossive 10 to 8 bit compression.
+  // code from Davide C. and Albert W.
+  if(Do10to8()){  // kTRUE if the compression is active
+    if (signal < 0 || signal > 255) {
+      Warning("Convert8to10","out of range signal=%d",signal);
+      return 0;
+    } // end if signal <0 || signal >255
+
+    if (signal < 128) return signal;
+    if (signal < 192) {
+      if (TMath::Odd(signal)) return (128+((signal-128)<<1));
+      else  return (128+((signal-128)<<1)+1);
+    } // end if signal < 192
+    if (signal < 224) {
+      if (TMath::Odd(signal)) return (256+((signal-192)<<3)+3);
+      else  return (256+((signal-192)<<3)+4);
+    } // end if signal < 224
+    if (TMath::Odd(signal)) return (512+((signal-224)<<4)+7);
+    return (512+((signal-224)<<4)+8);
+  }
+  else {  
+    return signal;
+  }
+}
+
 //______________________________________________________________________
 void AliITSresponseSDD::SetCompressParam(Int_t  cp[8]){
   // set compression param
index 7ec6aa0..c4734cc 100644 (file)
@@ -88,6 +88,7 @@ class AliITSresponseSDD : public AliITSresponse {
        if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);}
    
 //Declaration of member functions peculiar to this class
+    Int_t Convert8to10(Int_t signal) const; //undo 10 to 8 bit SDD compresion
     void  SetNoiseAfterElectronics(Float_t n=2.38){
        // Noise after electronics (ADC units)
        // 2.36 for ALICE from beam test measurements 2001
index 9ed5ea0..6700205 100644 (file)
@@ -817,7 +817,6 @@ void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
     Float_t phys;
     Float_t * charges = new Float_t[size];
 
-//    if( fResponse->Do10to8() ) signal = Convert8to10( signal ); 
     digits[0] = i;
     digits[1] = j;
     digits[2] = signal;
@@ -1088,6 +1087,7 @@ void AliITSsimulationSDD::CompressionParam(Int_t i,Int_t &db,Int_t &tl){
         } else {
             db=fD[0]; tl=fT1[0]; 
         } // end if size <=2 && i>=fNofMaps/2
+    //    Warning("CompressionParam","\n Size= %d . Values i=%d ; db= %d ; tl= %d",size,i,db,tl);
     } // end if size > 2
 }
 //______________________________________________________________________
@@ -1153,27 +1153,6 @@ Int_t AliITSsimulationSDD::Convert10to8(Int_t signal) const {
     if (signal < 1024) return (224+((signal-512)>>4));
     return 0;
 }
-//______________________________________________________________________
-Int_t AliITSsimulationSDD::Convert8to10(Int_t signal) const {
-    // Undo the lossive 10 to 8 bit compression.
-    // code from Davide C. and Albert W.
-    if (signal < 0 || signal > 255) {
-        Warning("Convert8to10","out of range signal=%d",signal);
-        return 0;
-    } // end if signal <0 || signal >255
-
-    if (signal < 128) return signal;
-    if (signal < 192) {
-        if (TMath::Odd(signal)) return (128+((signal-128)<<1));
-        else  return (128+((signal-128)<<1)+1);
-    } // end if signal < 192
-    if (signal < 224) {
-        if (TMath::Odd(signal)) return (256+((signal-192)<<3)+3);
-        else  return (256+((signal-192)<<3)+4);
-    } // end if signal < 224
-    if (TMath::Odd(signal)) return (512+((signal-224)<<4)+7);
-    return (512+((signal-224)<<4)+8);
-}
 
 /*
 //______________________________________________________________________
@@ -1491,7 +1470,6 @@ void AliITSsimulationSDD::StoreAllDigits(){
         for (j=0; j<fMaxNofSamples; j++) {
             Int_t signal=(Int_t)(fHitMap2->GetSignal(i,j));
             if(do10to8) signal = Convert10to8(signal);
-            if(do10to8) signal = Convert8to10(signal); 
             digits[0] = i;
             digits[1] = j;
             digits[2] = signal;
index 57981c1..0863cd2 100644 (file)
@@ -62,7 +62,6 @@ class AliITSsimulationSDD : public AliITSsimulation {
     void CompressionParam(Int_t i, Int_t &db, Int_t &tl);
 
     virtual Int_t Convert10to8(Int_t signal) const;// 10 to 8 bit SDD compresion
-    virtual Int_t Convert8to10(Int_t signal) const;//undo 10 to 8 bit SDD compresion
     virtual void ZeroSuppression(const char *opt); // Apply zero suppresion
     virtual void Init2D();   // initiilzes 2D compresion algorithm
     virtual void Compress2D(); // Applies 2D compresion algorithm