Revision of SSD calibration classes (E. Fragiacomo)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 12 Jul 2008 11:14:29 +0000 (11:14 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 12 Jul 2008 11:14:29 +0000 (11:14 +0000)
25 files changed:
ITS/AliITSBadChannelsSSD.cxx
ITS/AliITSBadChannelsSSD.h
ITS/AliITSCalibrationSSD.cxx
ITS/AliITSCalibrationSSD.h
ITS/AliITSClusterFinderV2SSD.cxx
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeRec.h
ITS/AliITSDetTypeSim.cxx
ITS/AliITSGainSSD.cxx
ITS/AliITSGainSSD.h
ITS/AliITSHandleDaSSD.cxx
ITS/AliITSModuleDaSSD.cxx
ITS/AliITSNoiseSSD.cxx
ITS/AliITSNoiseSSD.h
ITS/AliITSPedestalSSD.cxx
ITS/AliITSPedestalSSD.h
ITS/AliITSPlaneEffSSD.cxx
ITS/AliITSPreprocessorSSD.cxx
ITS/AliITSsimulationSSD.cxx
ITS/Calib/BadChannelsSSD/Run0_999999999_v0_s0.root
ITS/Calib/GainSSD/Run0_999999999_v0_s0.root [new file with mode: 0644]
ITS/Calib/GainSSD/Run0_9999999_v0_s0.root [deleted file]
ITS/Calib/NoiseSSD/Run0_999999999_v0_s0.root
ITS/Calib/PedestalSSD/Run0_999999999_v0_s0.root
ITS/MakeCalibrationSSD.C

index b92ceb2..1809c26 100644 (file)
@@ -1,6 +1,6 @@
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                         *
+ *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
  * Contributors are mentioned in the code where appropriate.              *
  *                                                                        *
 
 #include "AliITSBadChannelsSSD.h"
 
-ClassImp(AliITSBadChannelsSSD)
+//////////////////////////////////////////////////////
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// Modified: 08/07/2008
+//                                                  //
+//////////////////////////////////////////////////////
 
+//const Int_t AliITSBadChannelsSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSBadChannelsSSD::fgkDefaultNStripsSSD = 768;
+
+ClassImp(AliITSBadChannelsSSD)
+  
 //______________________________________________________________________
-AliITSBadChannelsSSD::AliITSBadChannelsSSD():
-fMod(0),
-fBadNChannelsList(0),
-fBadPChannelsList(0){
-    // Default Constructor
+  AliITSBadChannelsSSD::AliITSBadChannelsSSD()
+    // Default Constructor 
+{ 
+    for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) 
+      fBadChannels[i]=0;    
+  }
 
+//______________________________________________________________________
+AliITSBadChannelsSSD::AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source): 
+  TObject(source)  
+{
+    // copy Constructor
+  memcpy(fBadChannels,source.fBadChannels,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t));
 }
 
 //______________________________________________________________________
 AliITSBadChannelsSSD::~AliITSBadChannelsSSD(){
     // destructor
-
 }
 
+//______________________________________________________________________
+AliITSBadChannelsSSD& AliITSBadChannelsSSD::operator=(const AliITSBadChannelsSSD &source) {
+ // ass. op.
+    if (this == &source)return *this;
+    memcpy(fBadChannels,source.fBadChannels,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t));
+    
+    return *this;
+}
index 0a43226..e8464e9 100644 (file)
@@ -1,44 +1,49 @@
 #ifndef ALIITSBADCHANNELSSSD_H
 #define ALIITSBADCHANNELSSSD_H
  
-#include "TObjArray.h"
-#include "TArrayI.h"
-
 //////////////////////////////////////////////
-// Response class for SSD                   //
+// Author: Enrico Fragiacomo
+// Date: 23/08/2007
+// Modified: 08/07/2008
 //                                          //
 //////////////////////////////////////////////
+#include "TObject.h"
+
 class AliITSBadChannelsSSD : public TObject {
 
  public:
+
     AliITSBadChannelsSSD();
     virtual ~AliITSBadChannelsSSD();
+    AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source); // copy constructor
+    AliITSBadChannelsSSD& operator=(const AliITSBadChannelsSSD &source); // ass. op.
 
-    void SetNBadPChannelsList(Int_t n) { fBadPChannelsList.Set(n); }
-    void AddBadPChannel(Int_t c, Int_t n) { fBadPChannelsList.AddAt(n,c);}
-    TArrayI GetBadPChannelsList() const {return fBadPChannelsList; }
-    Int_t GetBadPChannel(Int_t n) {return fBadPChannelsList.At(n); }
-    void SetNBadNChannelsList(Int_t n) { fBadNChannelsList.Set(n); }
-    void AddBadNChannel(Int_t c, Int_t n) { fBadNChannelsList.AddAt(n,c);}
-    TArrayI GetBadNChannelsList() const {return fBadNChannelsList; }
-    Int_t GetBadNChannel(Int_t n) {return fBadNChannelsList.At(n); }
-    //
+    void AddBadChannelP(Int_t module, Int_t strip, Char_t value) { 
+      fBadChannels[module*2*fgkDefaultNStripsSSD+strip] = value;
+    }       
+    Char_t GetBadChannelP(Int_t module, Int_t strip) {
+      return fBadChannels[module*2*fgkDefaultNStripsSSD+strip]; 
+    }
 
-    void SetMod(UShort_t mod) {fMod = mod;}
-    UShort_t GetMod() { return fMod;}
+    void AddBadChannelN(Int_t module, Int_t strip, Char_t value) { 
+      fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value;
+    }       
+    Char_t GetBadChannelN(Int_t module, Int_t strip) {
+      return fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; 
+    }
 
  protected:
 
-    UShort_t fMod;       // module number (from 0 to 1535). Needed by the preprocessor to 
-    //   extract the information from the Detector Algorithm
-    
-    TArrayI  fBadNChannelsList;  // list of P side dead channels
-    TArrayI  fBadPChannelsList;  // list of N side dead channels
-    
+    static const Int_t fgkDefaultNModulesSSD = 1698;
+    static const Int_t fgkDefaultNStripsSSD = 768;
+    //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+   //   static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+   Char_t fBadChannels[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD];
+    //   Char_t *fBadChannels; 
+
  private:
-    AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source); // copy constructor
-    AliITSBadChannelsSSD& operator=(const AliITSBadChannelsSSD &source); // ass. op.
+   
+   ClassDef(AliITSBadChannelsSSD,1) // BadChannels  class for SSD
+     };
 
-    ClassDef(AliITSBadChannelsSSD,1) //Response class for SSD
-};
 #endif
index 30c1cc4..1e2a0d0 100644 (file)
 //                                                  //
 //////////////////////////////////////////////////////
 
-const Double_t AliITSCalibrationSSD::fgkNoiseNDefault = 625.;
-const Double_t AliITSCalibrationSSD::fgkNoisePDefault = 420.;
 const Int_t AliITSCalibrationSSD::fgkNParDefault = 6;
-const Double_t AliITSCalibrationSSD::fgkSigmaPDefault = 3.;
-const Double_t AliITSCalibrationSSD::fgkSigmaNDefault = 2.;
 
 ClassImp(AliITSCalibrationSSD)
 
 //______________________________________________________________________
 AliITSCalibrationSSD::AliITSCalibrationSSD():
+  fModule(0),
 fNPar(0),
 fDetPar(0),
-fNoiseP(0),
-fNoiseN(0),
-fSigmaP(0),
-fSigmaN(0),
 fNoise(0),
 fPedestal(),
 fGain(0),
 fBadChannels(0),
