Changes needed to properly add and subtract the SDD low threshold with data compresse...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Apr 2008 17:14:43 +0000 (17:14 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Apr 2008 17:14:43 +0000 (17:14 +0000)
15 files changed:
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSCalibrationSDD.h
ITS/AliITSClusterFinderV2SDD.cxx
ITS/AliITSDDLRawData.C
ITS/AliITSDetTypeSim.cxx
ITS/AliITSDetTypeSim.h
ITS/AliITSRawStreamSDD.cxx
ITS/AliITSRawStreamSDD.h
ITS/AliITSdigitSDD.cxx
ITS/AliITSdigitSDD.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h

index b8b9aae..8b03e10 100644 (file)
@@ -1052,7 +1052,7 @@ void AliITS::AddSimDigit(Int_t branch, AliITSdigit *d){
 }
 //______________________________________________________________________
 void AliITS::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,Int_t *tracks,
-                         Int_t *hits,Float_t *charges){
+                         Int_t *hits,Float_t *charges, Int_t sigexpanded){
   //   Add a simulated digit to the list.
   // Inputs:
   //      Int_t id        Detector type number.
@@ -1076,7 +1076,7 @@ void AliITS::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,Int_t *tracks,
       Error("AddSimDigit","fDetTypeSim is 0!");
       return;
     }
-    fDetTypeSim->AddSimDigit(branch,phys,digits,tracks,hits,charges);
+    fDetTypeSim->AddSimDigit(branch,phys,digits,tracks,hits,charges,sigexpanded);
 
 }
 //______________________________________________________________________
index 4a68618..400123d 100644 (file)
@@ -104,8 +104,6 @@ class AliITS : public AliDetector {
    // Trigger
     virtual AliTriggerDetector* CreateTriggerDetector() const
        { return new AliITSTrigger(); }
-   
-    //   TClonesArray* GetSDigits() const { return fDetTypeSim->GetSDigits();}
 
     AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
     virtual void UpdateInternalGeometry();
@@ -130,7 +128,8 @@ class AliITS : public AliDetector {
     virtual void AddRealDigit(Int_t branch, Int_t *digits);
     virtual void AddSimDigit(Int_t branch, AliITSdigit *d);
     virtual void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
-                    Int_t* tracks,Int_t *hits,Float_t* trkcharges);
+                    Int_t* tracks,Int_t *hits,Float_t* trkcharges,
+                    Int_t sigexpanded=-1000);
     TObjArray* GetDigits()  const {return fDetTypeSim->GetDigits();}
     Int_t* GetNDigitArray() const {return fDetTypeSim->GetNDigitArray();}
     TClonesArray *DigitsAddress(Int_t id) {
index cfe7093..d71f5d7 100644 (file)
@@ -161,7 +161,7 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     }
     virtual void SetParamOptions(const char *opt1,const char *opt2) {((AliITSresponseSDD*)fResponse)->SetParamOptions(opt1,opt2);}
     virtual void GetParamOptions(char *opt1,char *opt2) const {((AliITSresponseSDD*)fResponse)->ParamOptions(opt1,opt2);}
-    virtual Bool_t Do10to8() const {return ((AliITSresponseSDD*)fResponse)->Do10to8();}
+
     virtual void SetZeroSupp (const char *opt) {((AliITSresponseSDD*)fResponse)->SetZeroSupp(opt);} 
     virtual const char *GetZeroSuppOption() const {return ((AliITSresponseSDD*)fResponse)->ZeroSuppOption();}
     virtual void SetNSigmaIntegration(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetNSigmaIntegration(p1);}
@@ -169,7 +169,7 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     virtual void SetNLookUp(Int_t p1) {((AliITSresponseSDD*)fResponse)->SetNLookUp(p1);}
     virtual Int_t GetGausNLookUp() const {return ((AliITSresponseSDD*)fResponse)->GausNLookUp();}
     virtual Float_t GetGausLookUp(Int_t i) const {return ((AliITSresponseSDD*)fResponse)->GausLookUp(i);}