-fIsBad(kFALSE),
-fGainP(0),
-fGainN(0),
-fNoisP(0),
-fNoisN(0),
-fPedP(),
-fPedN(),
-fNoisePThreshold(0),
-fNoisyPChannelsList(0),
-fNoiseNThreshold(0),
-fNoisyNChannelsList(0),
-fDeadNChannelsList(0),
-fDeadPChannelsList(0){
+fIsBad(kFALSE){
     // Default Constructor
 
-    SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
     for(Int_t i=0;i<fgkChipsPerModule;i++){
       fIsChipBad[i]=kFALSE;
     }
 }
 //______________________________________________________________________
 AliITSCalibrationSSD::AliITSCalibrationSSD(const char *dataType):
+  fModule(0),
 fNPar(0),
 fDetPar(0),
-fNoiseP(0),
-fNoiseN(0),
-fSigmaP(0),
-fSigmaN(0),
 fNoise(0),
 fPedestal(0),
 fGain(0),
 fBadChannels(0),
-fIsBad(kFALSE),
-fGainP(0),
-fGainN(0),
-fNoisP(0),
-fNoisN(0),
-fPedP(0),
-fPedN(0),
-fNoisePThreshold(0),
-fNoisyPChannelsList(0),
-fNoiseNThreshold(0),
-fNoisyNChannelsList(0),
-fDeadNChannelsList(0),
-fDeadPChannelsList(0){
+fIsBad(kFALSE){
     // constructor
 
-    SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
     SetDataType(dataType);
-    SetSigmaSpread(fgkSigmaPDefault,fgkSigmaNDefault);
     SetNDetParam(fgkNParDefault);   // Sets fNPar=6 by default.
     fDetPar = new Double_t[fNPar];
     if (fNPar==6) {
index 1f4ddf6..a7387db 100644 (file)
@@ -23,38 +23,24 @@ class AliITSCalibrationSSD : public AliITSCalibration {
     AliITSCalibrationSSD(const char *dataType);
     virtual ~AliITSCalibrationSSD();
 
-    virtual  void   SetNoiseParam(Double_t np, Double_t nn) {
-       // set noise par
-       fNoiseP=np; fNoiseN=nn;
-    }
-
-    virtual void    GetNoiseParam(Double_t &np, Double_t &nn) const {
-       // get noise par
-       np=fNoiseP; nn=fNoiseN;
-    }
+    virtual  void   SetNoiseParam(Double_t , Double_t ) {
+      NotImplemented("SetNoiseParam");}
+    
+    virtual void    GetNoiseParam(Double_t &, Double_t &) const {
+      NotImplemented("SetNoiseParam");}
 
-    void AddNoiseP(Int_t c, Float_t n) { fNoise->AddNoiseP(c,n);}       
-    TArrayF GetNoiseP() {return fNoise->GetNoiseP(); }
-    Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(n); }
-    void AddNoiseN(Int_t c, Float_t n) { fNoise->AddNoiseN(c,n);}
-    TArrayF GetNoiseN() {return fNoise->GetNoiseN(); }
-    Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(n); }
+    Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(fModule,n); }
+    Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(fModule,n); }
     void SetNoise( AliITSNoiseSSD* noise) {fNoise=noise;}
 
-    void AddPedestalP(Int_t c, Float_t n) { fPedestal->AddPedestalP(c,n);}       
-    TArrayF GetPedestalP() {return fPedestal->GetPedestalP(); }
-    Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(n); }
-    void AddPedestalN(Int_t c, Float_t n) { fPedestal->AddPedestalN(c,n);}
-    TArrayF GetPedestalN() {return fPedestal->GetPedestalN(); }
-    Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(n); }
+    Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(fModule,n); }
+    Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(fModule,n); }
     void SetPedestal( AliITSPedestalSSD* pedestal) {fPedestal=pedestal;}
 
-    void AddGainP(Int_t c, Float_t n) { fGain->AddGainP(c,n);}       
-    TArrayF GetGainP() {return fGain->GetGainP(); }
-    Float_t GetGainP(Int_t n) {return fGain->GetGainP(n); }
-    void AddGainN(Int_t c, Float_t n) { fGain->AddGainN(c,n);}
-    TArrayF GetGainN() {return fGain->GetGainN(); }
-    Float_t GetGainN(Int_t n) {return fGain->GetGainN(n); }
+    Float_t GetGainP(Int_t n) {return fGain->GetGainP(fModule,n); }
+    Float_t GetGainN(Int_t n) {return fGain->GetGainN(fModule,n); }
+    void SetGainP(Int_t n, Float_t value) {fGain->AddGainP(fModule,n,value);}
+    void SetGainN(Int_t n, Float_t value) {fGain->AddGainN(fModule,n,value);}
     void SetGain( AliITSGainSSD* gain) {fGain=gain;}
 
     void   SetBad() {
@@ -69,33 +55,21 @@ class AliITSCalibrationSSD : public AliITSCalibration {
     virtual Bool_t IsChipBad(Int_t nChip) const {
       return fIsChipBad[nChip];
     }
-    Int_t ChipsPerModule() const{return fgkChipsPerModule;} // Number of chips/module
-    Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}//Number of channels/chip
-
-    TArrayI GetBadPChannelsList() { return fBadChannels->GetBadPChannelsList(); } const
-    TArrayI GetBadNChannelsList() { return fBadChannels->GetBadNChannelsList(); } const
-    void SetBadChannels( AliITSBadChannelsSSD* badchannels) {fBadChannels=badchannels;}
-    Int_t GetBadPChannel(Int_t n) {return fBadChannels->GetBadPChannel(n); }
-    Int_t GetBadNChannel(Int_t n) {return fBadChannels->GetBadNChannel(n); }
-    Bool_t IsPChannelBad(Int_t n) {return fBadChannels->GetBadPChannel(n)&1; }
-    Bool_t IsNChannelBad(Int_t n) {return fBadChannels->GetBadNChannel(n)&1; }
-
-    void SetNoisePThreshold(Int_t threshold) { fNoisePThreshold = threshold;}
-    void AddNoisyPChannel(Int_t c, Int_t n) { fNoisyPChannelsList.AddAt(n,c);}
-    TArrayI GetNoisyPChannelsList() const {return fNoisyPChannelsList; }
-    void SetNoiseNThreshold(Int_t threshold) { fNoiseNThreshold = threshold;}
-    void AddNoisyNChannel(Int_t c, Int_t n) { fNoisyNChannelsList.AddAt(n,c);}
-    TArrayI GetNoisyNChannelsList() const {return fNoisyNChannelsList; }
-
-    void SetNDeadPChannelsList(Int_t n) { fDeadPChannelsList.Set(n); }
-    void AddDeadPChannel(Int_t c, Int_t n) { fDeadPChannelsList.AddAt(n,c);}
-    TArrayI GetDeadPChannelsList() const {return fDeadPChannelsList; }
-    void SetNDeadNChannelsList(Int_t n) { fDeadNChannelsList.Set(n); }
-    void AddDeadNChannel(Int_t c, Int_t n) { fDeadNChannelsList.AddAt(n,c);}
-    TArrayI GetDeadNChannelsList() const {return fDeadNChannelsList; }
-    //
-
+    Int_t ChipsPerModule() const{return fgkChipsPerModule;} // # chips/module
+    Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}// #channels/chip
+
+    void SetBadChannels( AliITSBadChannelsSSD* badchannels) {
+      fBadChannels=badchannels;}
+    Char_t GetBadPChannel(Int_t n) {
+      return fBadChannels->GetBadChannelP(fModule,n); }
+    Char_t GetBadNChannel(Int_t n) {
+      return fBadChannels->GetBadChannelN(fModule,n); }
+    Bool_t IsPChannelBad(Int_t n) {
+      return fBadChannels->GetBadChannelP(fModule,n)&1; }
+    Bool_t IsNChannelBad(Int_t n) {
+      return fBadChannels->GetBadChannelN(fModule,n)&1; }
 
+    //
     virtual  void   SetNDetParam(Int_t npar) {
        // set number of param
        fNPar=npar;
@@ -109,17 +83,13 @@ class AliITSCalibrationSSD : public AliITSCalibration {
     }
     virtual void    GetDetParam(Double_t *dpar) const; 
 
-    virtual void    SetSigmaSpread(Double_t p1, Double_t p2) {
-       // Set sigmas of the charge spread function: Pside-Nside
-       // square of (microns)
-       fSigmaP=p1; fSigmaN=p2;
-    }
-
-    virtual void    SigmaSpread(Double_t &sP, Double_t &sN) const {
-      // Get sigmas for the charge spread 
-      sP=fSigmaP; sN=fSigmaN;
-    }
-
+    virtual void    SetSigmaSpread(Double_t, Double_t) {
+      NotImplemented("SetSigmaSpread");}
+    
+    virtual void    SigmaSpread(Double_t &, Double_t &) const {
+      NotImplemented("SetSigmaSpread");}
+    
+    
     virtual void   SetThresholds(Double_t /* a */, Double_t /* b */)
       {NotImplemented("SetThresholds");}
     virtual void   Thresholds(Double_t & /* a */, Double_t & /* b */) const 
@@ -143,25 +113,20 @@ class AliITSCalibrationSSD : public AliITSCalibration {
   virtual void SetZSThreshold(Int_t zsth) 
     { ((AliITSresponseSSD*)fResponse)->SetZSThreshold(zsth);}
 
+ void SetModule(Int_t mod){fModule = mod;}
+
 protected:
 
     static const Int_t fgkChipsPerModule  = 12;    // Number of chips/module
     static const Int_t fgkChannelsPerChip = 128;   // Number of channels/chip
 
-    static const Double_t fgkNoiseNDefault; // default for fNoiseN
-    static const Double_t fgkNoisePDefault; // default for fNoiseP
     static const Int_t fgkNParDefault; // default for fNPar
-    static const Double_t fgkSigmaPDefault; //default for fSigmaP
-    static const Double_t fgkSigmaNDefault; //default for fSigmaP
 
+    Int_t fModule;          //! module number (range 0 -> 1697)
+    
     Int_t   fNPar;            // Number of detector param 
     Double_t *fDetPar;         //[fNPar] Array of parameters
 
-    Double_t fNoiseP;          // Noise on Pside
-    Double_t fNoiseN;          // Noise on Nside
-    Double_t fSigmaP;          // Sigma charge spread on Pside
-    Double_t fSigmaN;          // Sigma charge spread on Nside
-    
     AliITSNoiseSSD *fNoise;
     AliITSPedestalSSD *fPedestal;
     AliITSGainSSD *fGain;
@@ -170,27 +135,10 @@ protected:
     Bool_t   fIsBad;                         // module is dead or alive ?
     Bool_t   fIsChipBad[fgkChipsPerModule];  // chip is dead or alive ?
 
-    TArrayF fGainP;           // Gain for P side channels
-    TArrayF fGainN;           // Gain for N side channels
-
-    TArrayF fNoisP;           // Noise for P side channels
-    TArrayF fNoisN;           // Noise for N side channels
-
-    TArrayF fPedP;
-    TArrayF fPedN;
-
-    Float_t fNoisePThreshold;     // need to decide if channel is noisy  
-    TArrayI  fNoisyPChannelsList; // list of P side noisy channels
-    Float_t fNoiseNThreshold;     // need to decide if channel is noisy  
-    TArrayI  fNoisyNChannelsList; // list of N side noisy channels
-
-    TArrayI  fDeadNChannelsList;  // list of P side dead channels
-    TArrayI  fDeadPChannelsList;  // list of N side dead channels
-
  private:
     AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor
     AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op.
 
     ClassDef(AliITSCalibrationSSD,3) //Response class for SSD
-};
+      };
 #endif
index c20b74f..d0f3bd2 100644 (file)
@@ -364,7 +364,7 @@ void AliITSClusterFinderV2SSD::FindClustersSSD(AliITSRawStreamSSD* input,
        noise = cal->GetNoiseP(istrip); if(noise<1.) signal = 65535;
        if(signal<3*noise) signal = 65535; // in case ZS was not done in hw do it now
 
-       //        if(cal->IsPChannelB ad(istrip)) signal=0;
+       //        if(cal->IsPChannelBad(istrip)) signal=0;
 
        if (signal!=65535) {
          gain = cal->GetGainP(istrip);
index 79f1e03..b2016d6 100644 (file)
@@ -74,6 +74,7 @@ fITSgeom(0),
 fReconstruction(0),
 fSegmentation(0),
 fCalibration(0),
+fSSDCalibration(0),
 fSPDDead(0),
 fPreProcess(0),
 fPostProcess(0),
@@ -102,6 +103,7 @@ fFirstcall(kTRUE){
     fDigClassName[i]=0;
     fRecPointClassName[i]=0;
   }
+  fSSDCalibration=new AliITSCalibrationSSD();
   fNdtype = new Int_t[fgkNdettypes];
   fCtype = new TObjArray(fgkNdettypes);
   fNctype = new Int_t[fgkNdettypes];
@@ -127,6 +129,7 @@ fITSgeom(rec.fITSgeom),
 fReconstruction(rec.fReconstruction),
 fSegmentation(rec.fSegmentation),
 fCalibration(rec.fCalibration),
+fSSDCalibration(rec.fSSDCalibration),
 fSPDDead(rec.fSPDDead),
 fPreProcess(rec.fPreProcess),
 fPostProcess(rec.fPostProcess),
@@ -181,7 +184,8 @@ AliITSDetTypeRec::~AliITSDetTypeRec(){
       if(fDDLMapSDD) delete fDDLMapSDD;
    }
   }
-  if(fSPDDead){
+  if(fSSDCalibration) delete fSSDCalibration;
+   if(fSPDDead){
     if(!(AliCDBManager::Instance()->GetCacheFlag())) {
       fSPDDead->Delete();
       delete fSPDDead;
@@ -294,7 +298,14 @@ AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod){
     return 0; 
   }  
 
-  return (AliITSCalibration*)fCalibration->At(iMod);
+  if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
+    return (AliITSCalibration*)fCalibration->At(iMod);
+  }else{
+    Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
+    fSSDCalibration->SetModule(i);
+    return (AliITSCalibration*)fSSDCalibration;
+  }
+
 }
 //_______________________________________________________________________
 AliITSCalibration* AliITSDetTypeRec::GetSPDDeadModel(Int_t iMod){
@@ -488,19 +499,21 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
   if(!cacheStatus)mapTSDD->SetObject(NULL);
   mapTSDD->SetOwner(kTRUE);
 
-  TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject();
+  AliITSNoiseSSD *noiseSSD = (AliITSNoiseSSD *)entryNoiseSSD->GetObject();
   if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
   entryNoiseSSD->SetOwner(kTRUE);
 
-  TObjArray *pedestalSSD = (TObjArray *)entryPedestalSSD->GetObject();
+  AliITSPedestalSSD *pedestalSSD = 
+    (AliITSPedestalSSD*)entryPedestalSSD->GetObject();
   if(!cacheStatus)entryPedestalSSD->SetObject(NULL);
   entryPedestalSSD->SetOwner(kTRUE);
 
-  TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject();
+  AliITSGainSSD *gainSSD = (AliITSGainSSD *)entryGainSSD->GetObject();
   if(!cacheStatus)entryGainSSD->SetObject(NULL);
   entryGainSSD->SetOwner(kTRUE);
 
-  TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject();
+  AliITSBadChannelsSSD *badchannelsSSD = 
+    (AliITSBadChannelsSSD*)entryBadChannelsSSD->GetObject();
   if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
   entryBadChannelsSSD->SetOwner(kTRUE);
 
@@ -546,7 +559,7 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
 
   fNMod[0] = calSPD->GetEntries();
   fNMod[1] = calSDD->GetEntries();
-  fNMod[2] = noiseSSD->GetEntries();
+  //fNMod[2] = noiseSSD->GetEntries();
   AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
               fNMod[0], fNMod[1], fNMod[2]));
   AliITSCalibration* cal;
@@ -583,6 +596,16 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
       SetCalibrationModel(iMod, cal);
     }
   }
+
+  fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
+  fSSDCalibration->SetNoise(noiseSSD);
+  fSSDCalibration->SetPedestal(pedestalSSD);
+  fSSDCalibration->SetGain(gainSSD);
+  fSSDCalibration->SetBadChannels(badchannelsSSD);
+  //fSSDCalibration->FillBadChipMap();
+
+
+  /*
   for (Int_t i=0; i<fNMod[2]; i++) {
 
     AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD();
@@ -601,6 +624,7 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
     Int_t iMod = i + fgkDefaultNModulesSPD + fgkDefaultNModulesSDD;
     SetCalibrationModel(iMod, calibSSD);
  }
+  */
 
   return kTRUE;
 }
index 25d02b5..b158856 100644 (file)
@@ -17,7 +17,6 @@ $Id$
 #include "AliITSDDLModuleMapSDD.h"
 #include "AliITSresponseSDD.h"
 #include "AliITSgeom.h"
-
 class TTree;
 class TBranch;
 
@@ -26,6 +25,7 @@ class TBranch;
 
 class AliITSsegmentation;
 class AliITSCalibration;
+class AliITSCalibrationSSD;
 class AliITSresponseSDD;
 class AliITSClusterFinder;
 class AliITSRawCluster;