-    virtual Int_t Convert8to10(Int_t signal) const {return ((AliITSresponseSDD*)fResponse)->Convert8to10(signal);}
+
     virtual void  SetJitterError(Double_t jitter=20) {((AliITSresponseSDD*)fResponse)->SetJitterError(jitter);}
     virtual Float_t GetJitterError() const {return ((AliITSresponseSDD*)fResponse)->JitterError();}
     virtual Float_t GetDriftPath(Float_t time, Float_t xAnode) const {return time*GetDriftSpeedAtAnode(xAnode);}
@@ -177,7 +177,7 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     virtual Float_t GetThresholdAnode(Int_t anode,Int_t nsigma=3) const {
       return nsigma*fNoiseAfterEl[anode];}
 
-    virtual void  SetDo10to8(Bool_t bitcomp=kTRUE) {((AliITSresponseSDD*)fResponse)->SetDo10to8(bitcomp);}
+
  protected:
 
 
index ccb83f7..9c49f28 100644 (file)
@@ -73,8 +73,7 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(TClonesArray *digits) {
     AliError(Form("Calibration object not present for SDD module %d\n",fModule));
     return;
   }
-  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++) {
@@ -84,8 +83,8 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(TClonesArray *digits) {
      Int_t iSide=0;
      if (ian >= nAnodes) iSide=1;    
      Float_t gain=cal->GetChannelGain(ian);
-     Float_t charge=d->GetSignal();
-     if(strstr(option,"ZS")) charge+=(Float_t)cal->GetZSLowThreshold(iSide);
+     Float_t charge=d->GetSignal(); // returns expanded signal 
+                                    // (10 bit, low threshold already added)
      Float_t baseline = cal->GetBaseline(ian);
      if(charge>baseline) charge-=baseline;
      else charge=0;
@@ -277,6 +276,24 @@ void AliITSClusterFinderV2SDD::RawdataToClusters(AliRawReader* rawReader,TClones
   AliITSRawStreamSDD inputSDD(rawReader);
   AliITSDDLModuleMapSDD *ddlmap=(AliITSDDLModuleMapSDD*)fDetTypeRec->GetDDLModuleMapSDD();
   inputSDD.SetDDLModuleMap(ddlmap);
+  for(Int_t iddl=0; iddl<AliITSDDLModuleMapSDD::GetNDDLs(); iddl++){
+    for(Int_t icar=0; icar<AliITSDDLModuleMapSDD::GetNModPerDDL();icar++){
+      Int_t iMod=ddlmap->GetModuleNumber(iddl,icar);
+      if(iMod==-1) continue;
+      AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(iMod);
+      if(cal==0){
+       AliError(Form("Calibration object not present for SDD module %d\n",iMod));
+       continue;
+      }
+      AliITSresponseSDD* res  = (AliITSresponseSDD*)cal->GetResponse();
+      const char *option=res->ZeroSuppOption();
+      if(strstr(option,"ZS")){ 
+       for(Int_t iSid=0; iSid<2; iSid++) inputSDD.SetZeroSuppLowThreshold(iMod-240,iSid,cal->GetZSLowThreshold(iSid));
+      }else{
+       for(Int_t iSid=0; iSid<2; iSid++) inputSDD.SetZeroSuppLowThreshold(iMod-240,iSid,0);
+      }
+    }
+  }
   FindClustersSDD(&inputSDD,clusters);
 
 }
@@ -335,12 +352,9 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(AliITSRawStream* input,
        AliError(Form("Calibration object not present for SDD module %d\n",iModule));
        continue;
       }
-      AliITSresponseSDD* res  = (AliITSresponseSDD*)cal->GetResponse();
-      const char *option=res->ZeroSuppOption();
       Float_t charge=input->GetSignal();
       Int_t chan=input->GetCoord1()+nAnodes*iSide;
       Float_t gain=cal->GetChannelGain(chan);
-      if(strstr(option,"ZS")) charge+=(Float_t)cal->GetZSLowThreshold(iSide);
       Float_t baseline = cal->GetBaseline(chan);
       if(charge>baseline) charge-=baseline;
       else charge=0;
@@ -370,8 +384,8 @@ void AliITSClusterFinderV2SDD::FindClustersSDD(AliITSRawStream* input,
 void AliITSClusterFinderV2SDD::NoiseSuppress(Int_t k, Int_t sid,Int_t nzBins, AliBin* bins, AliITSCalibrationSDD* cal) const {
   // applies zero suppression using the measured noise of each anode
   // threshold values from ALICE-INT-1999-28 V10
-  Float_t factL=2.2; 
-  Float_t factH=4.0;
+  Float_t xfactL=2.2; 
+  Float_t xfactH=4.0;
   //
 
   Int_t iAn=(k%nzBins)-1;
@@ -383,12 +397,12 @@ void AliITSClusterFinderV2SDD::NoiseSuppress(Int_t k, Int_t sid,Int_t nzBins, Al
   if(iAn>1) noisem1=cal->GetNoiseAfterElectronics(iAn-1);
   Float_t noisep1=noise;
   if(iAn<511) noisep1=cal->GetNoiseAfterElectronics(iAn+1);
-  Float_t tL=noise*factL;
-  Float_t tH=noise*factH;
-  Float_t tLp1=noisep1*factL;
-  Float_t tHp1=noisep1*factH;
-  Float_t tLm1=noisem1*factL;
-  Float_t tHm1=noisem1*factH;
+  Float_t tL=noise*xfactL;
+  Float_t tH=noise*xfactH;
+  Float_t tLp1=noisep1*xfactL;
+  Float_t tHp1=noisep1*xfactH;
+  Float_t tLm1=noisem1*xfactL;
+  Float_t tHm1=noisem1*xfactH;
   Float_t cC=bins[k].GetQ();
   if(cC<=tL){
     bins[k].SetQ(0);
index e7dbe27..57f7ff1 100644 (file)
@@ -6,12 +6,6 @@
 #include "AliITS.h"
 #endif
 
-/*
-Before running this macro it is necessary to comment the following line of the method
-AddDigit in the class AliITSsimulationSDD
-//if( fResponse->Do10to8() ) signal = Convert8to10( signal ); 
-In this way the amplitude value for signal coming from SDD takes only 8 bits and not 10.
-*/
 //DigitsFile is the input file that contains digits
 
 void AliITSDDLRawData(Int_t eventNumber=0){
index a01e44e..c627147 100644 (file)
@@ -832,20 +832,18 @@ void AliITSDetTypeSim::AddSimDigit(Int_t branch, AliITSdigit* d){
 }
 //______________________________________________________________________
 void AliITSDetTypeSim::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,
-                                  Int_t *tracks,Int_t *hits,Float_t *charges){
+                                  Int_t *tracks,Int_t *hits,Float_t *charges, 
+                                  Int_t sigexpanded){
   //   Add a simulated digit to the list.
 
   TClonesArray &ldigits = *((TClonesArray*)fDigits->At(branch));
-  AliITSCalibrationSDD *resp = 0;
   switch(branch){
   case 0:
     new(ldigits[fNDigits[branch]++]) AliITSdigitSPD(digits,tracks,hits);
     break;
   case 1:
-    resp = (AliITSCalibrationSDD*)GetCalibrationModel(
-       GetITSgeom()->GetStartSDD());
     new(ldigits[fNDigits[branch]++]) AliITSdigitSDD(phys,digits,tracks,
-                                                  hits,charges,resp);
+                                                  hits,charges,sigexpanded);
     break;
   case 2:
     new(ldigits[fNDigits[branch]++]) AliITSdigitSSD(digits,tracks,hits);
index ab1e0de..4c74674 100644 (file)
@@ -85,7 +85,8 @@ class AliITSDetTypeSim : public TObject {
     virtual void AddRealDigit(Int_t branch, Int_t *digits);
     virtual void AddSimDigit(Int_t branch, AliITSdigit *d);
     virtual void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
-                            Int_t* tracks,Int_t *hits,Float_t* trkcharges);
+                            Int_t* tracks,Int_t *hits,Float_t* trkcharges,
+                            Int_t sigexpanded=-1000);
     virtual void SetDigitClassName(Int_t i, Char_t* name) {
        fDigClassName[i]=name;}
     Char_t* GetDigitClassName(Int_t i) const {return fDigClassName[i];}
index 3d53c04..31b1726 100644 (file)
@@ -47,6 +47,10 @@ fResetSkip(0)
   fDDLModuleMap=new AliITSDDLModuleMapSDD();
   fDDLModuleMap->SetDefaultMap();
   Reset();
+  for(Int_t im=0;im<kSDDModules;im++){
+    fLowThresholdArray[im][0]=0;
+    fLowThresholdArray[im][1]=0;
+  }
   for(Int_t i=0;i<kFifoWords;i++) fNfifo[i]=0;
   for(Int_t i=0;i<kDDLsNumber;i++) fSkip[i]=0;
   fRawReader->Reset();
@@ -128,7 +132,7 @@ Bool_t AliITSRawStreamSDD::Next()
 
   while (kTRUE) {
     if(fResetSkip==0){
-      Bool_t kSkip = ResetSkip(ddln);
+      Bool_t kSkip = SkipHeaderWord();
       fResetSkip=1;
       if(!kSkip) return kSkip;
     }
@@ -144,7 +148,6 @@ Bool_t AliITSRawStreamSDD::Next()
 
       fChannel = -1;
       if((fData >> 16) == 0x7F00){ // jitter word
-       for(Int_t i=0;i<kDDLsNumber;i++){fSkip[i]=0;}
        fResetSkip=0;
        fEndWords=0;
        continue;
@@ -217,7 +220,7 @@ Bool_t AliITSRawStreamSDD::Next()
          fTimeBin[fCarlosId][fChannel] = 0;
          fAnode[fCarlosId][fChannel]++;
        } else {                                   // ADC signal data
-         fSignal = DecompAmbra(data + (1 << fChannelCode[fCarlosId][fChannel]) + fLowThreshold[fChannel]);
+         fSignal = DecompAmbra(data + (1 << fChannelCode[fCarlosId][fChannel]) + fLowThresholdArray[fModuleID-kSPDModules][fChannel]);
          fCoord1 = fAnode[fCarlosId][fChannel];
          fCoord2 = fTimeBin[fCarlosId][fChannel];
          fTimeBin[fCarlosId][fChannel]++;
@@ -250,18 +253,12 @@ void AliITSRawStreamSDD::Reset(){
 }
 
 //______________________________________________________________________
-Bool_t AliITSRawStreamSDD::ResetSkip(Int_t ddln){
+Bool_t AliITSRawStreamSDD::SkipHeaderWord(){
   // skip the 1 DDL header word = 0xffffffff
-  Bool_t startCount=kFALSE;
-  while (fSkip[ddln] < 1) {
-    if (!fRawReader->ReadNextInt(fData)) { 
-      return kFALSE;
-    }
-    if(fData==0xFFFFFFFF) startCount=kTRUE;
-    //printf("%x\n",fData);
+  while (kTRUE) {
+    if (!fRawReader->ReadNextInt(fData)) return kFALSE;    
     if ((fData >> 30) == 0x01) continue;  // JTAG word
-    if(startCount) fSkip[ddln]++;
+    if(fData==0xFFFFFFFF) return kTRUE;
   }
-  return kTRUE;
 }
 
index 6747a27..d9fcf52 100644 (file)
@@ -34,24 +34,28 @@ class AliITSRawStreamSDD: public AliITSRawStream {
     virtual Int_t    GetEventId() const {return fEventId;}
 
     virtual void SetDDLModuleMap(AliITSDDLModuleMapSDD* ddlsdd){fDDLModuleMap->SetDDLMap(ddlsdd);}
-    virtual void     SetLowCarlosThreshold(Int_t th, Int_t i) 
+    virtual void     SetLowCarlosThreshold(Int_t th, Int_t i)
       {fLowThreshold[i]=th;}
+    virtual void     SetZeroSuppLowThreshold(Int_t iMod, Int_t iSid, Int_t th) 
+      {fLowThresholdArray[iMod][iSid]=th;}
     virtual void     SetNCarlos(Int_t nC=12){fNCarlos=nC;}
     Int_t   GetModuleNumber(UInt_t iDDL, UInt_t iModule) const {
       return fDDLModuleMap->GetModuleNumber(iDDL,iModule);
     }
     virtual void     Reset(); 
-    virtual Bool_t   ResetSkip(Int_t ddln); 
 
-    enum {kDDLsNumber = 24};      // number of DDLs in SDD
-    enum {kModulesPerDDL = 12};   // number of modules in each DDL 
+    enum {kSDDModules = 260};      // number of SDD modules
+    enum {kSPDModules = 240};      // number of SPD modules (used as offset)
+    enum {kDDLsNumber = 24};       // number of DDLs in SDD
+    enum {kModulesPerDDL = 12};    // number of modules in each DDL 
     enum {kCarlosWords = 12};      // number of FIFOCARLOS Words
-    enum {kFifoWords =  4};      // number of FIFO Words
+    enum {kFifoWords =  4};        // number of FIFO Words
     enum ESDDRawStreamError { 
       kDataError = 1,
       kDataFormatErr = 2
     };
   protected:
+    virtual Bool_t   SkipHeaderWord(); 
     virtual UInt_t   ReadBits();
     virtual Int_t    DecompAmbra(Int_t value) const;
 
@@ -59,7 +63,7 @@ class AliITSRawStreamSDD: public AliITSRawStream {
 
     AliITSDDLModuleMapSDD* fDDLModuleMap; // mapping DDL/module -> module number 
     UInt_t           fData;         // data read for file
-    Int_t            fSkip[kDDLsNumber];// number of skipped words
+    Int_t            fSkip[kDDLsNumber];// obsolete -- needed to compile AliITSRawStreamSDDv2
     Int_t            fEventId;      // event ID from header
     Int_t            fCarlosId;     // carlos ID
     Int_t            fChannel;      // current channel
@@ -69,7 +73,8 @@ class AliITSRawStreamSDD: public AliITSRawStream {
     UInt_t           fChannelCode[kModulesPerDDL][2];// current channel code
     Bool_t           fReadCode[kModulesPerDDL][2];   // next bits are code or data
     UInt_t           fReadBits[kModulesPerDDL][2];   // number of bits to read
-    Int_t            fLowThreshold[2]; // low Carlos threshold
+    Int_t            fLowThresholdArray[kSDDModules][2]; // array with low thresholds for all modules
+    Int_t            fLowThreshold[2];    // obsolete -- needed to compile AliITSRawStreamSDDv2
     Int_t            fNCarlos;         // number of Carlos 
     Int_t            fNfifo[kFifoWords];  // FIFO number
     Int_t            fTimeBin[kModulesPerDDL][2];  // current timebin [ncarlos][nchannels]
@@ -80,7 +85,7 @@ class AliITSRawStreamSDD: public AliITSRawStream {
     Int_t            fICountFoot[kModulesPerDDL]; // counter for carlos footer words
     Int_t            fEndWords;      //number of 3f1f1f1f
     Int_t            fResetSkip;     //if it is 0, the ResetSkip Funcion is called
-    ClassDef(AliITSRawStreamSDD, 7) // class for reading ITS SDD raw digits
+    ClassDef(AliITSRawStreamSDD, 8) // class for reading ITS SDD raw digits
 };
 
 #endif
index f77196e..bf3a9a3 100644 (file)
@@ -15,7 +15,6 @@
 
 #include <AliITSdigitSDD.h>
 #include <AliITSCalibrationSDD.h>
-#include <AliITSresponseSDD.h>
 #include <TArrayI.h>
 #include <TArrayF.h>
 
@@ -93,19 +92,6 @@ fSignalExpanded(0){
 }
 
 //_____________________________________________________________________________
-AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
-    const Int_t *tracks,const Int_t *hits,const Float_t *charges,
-    AliITSCalibrationSDD* resp): AliITSdigit(digits),
-fPhysics(0),
-fSignalExpanded(0){
-
-  //constructor setting fSignalExpanded through AliITSCalibrationSDD
-  InitObject(phys,tracks,hits,charges);
-  AliITSresponseSDD* pd = (AliITSresponseSDD*)resp->GetResponse();
-  SetSignalExpanded(pd->Convert8to10(digits[2]));
-}
-
-//______________________________________________________________________
 Int_t AliITSdigitSDD::GetListOfTracks(TArrayI &t,TArrayF &c){
 
     // Fills the TArrayI t with the tracks found in fTracks removing
index 15e790c..296cb61 100644 (file)
@@ -22,10 +22,6 @@ class AliITSdigitSDD: public AliITSdigit {
     //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 AliITSCalibrationSDD
-    AliITSdigitSDD( Float_t phys,const Int_t *digits,const Int_t *tracks,
-                   const Int_t *hits,const Float_t *charges, 
-                    AliITSCalibrationSDD *resp);
     virtual ~AliITSdigitSDD(){/* destructor*/}
     // returns the array size used to store Tracks and Hits
     virtual Int_t GetSignal() const {return fSignalExpanded;}
index a96ac62..e1d4dd9 100644 (file)
@@ -57,7 +57,6 @@ fMaxAdc(fgkMaxAdcDefault),
 fNsigmas(fgkNsigmasDefault),
 fGaus(),
 fNcomps(fgkNcompsDefault),
-fBitComp(kFALSE),
 fOption(),
 fParam1(),
 fParam2() {
@@ -72,7 +71,6 @@ fParam2() {
   SetChargeLoss(fgkfChargeLossDefault);
   SetParamOptions(fgkParam1Default.Data(),fgkParam2Default.Data());
   SetZeroSupp(fgkOptionDefault);
-  SetDo10to8();
   SetOutputOption();
 }
 
@@ -84,34 +82,6 @@ AliITSresponseSDD::~AliITSresponseSDD() {
 }
 
 
-//______________________________________________________________________
-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::SetNLookUp(Int_t p1){
   // Set number of sigmas over which cluster disintegration is performed
index 57ca829..f64466d 100644 (file)
@@ -56,8 +56,6 @@ class AliITSresponseSDD : public AliITSresponse {
     virtual void   ParamOptions(char *opt1,char *opt2) const {// options
        strcpy(opt1,fParam1.Data()); strcpy(opt2,fParam2.Data());}
  
-    virtual Bool_t Do10to8() const {// get 10 to 8 compression option
-       return fBitComp;}
     void    SetZeroSupp (const char *opt) {
        // Zero-suppression option - could be 1D, 2D or non-ZS 
        fOption=opt;}
@@ -78,16 +76,11 @@ class AliITSresponseSDD : public AliITSresponse {
       if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);
     }
    
-    Int_t Convert8to10(Int_t signal) const; //undo 10 to 8 bit SDD compresion
-
     void  SetJitterError(Float_t jitter=20) {
        // set Jitter error (20 um for ALICE from beam test measurements 2001)
        fJitterError=jitter;}
     Float_t  JitterError() const {// set Jitter error
        return fJitterError;}
-    void  SetDo10to8(Bool_t bitcomp=kTRUE) {
-       // set the option for 10 to 8 bit compression
-       fBitComp = bitcomp;}
 
  protected:
 
@@ -117,7 +110,6 @@ class AliITSresponseSDD : public AliITSresponse {
                           // is performed
     TArrayF   *fGaus;          // Gaussian lookup table for signal generation
     Int_t      fNcomps;        // Number of samplings along the gaussian
-    Bool_t     fBitComp;       // 10 to 8 bit compression option
     TString    fOption;        // Zero-suppresion option (1D, 2D or none)
     TString    fParam1;        // Read baselines from file option
     TString    fParam2;        // Read compression algo thresholds from file
index bc38771..c379613 100644 (file)
@@ -630,7 +630,7 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
 }
 
 //____________________________________________
-void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
+void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signalc, Int_t signale) {
   // Adds a Digit.
   Int_t size = AliITSdigit::GetNTracks();
 
@@ -642,7 +642,7 @@ void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
 
   digits[0] = i;
   digits[1] = j;
-  digits[2] = signal;
+  digits[2] = signalc;
 
   AliITSpListItem *pItem = fpList->GetpListItem( i, j );
   if( pItem == 0 ) {
@@ -668,7 +668,7 @@ void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
     }// end for if
   }
 
-  fITS->AddSimDigit( 1, phys, digits, tracks, hits, charges ); 
+  fITS->AddSimDigit( 1, phys, digits, tracks, hits, charges, signale ); 
   delete [] tracks;
   delete [] hits;
   delete [] charges;
@@ -844,10 +844,30 @@ Int_t AliITSsimulationSDD::Convert10to8(Int_t signal) const {
     return 0;
 }
 //______________________________________________________________________
+Int_t AliITSsimulationSDD::Convert8to10(Int_t signal) const {
+  // Decompression from 8 to 10 bit
+
+  if (signal < 0 || signal > 255) {
+    AliWarning(Form("Signal value %d out of range",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);
+}
+//______________________________________________________________________
 void AliITSsimulationSDD::Compress2D(){
   // 2D zero-suppression algorithm as described in ALICE-INT-1999-28 V10
   AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);  
-  Bool_t   do10to8=res->Do10to8();
   for (Int_t iWing=0; iWing<2; iWing++) {
     Int_t tL=res->GetZSLowThreshold(iWing);
     Int_t tH=res->GetZSHighThreshold(iWing);
@@ -881,9 +901,11 @@ void AliITSsimulationSDD::Compress2D(){
        if(sS>tH) nHigh++;
        
        if(nLow>=3 && nHigh>=1){
-         Int_t signal=(Int_t)(cC-tL);
-         if(do10to8) signal = Convert10to8(signal);
-         AddDigit(ian,itb,signal);  // store C (subtracting low threshold)
+         Int_t signal=(Int_t)cC;
+         Int_t signalc = Convert10to8(signal);
+         Int_t signale = Convert8to10(signalc);
+         signalc-=tL; // subtract low threshold after 10 to 8 bit compression
+         AddDigit(ian,itb,signalc,signale);  // store C 
        }
       }
     }
@@ -896,13 +918,13 @@ void AliITSsimulationSDD::StoreAllDigits(){
   // if non-zero-suppressed data
   AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
 
-  Bool_t do10to8 = res->Do10to8();
   Int_t i, j, digits[3];
 
   for (i=0; i<fNofMaps; i++) {
     for (j=0; j<fMaxNofSamples; j++) {
       Int_t signal=(Int_t)(fHitMap2->GetSignal(i,j));
-      if(do10to8) signal = Convert10to8(signal);
+      signal = Convert10to8(signal);
+      signal = Convert8to10(signal);
       digits[0] = i;
       digits[1] = j;
       digits[2] = signal;
index 97c72d0..bf63960 100644 (file)
@@ -59,12 +59,13 @@ class AliITSsimulationSDD : public AliITSsimulation {
     Bool_t CrosstalkFlag() const {return fCrosstalkFlag;}
     void FastFourierTransform(Double_t *real, Double_t *imag, Int_t direction);
     virtual Int_t Convert10to8(Int_t signal) const;//10 to 8 bit SDD compresion
+    virtual Int_t Convert8to10(Int_t signal) const;//8 to 10 bit decompresion
     virtual void Compress2D(); // Applies 2D compresion algorithm
     virtual void StoreAllDigits(); // if No compresion run this.
     // returns baseline and noise for a given anode i.
     //virtual void GetAnodeBaseline(Int_t i,Double_t &baseline,Double_t &noise) const;
     // local implementation of ITS->AddDigit. Specific for SDD
-    virtual void AddDigit(Int_t i, Int_t j, Int_t signal);
+    virtual void AddDigit(Int_t i, Int_t j, Int_t signalc, Int_t signale);
 
     // add baseline, noise, gain, electronics and ADC saturation effects
     void ChargeToSignal(Int_t mod,Bool_t bAddNoise=kFALSE, Bool_t bAddGain=kTRUE);