@@ -113,6 +113,7 @@ class AliITSDetTypeRec : public TObject {
     TObjArray    *fReconstruction;//! [NDet]
     TObjArray    *fSegmentation;  //! [NDet]
     TObjArray    *fCalibration;   //! [NMod]
+    AliITSCalibrationSSD* fSSDCalibration;  //! SSD calibration object
     TObjArray    *fSPDDead;       //! [fgkDefaultNModulesSPD]
     TObjArray    *fPreProcess;    //! [] e.g. Find Calibration values
     TObjArray    *fPostProcess;   //! [] e.g. find primary vertex
index 4e63042..75186f8 100644 (file)
@@ -73,6 +73,7 @@ TObject(),
 fSimulation(),   // [NDet]
 fSegmentation(), // [NDet]
 fCalibration(),     // [NMod]
+fSSDCalibration(0),
 fPreProcess(),   // [] e.g. Fill fHitModule with hits
 fPostProcess(),  // [] e.g. Wright Raw data
 fNSDigits(0),    //! number of SDigits
@@ -102,6 +103,7 @@ fFirstcall(kTRUE){ // flag
   fNDigits = new Int_t[fgkNdettypes];
   fDDLMapSDD=new AliITSDDLModuleMapSDD();
   fSimuPar= new AliITSSimuParam();
+  fSSDCalibration=new AliITSCalibrationSSD();
   fNMod[0] = fgkDefaultNModulesSPD;
   fNMod[1] = fgkDefaultNModulesSDD;
   fNMod[2] = fgkDefaultNModulesSSD;
@@ -138,7 +140,8 @@ AliITSDetTypeSim::~AliITSDetTypeSim(){
        delete fCalibration;
     }
     fCalibration = 0;
-    if(fPreProcess){
+    if(fSSDCalibration) delete fSSDCalibration;
+     if(fPreProcess){
        fPreProcess->Delete();
        delete fPreProcess;
     }
@@ -166,6 +169,7 @@ AliITSDetTypeSim::AliITSDetTypeSim(const AliITSDetTypeSim &source) : TObject(sou
 fSimulation(source.fSimulation),   // [NDet]
 fSegmentation(source.fSegmentation), // [NDet]
 fCalibration(source.fCalibration),     // [NMod]
+fSSDCalibration(source.fSSDCalibration),
 fPreProcess(source.fPreProcess),   // [] e.g. Fill fHitModule with hits
 fPostProcess(source.fPostProcess),  // [] e.g. Wright Raw data
 fNSDigits(source.fNSDigits),    //! number of SDigits
@@ -364,7 +368,14 @@ AliITSCalibration* AliITSDetTypeSim::GetCalibrationModel(Int_t iMod){
        AliError("fCalibration is 0!");
        return 0; 
     }
-  return (AliITSCalibration*)(fCalibration->At(iMod));
+  if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
+    return (AliITSCalibration*)fCalibration->At(iMod);
+  }else{
+    Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
+    fSSDCalibration->SetModule(i);
+    return (AliITSCalibration*)fSSDCalibration;
+  }
+
 }
 //_______________________________________________________________________
 void AliITSDetTypeSim::SetDefaults(){
@@ -476,15 +487,16 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
   entrySSD->SetOwner(kTRUE);
   */
 
-  TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject();
+  AliITSNoiseSSD *noiseSSD = (AliITSNoiseSSD *)entryNoiseSSD->GetObject();
   if(!isCacheActive)entryNoiseSSD->SetObject(NULL);
   entryNoiseSSD->SetOwner(kTRUE);
 
-  TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject();
+  AliITSGainSSD *gainSSD = (AliITSGainSSD *)entryGainSSD->GetObject();
   if(!isCacheActive)entryGainSSD->SetObject(NULL);
   entryGainSSD->SetOwner(kTRUE);
 
-  TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject();
+  AliITSBadChannelsSSD *badchannelsSSD = 
+    (AliITSBadChannelsSSD *)entryBadChannelsSSD->GetObject();
   if(!isCacheActive)entryBadChannelsSSD->SetObject(NULL);
   entryBadChannelsSSD->SetOwner(kTRUE);
 
@@ -517,7 +529,7 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
 
   fNMod[0] = calSPD->GetEntries();
   fNMod[1] = calSDD->GetEntries();
-  fNMod[2] = noiseSSD->GetEntries();
+  //  fNMod[2] = noiseSSD->GetEntries();
   AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
               fNMod[0], fNMod[1], fNMod[2]));
   AliITSCalibration* cal;
@@ -563,6 +575,14 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
     }
   }
 
+  fSSDCalibration->SetResponse((AliITSresponse*)pSSD);
+  fSSDCalibration->SetNoise(noiseSSD);
+  fSSDCalibration->SetGain(gainSSD);
+  fSSDCalibration->SetBadChannels(badchannelsSSD);
+  //fSSDCalibration->FillBadChipMap();
+
+
+  /*
   for (Int_t i=0; i<fNMod[2]; i++) {
     AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD();
     calibSSD->SetResponse((AliITSresponse*)pSSD);
@@ -577,7 +597,10 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
     Int_t iMod = i + fgkDefaultNModulesSPD + fgkDefaultNModulesSDD;
     SetCalibrationModel(iMod, calibSSD);
 
- }
+    }
+  */
+
+
   return kTRUE;
 }
 //_______________________________________________________________________
index aa850ad..b6d6aff 100644 (file)
 //////////////////////////////////////////////////////
 // Author: Enrico Fragiacomo
 // Date: 23/08/2007
+// Modified: 08/07/2008
 //                                                  //
 //////////////////////////////////////////////////////
 
+//const Int_t AliITSGainSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSGainSSD::fgkDefaultNStripsSSD = 768;
+
 ClassImp(AliITSGainSSD)
+  
+//______________________________________________________________________
+  AliITSGainSSD::AliITSGainSSD() 
+{
+    // Default Constructor  
+    for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) 
+      fGain[i]=0;    
+}
 
 //______________________________________________________________________
-AliITSGainSSD::AliITSGainSSD():
-fMod(0),
-fGainP(0),
-fGainN(0) {
-    // Default Constructor
+AliITSGainSSD::AliITSGainSSD(const AliITSGainSSD &source): 
+  TObject(source)
+{
+    // copy Constructor
+  memcpy(fGain,source.fGain,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t));
 }
 
 //______________________________________________________________________
@@ -38,3 +51,13 @@ AliITSGainSSD::~AliITSGainSSD(){
 
 }
 
+//______________________________________________________________________
+AliITSGainSSD& AliITSGainSSD::operator=(const AliITSGainSSD &source) {
+ // ass. op.
+    if (this == &source)return *this;
+
+    memcpy(fGain,source.fGain,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t));
+    
+    return *this;
+}
index 9291347..1924b92 100644 (file)
@@ -1,45 +1,51 @@
 #ifndef ALIITSGAINSSD_H
 #define ALIITSGAINSSD_H
  
-#include "TObjArray.h"
-#include "TArrayF.h"
-
 //////////////////////////////////////////////
 // Author: Enrico Fragiacomo
 // Date: 23/08/2007
+// Modified: 08/07/2008
 //                                          //
 //////////////////////////////////////////////
+#include "TObject.h"
+
 class AliITSGainSSD : public TObject {
 
  public:
 
     AliITSGainSSD();
     virtual ~AliITSGainSSD();
-
-    void SetNGainP(Int_t n) { fGainP.Set(n); }
-    void AddGainP(Int_t c, Float_t n) { fGainP.AddAt(n,c);}       
-    TArrayF GetGainP() const {return fGainP; }
-    Float_t GetGainP(Int_t n) {return fGainP.At(n); }
-    void SetNGainN(Int_t n) { fGainN.Set(n); }
-    void AddGainN(Int_t c, Float_t n) { fGainN.AddAt(n,c);}
-    TArrayF GetGainN() const {return fGainN; }
-    Float_t GetGainN(Int_t n) {return fGainN.At(n); }
-
-    void SetMod(UShort_t mod) {fMod = mod;}
-    UShort_t GetMod() { return fMod;}
-
-protected:
-
-  UShort_t fMod;       // module number (from 0 to 1535). Needed by the preprocessor to 
-                       //   extract the information from the Detector Algorithm
-  
-  TArrayF fGainP;           // Gain for P side channels
-  TArrayF fGainN;           // Gain for N side channels
-  
- private:
     AliITSGainSSD(const AliITSGainSSD &source); // copy constructor
     AliITSGainSSD& operator=(const AliITSGainSSD &source); // ass. op.
 
-    ClassDef(AliITSGainSSD,1) //Response class for SSD
-};
+    void AddGainP(Int_t module, Int_t strip, Float_t value) { 
+      fGain[module*2*fgkDefaultNStripsSSD+strip] = (UShort_t) (1000.*value);
+    }       
+    Float_t GetGainP(Int_t module, Int_t strip) {
+      return ((Float_t) ( (Float_t) fGain[module*2*fgkDefaultNStripsSSD+strip] ) /1000.); 
+    }
+
+    void AddGainN(Int_t module, Int_t strip, Float_t value) { 
+      fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = 
+       (UShort_t) (1000.*value);
+    }       
+    Float_t GetGainN(Int_t module, Int_t strip) {
+      return ( (Float_t) ((Float_t) fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip])/1000.); 
+    }
+
+ protected:
+
+    static const Int_t fgkDefaultNModulesSSD = 1698;
+    static const Int_t fgkDefaultNStripsSSD = 768;
+
+    //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+    //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+
+    UShort_t fGain[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; 
+    //   UShort_t *fGain; 
+
+ private:
+    
+    ClassDef(AliITSGainSSD,1) // Gain  class for SSD
+      };
 #endif
index f4ff41e..f7bb273 100644 (file)
@@ -1107,11 +1107,14 @@ Bool_t AliITSHandleDaSSD::SaveEqSlotCalibrationData(const Int_t ddl, const Int_t
 Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
 {
 // Check if the channel is bad
-  AliITSBadChannelsSSD  *badch = NULL;
-  TArrayI                bcharray;
-  Int_t                  strsiden, modn = -1;
+//  AliITSBadChannelsSSD  *badch = NULL;
+  //  TArrayI                bcharray;
+  //  Int_t                  strsiden;
+  Int_t modn = -1;
   if (fStaticBadChannelsMap && fDDLModuleMap) {
     modn = RetrieveModuleId(ddl, ad, adc);
+
+    /*
     if (modn < 0) return -1;
     Int_t modind = 0;
     while ((modind < fStaticBadChannelsMap->GetEntriesFast() && (!badch))) {
@@ -1137,8 +1140,11 @@ Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const
     }  
   } else {
     AliError("Error ether bad channels list or DDLMap is not initialized or both, return 0!");
+
+    */
        return 0;
   }
+  return 0;
 }
         
         
@@ -1173,8 +1179,8 @@ ULong_t AliITSHandleDaSSD::OffsetValue(const UChar_t ddl, const UChar_t ad, cons
 // Calculate the offset value to be upload to FEROM    
   AliITSChannelDaSSD    *strip = NULL;
   AliITSModuleDaSSD     *module = NULL;
-  if (module = GetModule(ddl, ad, adc)) {
-    if (strip = module->GetStrip(strn)) return OffsetValue(strip, ddl, ad, adc, strn);
+  if ((module = GetModule(ddl, ad, adc))) {
+    if ((strip = module->GetStrip(strn))) return OffsetValue(strip, ddl, ad, adc, strn);
     else {
       AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i,  strip = %i, 0 is used!", ddl, ad, adc, strn));
       return 0ul;
@@ -1204,9 +1210,9 @@ ULong_t AliITSHandleDaSSD::ZsThreshold(const UChar_t ddl, const UChar_t ad, cons
 // Calculate the value of zero suppression threshold to be upload to FEROM, account bad channels list
   AliITSChannelDaSSD    *strip = NULL;
   AliITSModuleDaSSD     *module = NULL;
-  if (ChannelIsBad(ddl, ad, adc, strn)) return fgkZsBitMask;
-  if (module = GetModule(ddl, ad, adc)) {
-    if (strip = module->GetStrip(strn))  return ZsThreshold(strip);
+  if ((ChannelIsBad(ddl, ad, adc, strn))) return fgkZsBitMask;
+  if ((module = GetModule(ddl, ad, adc))) {
+    if ((strip = module->GetStrip(strn)))  return ZsThreshold(strip);
     else {
       AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i,  strip = %i, 0 is used!", ddl, ad, adc, strn));
       return 0ul;
index f2a0371..72e5da0 100644 (file)
@@ -496,9 +496,11 @@ AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationNoise() const
 {
 // Creates the AliITSNoiseSSD objects with callibration data
   AliITSNoiseSSD  *mc;
-  Float_t          noise;
+  //  Float_t          noise;
   if (!fStrips) return NULL;
   mc = new AliITSNoiseSSD();
+
+  /*
   mc->SetMod(fModuleId);
   mc->SetNNoiseP(fgkPNStripsPerModule);
   mc->SetNNoiseN(fgkPNStripsPerModule);
@@ -509,6 +511,8 @@ AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationNoise() const
           mc->AddNoiseP(i, noise);
     else  mc->AddNoiseN((AliITSChannelDaSSD::GetMaxStripIdConst() - i), noise);                     
   }
+  */
+
   return mc;
 }
 
@@ -519,9 +523,11 @@ AliITSPedestalSSD* AliITSModuleDaSSD::GetCalibrationPedestal() const
 {
 // Creates the AliITSPedestalSSD objects with callibration data
   AliITSPedestalSSD  *mc;
-  Float_t             ped;
+  //  Float_t             ped;
   if (!fStrips) return NULL;
   mc = new AliITSPedestalSSD();
+
+  /*
   mc->SetMod(fModuleId);
   mc->SetNPedestalP(fgkPNStripsPerModule);
   mc->SetNPedestalN(fgkPNStripsPerModule);
@@ -532,6 +538,8 @@ AliITSPedestalSSD* AliITSModuleDaSSD::GetCalibrationPedestal() const
           mc->AddPedestalP(i, ped);
     else  mc->AddPedestalN((AliITSChannelDaSSD::GetMaxStripIdConst() - i), ped);                     
   }
+  */
+
   return mc;
 }
 
@@ -551,6 +559,8 @@ AliITSBadChannelsSSD* AliITSModuleDaSSD::GetCalibrationBadChannels() const
        { chlist[nch++] = i; if (i < fgkPNStripsPerModule) nchp++; else nchn++; }
   }
   mc = new AliITSBadChannelsSSD();
+
+  /*
   mc->SetMod(fModuleId);
   if (!nch) return mc;
   mc->SetNBadPChannelsList(nchp);
@@ -559,5 +569,7 @@ AliITSBadChannelsSSD* AliITSModuleDaSSD::GetCalibrationBadChannels() const
     if (chlist[i] < fgkPNStripsPerModule) mc->AddBadPChannel(chlist[i], i);
     else mc->AddBadNChannel((AliITSChannelDaSSD::GetMaxStripIdConst() - chlist[i]), (i-nchp));
   }
+  */
+
   return mc;
 }
index 896c4ff..a92d7ab 100644 (file)
 //////////////////////////////////////////////////////
 // Author: Enrico Fragiacomo
 // Date: 23/08/2007
+// Modified: 08/07/2008
 //                                                  //
 //////////////////////////////////////////////////////
 
-ClassImp(AliITSNoiseSSD)
+//const Int_t AliITSNoiseSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSNoiseSSD::fgkDefaultNStripsSSD = 768;
 
+ClassImp(AliITSNoiseSSD)
+  
 //______________________________________________________________________
-AliITSNoiseSSD::AliITSNoiseSSD():
-fMod(0),
-fNoisP(0),
-fNoisN(0) {
-    // Default Constructor
+  AliITSNoiseSSD::AliITSNoiseSSD() {
+  // Default Constructor
+  for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) 
+    fNois[i]=0;    
 }
 
 //______________________________________________________________________
-AliITSNoiseSSD::AliITSNoiseSSD(const AliITSNoiseSSD &source): TObject(source),
-fMod(source.fMod),
-fNoisP(source.fNoisP),
-fNoisN(source.fNoisN) {
+AliITSNoiseSSD::AliITSNoiseSSD(const AliITSNoiseSSD &source): 
+  TObject(source)  
+{
     // copy Constructor
+  memcpy(fNois,source.fNois,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
 }
+
 //______________________________________________________________________
 AliITSNoiseSSD::~AliITSNoiseSSD(){
     // destructor
@@ -50,8 +55,9 @@ AliITSNoiseSSD& AliITSNoiseSSD::operator=(const AliITSNoiseSSD &source) {
  // ass. op.
     if (this == &source)
       return *this;
-    fMod = source.fMod;
-    fNoisP =  source.fMod;
-    fNoisN =  source.fMod;
+
+    memcpy(fNois,source.fNois,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
+    
     return *this;
 }
index e389cf1..58046e8 100644 (file)
@@ -1,14 +1,14 @@
 #ifndef ALIITSNOISESSD_H
 #define ALIITSNOISESSD_H
  
-#include "TObjArray.h"
-#include "TArrayF.h"
-
 //////////////////////////////////////////////
 // Author: Enrico Fragiacomo
 // Date: 23/08/2007
+// Modified: 08/07/2008
 //                                          //
 //////////////////////////////////////////////
+#include "TObject.h"
+
 class AliITSNoiseSSD : public TObject {
 
  public:
@@ -18,28 +18,33 @@ class AliITSNoiseSSD : public TObject {
     AliITSNoiseSSD(const AliITSNoiseSSD &source); // copy constructor
     AliITSNoiseSSD& operator=(const AliITSNoiseSSD &source); // ass. op.
 
-    void SetNNoiseP(Int_t n) { fNoisP.Set(n); }
-    void AddNoiseP(Int_t c, Float_t n) { fNoisP.AddAt(n,c);}       
-    TArrayF GetNoiseP() const {return fNoisP; }
-    Float_t GetNoiseP(Int_t n) {return fNoisP.At(n); }
-    void SetNNoiseN(Int_t n) { fNoisN.Set(n); }
-    void AddNoiseN(Int_t c, Float_t n) { fNoisN.AddAt(n,c);}
-    TArrayF GetNoiseN() const {return fNoisN; }
-    Float_t GetNoiseN(Int_t n) {return fNoisN.At(n); }
-
-    void SetMod(UShort_t mod) {fMod = mod;}
-    UShort_t GetMod() { return fMod;}
-
-protected:
-
-  UShort_t fMod;       // module number (from 0 to 1535). Needed by the preprocessor to 
-                       //   extract the information from the Detector Algorithm
-  
-  TArrayF fNoisP;           // Noise for P side channels
-  TArrayF fNoisN;           // Noise for N side channels
-  
- private:
+    void AddNoiseP(Int_t module, Int_t strip, Float_t value) { 
+      fNois[module*2*fgkDefaultNStripsSSD+strip] = value;
+    }       
+    Float_t GetNoiseP(Int_t module, Int_t strip) {
+      return fNois[module*2*fgkDefaultNStripsSSD+strip]; 
+    }
+
+    void AddNoiseN(Int_t module, Int_t strip, Float_t value) { 
+      fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value;
+    }       
+    Float_t GetNoiseN(Int_t module, Int_t strip) {
+      return fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; 
+    }
+
+ protected:
 
+    static const Int_t fgkDefaultNModulesSSD = 1698;
+    static const Int_t fgkDefaultNStripsSSD = 768;
+
+    //   static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+    //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+
+     Float_t fNois[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; 
+     //Float_t *fNois;
+
+ private:
+    
     ClassDef(AliITSNoiseSSD,1) // Noise  class for SSD
-};
+      };
 #endif
index 1ba1ed6..6fc583b 100644 (file)
@@ -1,5 +1,5 @@
 /**************************************************************************
- * Copyright(c) 2007-9, ALICE Experiment at CERN, All rights reserved. *
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                         *
  * Author: The ALICE Off-line Project.                                    *
  * Contributors are mentioned in the code where appropriate.              *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
 
 #include "AliITSPedestalSSD.h"
 
 //////////////////////////////////////////////////////
 // Author: Enrico Fragiacomo
-// Date: 12/12/2007
+// Date: 23/08/2007
+// Modified: 08/07/2008
 //                                                  //
 //////////////////////////////////////////////////////
 
-ClassImp(AliITSPedestalSSD)
+//const Int_t AliITSPedestalSSD::fgkDefaultNModulesSSD = 1698;
+//const Int_t AliITSPedestalSSD::fgkDefaultNStripsSSD = 768;
 
+ClassImp(AliITSPedestalSSD)
+  
 //______________________________________________________________________
-AliITSPedestalSSD::AliITSPedestalSSD():
-fMod(0),
-fPedP(0),
-fPedN(0) {
+  AliITSPedestalSSD::AliITSPedestalSSD()
     // Default Constructor
-}
+      //: fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]) 
+{ 
+    for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) 
+      fPedestal[i]=0;    
+  }
 
 //______________________________________________________________________
-AliITSPedestalSSD::AliITSPedestalSSD(const AliITSPedestalSSD &source): TObject(source),
-fMod(source.fMod),
-fPedP(source.fPedP),
-fPedN(source.fPedN) {
+AliITSPedestalSSD::AliITSPedestalSSD(const AliITSPedestalSSD &source): 
+  TObject(source)  
+                                   //,  fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD])
+{
     // copy Constructor
+  memcpy(fPedestal,source.fPedestal,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
 }
+
 //______________________________________________________________________
 AliITSPedestalSSD::~AliITSPedestalSSD(){
     // destructor
@@ -49,10 +56,10 @@ AliITSPedestalSSD::~AliITSPedestalSSD(){
 //______________________________________________________________________
 AliITSPedestalSSD& AliITSPedestalSSD::operator=(const AliITSPedestalSSD &source) {
  // ass. op.
-    if (this == &source)
-      return *this;
-    fMod = source.fMod;
-    fPedP =  source.fMod;
-    fPedN =  source.fMod;
+    if (this == &source)return *this;
+
+    memcpy(fPedestal,source.fPedestal,
+        2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t));
+    
     return *this;
 }
index 7afc2e7..f0f125e 100644 (file)
@@ -1,16 +1,13 @@
 #ifndef ALIITSPEDESTALSSD_H
 #define ALIITSPEDESTALSSD_H
  
-#include "TObjArray.h"
-#include "TArrayF.h"
-
 //////////////////////////////////////////////
 // Author: Enrico Fragiacomo
-// Date: 12/12/2007
+// Date: 23/08/2007
+// Modified: 08/07/2008
 //                                          //
 //////////////////////////////////////////////
-
-/* $Id$ */
+#include "TObject.h"
 
 class AliITSPedestalSSD : public TObject {
 
@@ -21,28 +18,32 @@ class AliITSPedestalSSD : public TObject {
     AliITSPedestalSSD(const AliITSPedestalSSD &source); // copy constructor
     AliITSPedestalSSD& operator=(const AliITSPedestalSSD &source); // ass. op.
 
-    void SetNPedestalP(Int_t n) { fPedP.Set(n); }
-    void AddPedestalP(Int_t c, Float_t n) { fPedP.AddAt(n,c);}       
-    TArrayF GetPedestalP() const {return fPedP; }
-    Float_t GetPedestalP(Int_t n) {return fPedP.At(n); }
-    void SetNPedestalN(Int_t n) { fPedN.Set(n); }
-    void AddPedestalN(Int_t c, Float_t n) { fPedN.AddAt(n,c);}
-    TArrayF GetPedestalN() const {return fPedN; }
-    Float_t GetPedestalN(Int_t n) {return fPedN.At(n); }
-
-    void SetMod(UShort_t mod) {fMod = mod;}
-    UShort_t GetMod() { return fMod;}
-
-protected:
-
-  UShort_t fMod;       // module number (from 0 to 1535). Needed by the preprocessor to 
-                       //   extract the information from the Detector Algorithm
-  
-  TArrayF fPedP;           // Pedestal for P side channels
-  TArrayF fPedN;           // Pedestal for N side channels
-  
- private:
+    void AddPedestalP(Int_t module, Int_t strip, Float_t value) { 
+      fPedestal[module*2*fgkDefaultNStripsSSD+strip] = value;
+    }       
+    Float_t GetPedestalP(Int_t module, Int_t strip) {
+      return fPedestal[module*2*fgkDefaultNStripsSSD+strip]; 
+    }
+
+    void AddPedestalN(Int_t module, Int_t strip, Float_t value) { 
+      fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value;
+    }       
+    Float_t GetPedestalN(Int_t module, Int_t strip) {
+      return fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; 
+    }
+
+ protected:
 
+    static const Int_t fgkDefaultNModulesSSD = 1698;
+    static const Int_t fgkDefaultNStripsSSD = 768;
+
+    //   static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules
+    //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules
+
+Float_t fPedestal[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; 
+
+ private:
+    
     ClassDef(AliITSPedestalSSD,1) // Pedestal  class for SSD
-};
+      };
 #endif
index 7baf7ac..06a966d 100644 (file)
@@ -330,13 +330,13 @@ if(cdbSSD) {
   return;
 }
 //
-UInt_t mod=GetModFromKey(key);
+//UInt_t mod=GetModFromKey(key);
 //
-AliITSBadChannelsSSD* badchannels=(AliITSBadChannelsSSD*) ssdEntry->At(mod);
+//AliITSBadChannelsSSD* badchannels=(AliITSBadChannelsSSD*) ssdEntry->At(mod);
 // count the  number of bad channels on the p side
-nrBadInMod += (badchannels->GetBadPChannelsList()).GetSize();
+//nrBadInMod += (badchannels->GetBadPChannelsList()).GetSize();
 // add the  number of bad channels on the s side
-nrBadInMod += (badchannels->GetBadNChannelsList()).GetSize();
+//nrBadInMod += (badchannels->GetBadNChannelsList()).GetSize();
 return;
 }
 //_____________________________________________________________________________
index 5a72d02..60d880a 100644 (file)
@@ -58,11 +58,17 @@ UInt_t AliITSPreprocessorSSD::Process(TMap* /*dcsAliasMap*/)
   // Note. To be modified: dcsAliasMap is not needed but I can not get rid
   // of it unless the base class AliPreprocessor is modified accordingly.
 
-  TObjArray calib_array(fgkNumberOfSSD); 
-  TObjArray badch_array(fgkNumberOfSSD); 
-  TObjArray ped_array(fgkNumberOfSSD); 
+  //  TObjArray calib_array(fgkNumberOfSSD); 
+  //TObjArray badch_array(fgkNumberOfSSD); 
+  //TObjArray ped_array(fgkNumberOfSSD); 
   //Float_t noise=0, gain=0;
   
+  //---------------------------------------
+  // initialize the calibration objects
+  AliITSNoiseSSD *calib = new AliITSNoiseSSD();
+  AliITSBadChannelsSSD *badch = new AliITSBadChannelsSSD();
+  AliITSPedestalSSD *pedel = new AliITSPedestalSSD();
+  
   TString runType = GetRunType();
   if(runType == "ELECTRONICS_CALIBRATION_RUN") {
     
@@ -79,49 +85,6 @@ UInt_t AliITSPreprocessorSSD::Process(TMap* /*dcsAliasMap*/)
        TIter next(list);
        TObjString *ok;
        
-       //---------------------------------------
-       // in case some module was not calibrated!
-       for(Int_t i=0; i<fgkNumberOfSSD; i++) {
-         AliITSNoiseSSD *calib = new AliITSNoiseSSD();
-         calib->SetMod((UShort_t) i+500);
-         calib->SetNNoiseP(768);
-         calib->SetNNoiseN(768);
-         // take a reasonable averaged value for the noise on P- and N-side strips
-         for(Int_t j=0; j<768; j++) {
-           calib->AddNoiseP(j,1000.);
-           calib->AddNoiseN(j,1000.);
-         }
-         calib_array.AddAt(calib,i);
-       }
-       //-----------------------------------------
-       //---------------------------------------
-       // in case some module was not calibrated!
-       for(Int_t i=0; i<fgkNumberOfSSD; i++) {
-         AliITSBadChannelsSSD *badch = new AliITSBadChannelsSSD();
-         badch->SetMod((UShort_t) i+500);
-         badch->SetNBadPChannelsList(768);
-         badch->SetNBadNChannelsList(768);
-         badch_array.AddAt(badch,i);
-       }
-       //-----------------------------------------
-       
-       //---------------------------------------
-       // in case some module was not calibrated!
-       for(Int_t i=0; i<fgkNumberOfSSD; i++) {
-         AliITSPedestalSSD *pedel = new AliITSPedestalSSD();
-         pedel->SetMod((UShort_t) i+500);
-         pedel->SetNPedestalP(768);
-         pedel->SetNPedestalN(768);
-         for(Int_t j=0; j<768; j++) {
-           pedel->AddPedestalP(j,0.);
-           pedel->AddPedestalN(j,0.);
-         }
-         ped_array.AddAt(pedel,i);
-       }
-       //-----------------------------------------
-       
-       
-       
        // expect to iterate 3 times (LDC0, LDC1, LDC2)
        while ( (ok = (TObjString*) next()) ) {                               
          
@@ -139,49 +102,47 @@ UInt_t AliITSPreprocessorSSD::Process(TMap* /*dcsAliasMap*/)
                return 2;
            }
            
-           TObjArray *cal; 
+           AliITSNoiseSSD *cal; 
            f->GetObject("Noise;1", cal); 
            if(!cal) {
                Log("File does not contain expected data for the noise!");
                delete list;
                return 3;
            }       
-
-           Int_t nmod = cal->GetEntries();
-           Log(Form("\n#Mod %d", nmod ));
-           for(Int_t mod=0; mod<nmod; mod++) {
-             AliITSNoiseSSD *calib = (AliITSNoiseSSD*) cal->At(mod);
-             Log(Form("\nModId %d", calib->GetMod() ));
-             if((calib->GetMod()<500)||(calib->GetMod()>2198)) continue;
-             calib_array.AddAt(calib,calib->GetMod()-500);
-           }
-
-           TObjArray *bad; 
+           AliITSPedestalSSD *ped;
+           f->GetObject("Pedestal;1", ped); 
+           if(!ped) {
+               Log("File does not contain expected data for the pedestals!");
+               delete list;
+               return 5;
+           }       
+           AliITSBadChannelsSSD *bad;
            f->GetObject("BadChannels;1", bad); 
            if(!bad) {
                Log("File does not contain expected data for bad channels  !");
                delete list;
                return 4;
            }       
-           nmod = bad->GetEntries();
-           for(Int_t mod=0; mod<nmod; mod++) {
-             AliITSBadChannelsSSD *badch = (AliITSBadChannelsSSD*) bad->At(mod);
-             if((badch->GetMod()<500)||(badch->GetMod()>2198)) continue;
-             badch_array.AddAt(badch,badch->GetMod()-500);
-           }
 
-           TObjArray *ped; 
-           f->GetObject("Pedestal;1", ped); 
-           if(!ped) {
-               Log("File does not contain expected data for the pedestals!");
-               delete list;
-               return 5;
-           }       
-           nmod = ped->GetEntries();
-           for(Int_t mod=0; mod<nmod; mod++) {
-             AliITSPedestalSSD *pedel = (AliITSPedestalSSD*) ped->At(mod);
-             if((pedel->GetMod()<500)||(pedel->GetMod()>2198)) continue;
-             ped_array.AddAt(pedel,pedel->GetMod()-500);
+           for(Int_t module=0; module<fgkNumberOfSSD; module++) {
+             for(Int_t strip=0; strip<768; strip++) {
+               if(cal->GetNoiseP(module,strip)) 
+                 calib->AddNoiseP(module,strip,cal->GetNoiseP(module,strip));
+               if(cal->GetNoiseN(module,strip)) 
+                 calib->AddNoiseN(module,strip,cal->GetNoiseN(module,strip));
+               if(ped->GetPedestalP(module,strip)) 
+                 pedel->AddPedestalP(module,strip,
+                                     ped->GetPedestalP(module,strip));
+               if(ped->GetPedestalN(module,strip)) 
+                 pedel->AddPedestalN(module,strip,
+                                     ped->GetPedestalN(module,strip));
+               if(bad->GetBadChannelP(module,strip)) 
+                 badch->AddBadChannelP(module,strip,
+                                        bad->GetBadChannelP(module,strip));
+               if(bad->GetBadChannelN(module,strip)) 
+                 badch->AddBadChannelN(module,strip,
+                                        bad->GetBadChannelN(module,strip));
+             }
            }
 
            f->Close(); delete f;           
@@ -206,17 +167,17 @@ UInt_t AliITSPreprocessorSSD::Process(TMap* /*dcsAliasMap*/)
       metaData.SetResponsible("Enrico Fragiacomo");
       metaData.SetComment("Fills noise, pedestal and bad channels TObjArray");
   
-      if(!Store("Calib", "NoiseSSD", &calib_array, &metaData, 0, 1)) {
+      if(!Store("Calib", "NoiseSSD", (TObject*) &calib, &metaData, 0, 1)) {
        Log("no store");
         return 1;
       }  
       
-      if(!Store("Calib", "BadChannelsSSD", &badch_array, &metaData, 0, 1)) {
+      if(!Store("Calib", "BadChannelsSSD", (TObject*) &badch, &metaData, 0, 1)) {
        Log("no store");
         return 1;
       }  
       
-      if(!StoreReferenceData("Calib","PedestalSSD", &ped_array, &metaData)) {
+      if(!StoreReferenceData("Calib","PedestalSSD",  (TObject*) &pedel, &metaData)) {
        Log("no store");
        return 1;
       }
index 4c01c9b..4a06149 100644 (file)
@@ -402,7 +402,7 @@ void AliITSsimulationSSD::ApplyNoise(AliITSpList *pList,Int_t module){
   for(ix=0;ix<GetNStrips();ix++){      // loop over strips
     
     // noise is gaussian
-    noise  = (Double_t) gRandom->Gaus(0,res->GetNoiseP().At(ix));
+    noise  = (Double_t) gRandom->Gaus(0,res->GetNoiseP(ix));
     
     // need to calibrate noise 
     // NOTE. noise from the calibration database comes uncalibrated, 
@@ -422,7 +422,7 @@ void AliITSsimulationSSD::ApplyNoise(AliITSpList *pList,Int_t module){
   
     // Nside
   for(ix=0;ix<GetNStrips();ix++){      // loop over strips
-    noise  = (Double_t) gRandom->Gaus(0,res->GetNoiseN().At(ix));// give noise to signal
+    noise  = (Double_t) gRandom->Gaus(0,res->GetNoiseN(ix));// give noise to signal
     noise *= (Double_t) res->GetGainN(ix); 
     noise /= res->GetDEvToADC(1.);
     signal = noise + fMapA2->GetSignal(1,ix);//get signal from map
@@ -484,8 +484,8 @@ void AliITSsimulationSSD::ApplyDeadChannels(Int_t module) {
 
   for(Int_t i=0;i<GetNStrips();i++){
 
-    if(res->IsPChannelBad(i)) res->AddGainP(i,0.0);
-    if(res->IsNChannelBad(i)) res->AddGainN(i,0.0);
+    if(res->IsPChannelBad(i)) res->SetGainP(i,0.0);
+    if(res->IsNChannelBad(i)) res->SetGainN(i,0.0);
 
   } // loop over strips 
 
@@ -661,10 +661,13 @@ void AliITSsimulationSSD::ChargeToSignal(Int_t module,AliITSpList *pList) {
 
        // threshold for zero suppression is set on the basis of the noise
        // A good value is 3*sigma_noise
-       if(k==0) threshold = res->GetNoiseP().At(ix);
-       else threshold = res->GetNoiseN().At(ix);
+       if(k==0) threshold = res->GetNoiseP(ix);
+       else threshold = res->GetNoiseN(ix);
+
        threshold *= res->GetZSThreshold(); // threshold at 3 sigma noise
+
        if(signal < threshold) continue;
+       //cout<<signal<<" "<<threshold<<endl;
 
        digits[0] = k;
        digits[1] = ix;
index 5ffa27a..05c3f11 100644 (file)
Binary files a/ITS/Calib/BadChannelsSSD/Run0_999999999_v0_s0.root and b/ITS/Calib/BadChannelsSSD/Run0_999999999_v0_s0.root differ
diff --git a/ITS/Calib/GainSSD/Run0_999999999_v0_s0.root b/ITS/Calib/GainSSD/Run0_999999999_v0_s0.root
new file mode 100644 (file)
index 0000000..42f0443
Binary files /dev/null and b/ITS/Calib/GainSSD/Run0_999999999_v0_s0.root differ
diff --git a/ITS/Calib/GainSSD/Run0_9999999_v0_s0.root b/ITS/Calib/GainSSD/Run0_9999999_v0_s0.root
deleted file mode 100644 (file)
index 6be4523..0000000
Binary files a/ITS/Calib/GainSSD/Run0_9999999_v0_s0.root and /dev/null differ
index 5815a64..faad8bc 100644 (file)
Binary files a/ITS/Calib/NoiseSSD/Run0_999999999_v0_s0.root and b/ITS/Calib/NoiseSSD/Run0_999999999_v0_s0.root differ
index 269f965..be7a98b 100644 (file)
Binary files a/ITS/Calib/PedestalSSD/Run0_999999999_v0_s0.root and b/ITS/Calib/PedestalSSD/Run0_999999999_v0_s0.root differ
index 19fbee8..4eb6ee5 100644 (file)
@@ -1,4 +1,4 @@
-void MakeCalibrationSSD(Int_t firstRun=0,Int_t lastRun=9999999 ){
+void MakeCalibrationSSD(Int_t firstRun=0,Int_t lastRun=999999999 ){
   
   if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
     AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/");
@@ -8,63 +8,30 @@ void MakeCalibrationSSD(Int_t firstRun=0,Int_t lastRun=9999999 ){
   md1->SetObjectClassName("AliITSCalibration");
   md1->SetResponsible("Enrico Fragiacomo");
   md1->SetBeamPeriod(0);
-  md1->SetAliRootVersion("head 23/08/07"); //root version
+  md1->SetAliRootVersion("trunk090708"); //root version
 
   AliCDBId idNoiseSSD("ITS/Calib/NoiseSSD",firstRun, lastRun);
+  AliCDBId idPedestalSSD("ITS/Calib/PedestalSSD",firstRun, lastRun);
   AliCDBId idGainSSD("ITS/Calib/GainSSD",firstRun, lastRun);
   AliCDBId idBadChannelsSSD("ITS/Calib/BadChannelsSSD",firstRun, lastRun);
   
-  TObjArray noiseSSD(1698);
-  TObjArray gainSSD(1698);
-  TObjArray badchannelsSSD(1698);
+  AliITSNoiseSSD *noiseSSD = new AliITSNoiseSSD();
+  AliITSPedestalSSD *pedestalSSD = new AliITSPedestalSSD();
+  AliITSGainSSD *gainSSD = new AliITSGainSSD();
+  AliITSBadChannelsSSD *badchannelsSSD = new AliITSBadChannelsSSD();
 
-  noiseSSD.SetOwner(kFALSE);
-  gainSSD.SetOwner(kFALSE);
-  badchannelsSSD.SetOwner(kFALSE);
-  
-  Double_t noiseP[768];
-  Double_t noiseN[768];
-
-  Double_t gainP[768];
-  Double_t gainN[768];
-  
-  // loop over SSD modules
-  for(Int_t i=0;i<1698;i++){
-    
-    AliITSNoiseSSD* noise = new AliITSNoiseSSD();
-    AliITSGainSSD* gain = new AliITSGainSSD();
-    AliITSBadChannelsSSD* badchannels = new AliITSBadChannelsSSD();
-
-    // 768 strips on P- and N-side
-    noise->SetNNoiseP(768);
-    noise->SetNNoiseN(768);
-    gain->SetNGainP(768);
-    gain->SetNGainN(768);
-    badchannels->SetNBadPChannelsList(10);
-    badchannels->SetNBadNChannelsList(10);
-
-    // take a reasonable averaged value for the noise on P- and N-side strips 
+  for(Int_t i=0; i<1698; i++) {
     for(Int_t j=0; j<768; j++) {
-      noise->AddNoiseP(j,2.);
-      gain->AddGainP(j,1.);
-      noise->AddNoiseN(j,4.);
-      gain->AddGainN(j,1.);
+      noiseSSD->AddNoiseP(i,j,3.);
+      noiseSSD->AddNoiseN(i,j,5.);
+      gainSSD->AddGainP(i,j,0.8);
+      gainSSD->AddGainN(i,j,1.2);
     }
-
-    // 10 random strips per module tagged as "bad"
-    for(Int_t j=0; j<10; j++) {
-      badchannels->AddBadPChannel(j,gRandom->Uniform(0,767));
-      badchannels->AddBadNChannel(j,gRandom->Uniform(0,767));
-    }
-
-    noiseSSD.Add(noise);
-    gainSSD.Add(gain);
-    badchannelsSSD.Add(badchannels);
-
   }
 
-  AliCDBManager::Instance()->GetDefaultStorage()->Put(&noiseSSD, idNoiseSSD, md1);
-  AliCDBManager::Instance()->GetDefaultStorage()->Put(&gainSSD, idGainSSD, md1);
-  AliCDBManager::Instance()->GetDefaultStorage()->Put(&badchannelsSSD, idBadChannelsSSD, md1);
-
+  AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) noiseSSD, idNoiseSSD, md1);
+  AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) gainSSD, idGainSSD, md1);
+  AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) badchannelsSSD, idBadChannelsSSD, md1);
+  AliCDBManager::Instance()->GetDefaultStorage()->Put( (TObject*) pedestalSSD, idPedestalSSD, md1);
+  
 }