Clean-up of response classes in order reduce momory occupancy (F. Prino)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 6 Jun 2008 14:26:57 +0000 (14:26 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 6 Jun 2008 14:26:57 +0000 (14:26 +0000)
19 files changed:
ITS/AliITSCalibration.h
ITS/AliITSCalibrationSDD.h
ITS/AliITSCalibrationSPD.h
ITS/AliITSCalibrationSSD.h
ITS/AliITSdcsSSD.cxx [deleted file]
ITS/AliITSdcsSSD.h [deleted file]
ITS/AliITSresponse.cxx
ITS/AliITSresponse.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSresponseSPD.h
ITS/AliITSresponseSSD.cxx
ITS/AliITSresponseSSD.h
ITS/AliITSsimulationSDD.cxx
ITS/Calib/RespSDD/Run0_999999999_v0_s0.root
ITS/Calib/RespSPD/Run0_9999999_v0_s0.root
ITS/ITSsimLinkDef.h
ITS/StoreCalibSDD.C
ITS/libITSsim.pkg

index 3e2131a..d295965 100644 (file)
@@ -68,8 +68,6 @@ class AliITSCalibration : public TObject {
     virtual const char  *DataType() const {return fDataType.Data();}
     // Type of data - real or simulated
     virtual void    SetDataType(const char *data="simulated") {fDataType=data;}
-    // Set parameters options: "same" or read from "file" or "SetInvalid" or...
-    //  virtual void   SetParamOptions(const char*,const char*) = 0;
     // Set noise parameters 
     virtual void   SetNoiseParam(Double_t, Double_t) = 0;
     // Number of parameters to be set
@@ -77,8 +75,6 @@ class AliITSCalibration : public TObject {
     // Set detector parameters: gain, coupling ...
     virtual  void   SetDetParam(Double_t *) = 0;
 
-    // Parameters options
-    //  virtual void   ParamOptions(char *,char*) const = 0;
     virtual Int_t  NDetParam() const = 0;
     virtual void   GetDetParam(Double_t *) const = 0;
     virtual void   GetNoiseParam(Double_t&, Double_t&) const = 0;
@@ -157,11 +153,6 @@ class AliITSCalibration : public TObject {
 
     virtual void SetDiffCoeff(Float_t p1, Float_t p2) {fResponse->SetDiffCoeff(p1,p2);}
     virtual void DiffCoeff(Float_t &diff,Float_t &diff1) const {fResponse->DiffCoeff(diff,diff1);} 
-    virtual void SetFilenames(const char *f1="",const char *f2="",
-                                const char *f3="") {fResponse->SetFilenames(f1,f2,f3);}    
-    virtual void Filenames(char* input,char* baseline,char* param) {fResponse->Filenames(input,baseline,param);}
-    virtual void SetOutputOption(Bool_t write=kFALSE) {fResponse->SetOutputOption(write);}
-    virtual Bool_t OutputOption() const {return fResponse->OutputOption();} 
 
  protected:
     AliITSCalibration(const AliITSCalibration &ob); // copy constructor
index d71f5d7..8982892 100644 (file)
@@ -159,8 +159,6 @@ class AliITSCalibrationSDD : public AliITSCalibration {
       if(nAnode<256) return fDrSpeed0->GetDriftSpeed(0,nAnode);
       else return fDrSpeed1->GetDriftSpeed(0,nAnode-256);
     }
-    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 void SetZeroSupp (const char *opt) {((AliITSresponseSDD*)fResponse)->SetZeroSupp(opt);} 
     virtual const char *GetZeroSuppOption() const {return ((AliITSresponseSDD*)fResponse)->ZeroSuppOption();}
index 92f374d..509d231 100644 (file)
@@ -67,8 +67,6 @@ class AliITSCalibrationSPD :  public AliITSCalibration {
 
     virtual void GetCouplingOption(char *opt) const {((AliITSresponseSPD*)fResponse)->CouplingOption(opt);}
     virtual void SetCouplingOption(const char* opt) {((AliITSresponseSPD*)fResponse)->SetCouplingOption(opt);}
-    virtual void SetParamOptions(const char* a,const char* b) {((AliITSresponseSPD*)fResponse)->SetParamOptions(a,b);}
-    virtual void GetParamOptions(char *a,char* b) const {((AliITSresponseSPD*)fResponse)->ParamOptions(a,b);}
     virtual void SetSigmaDiffusionAsymmetry(Double_t ecc) {((AliITSresponseSPD*)fResponse)->SetSigmaDiffusionAsymmetry(ecc);}
     virtual void GetSigmaDiffusionAsymmetry(Double_t &ecc) const {((AliITSresponseSPD*)fResponse)->GetSigmaDiffusionAsymmetry(ecc);}
     
index 3755539..1f4ddf6 100644 (file)
@@ -125,8 +125,6 @@ class AliITSCalibrationSSD : public AliITSCalibration {
     virtual void   Thresholds(Double_t & /* a */, Double_t & /* b */) const 
       {NotImplemented("Thresholds");}
   
-    virtual void SetParamOptions(const char *opt1, const char *opt2) {((AliITSresponseSSD*)fResponse)->SetParamOptions(opt1,opt2);}
-    virtual void GetParamOptions(char *opt1,char *opt2) const {((AliITSresponseSSD*)fResponse)->ParamOptions(opt1,opt2);}
     virtual void SetADCpereV(Double_t a=120./24888.9) {((AliITSresponseSSD*)fResponse)->SetADCpereV(a);}
     virtual Double_t GetDEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->DEvToADC(eV);}
     virtual Int_t IEvToADC(Double_t eV) const {return ((AliITSresponseSSD*)fResponse)->IEvToADC(eV);} 
diff --git a/ITS/AliITSdcsSSD.cxx b/ITS/AliITSdcsSSD.cxx
deleted file mode 100644 (file)
index e08796c..0000000
+++ /dev/null
@@ -1,224 +0,0 @@
-#include <TRandom.h>
-#include <TArrayS.h>
-
-#include "AliITSdcsSSD.h"
-#include "AliITSCalibrationSSD.h"
-#include "AliITSresponseSSD.h"
-#include "AliITSsegmentationSSD.h"
-///////////////////////////////////////////////////////////////////////////
-//                                                                       //
-//  Class AliITSdcsSSD                                                   //
-//  describes Detector Control System parameters for one SSD module.     //
-//                                                                       //
-//  This class stores parametrers such as gain, threshold                //
-//  capacitive coupling.                                                 //
-//                                                                       //
-//  Class takes care of invalid strip menagement during                  //
-//  simulation and runtime                                               //
-//                                                                       //
-//                                                                       //
-//  created at: Warsaw University of Technology                          //
-//  ver. 1.0    WARSAW, 23.12.1999                                       //
-//                                                                       //
-///////////////////////////////////////////////////////////////////////////
-
-ClassImp(AliITSdcsSSD)
-
-// Constructor and Destructor
-//______________________________________________________________________
-  AliITSdcsSSD::AliITSdcsSSD():
-fCouplingPR(0),
-fCouplingPL(0),
-fCouplingNR(0),
-fCouplingNL(0),
-fNstrips(0),
-fNInvalid(0),
-fISigma(0),
-fInvalidP(0),
-fInvalidN(0){
-    // Default Constructor
-
-}
-//______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(AliITSsegmentation *seg, AliITSCalibration *resp):
-fCouplingPR(0),
-fCouplingPL(0),
-fCouplingNR(0),
-fCouplingNL(0),
-fNstrips(0),
-fNInvalid(0),
-fISigma(0),
-fInvalidP(0),
-fInvalidN(0){
-    // Standard constructor
-
-    fNstrips =(Float_t) (((AliITSsegmentationSSD*)seg)->Npx());
-    
-    fInvalidP = new TArrayS();
-    fInvalidN = new TArrayS();
-
-    Int_t npar=((AliITSCalibrationSSD*)resp)->NDetParam();
-    if (npar < 6) {
-       Warning("AliITSdcsSSD","I need 6 parameters ");
-       npar=6;
-    } // end if
-
-    Double_t *detpar= new Double_t[npar];
-    resp->GetDetParam(detpar);
-
-    fNInvalid = detpar[0];
-    fISigma   = detpar[1];
-
-    fCouplingPR = detpar[2];
-    fCouplingPL = detpar[3];
-    fCouplingNR = detpar[4];
-    fCouplingNL = detpar[5];
-
-    char opt[30],dummy[20];
-    ((AliITSCalibrationSSD*)resp)->GetParamOptions(opt,dummy);
-    if (strstr(opt,"SetInvalid")) SetInvalidMC(fNInvalid,fISigma);
-
-    delete [] detpar;
-}
-//______________________________________________________________________
-AliITSdcsSSD::~AliITSdcsSSD() {
-    // destructor
-
-    delete fInvalidP;
-    delete fInvalidN;
-}
-//______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source) : TObject(source),
-fCouplingPR(source.fCouplingPR),
-fCouplingPL(source.fCouplingPL),
-fCouplingNR(source.fCouplingNR),
-fCouplingNL(source.fCouplingNL),
-fNstrips(source.fNstrips),
-fNInvalid(source.fNInvalid),
-fISigma(source.fISigma),
-fInvalidP(source.fInvalidP),
-fInvalidN(source.fInvalidN){
-    //     Copy Constructor 
-
-}
-//_________________________________________________________________________
-AliITSdcsSSD& AliITSdcsSSD::operator=(const AliITSdcsSSD &source) {
-    //    Assignment operator
-
-    if(&source == this) return *this;
-
-    this->fCouplingPR = source.fCouplingPR;
-    this->fCouplingPL = source.fCouplingPL;
-    this->fCouplingNR = source.fCouplingNR;
-    this->fCouplingNL = source.fCouplingNL;
-    this->fNstrips = source.fNstrips;
-    this->fNInvalid = source.fNInvalid;
-    this->fISigma = source.fISigma;
-    this->fInvalidP = source.fInvalidP;
-    this->fInvalidN = source.fInvalidN;
-
-    return *this;
-}
-//_____________________________________________________________________
-//
-//  Methods for creating invalid strips
-//_____________________________________________________________________
-void AliITSdcsSSD::SetInvalidMC(Float_t mean, Float_t sigma) {
-    // set invalid MC
-
-    SetInvalidParam(mean, sigma);
-    SetInvalidMC();
-}
-//______________________________________________________________________
-void AliITSdcsSSD::SetInvalidMC() {
-    // set invalid MC
-    Int_t pside;
-    Int_t nside;
-    Int_t i;
-    Int_t strip;
-
-    pside = (Int_t)gRandom->Gaus(fNInvalid, fISigma);
-    nside = (Int_t)gRandom->Gaus(fNInvalid, fISigma);
-    
-    fInvalidP->Set(pside);
-    fInvalidN->Set(nside);
-     
-    for(i=0 ;i<pside; i++) {
-       strip = (Int_t)(gRandom->Rndm() * fNstrips);
-       fInvalidP->AddAt(strip, i); 
-    } // end for i
-    
-    for(i=0 ;i<nside; i++) {
-       strip = (Int_t)(gRandom->Rndm() * fNstrips);
-       fInvalidN->AddAt(strip, i); 
-    } // end for i
-}
-//______________________________________________________________________
-void AliITSdcsSSD::SetInvalidParam(Float_t mean, Float_t sigma) {
-    // set invalid param
-
-    fNInvalid = mean;
-    fISigma = sigma;
-
-    fNInvalid = (fNInvalid<0)? 0 : fNInvalid;
-    fNInvalid = (fNInvalid>fNstrips)? fNstrips: fNInvalid;
-    
-    fISigma = (fISigma < 0)? 0 : fISigma;
-    fISigma = (fISigma > fNstrips/10) ? fNstrips/10 : fISigma;
-}
-//______________________________________________________________________
-void AliITSdcsSSD::GetInvalidParam(Float_t &mean, Float_t &sigma) const {
-    // get invalid param
-
-    mean = fNInvalid;
-    sigma = fISigma;
-}
-//_____________________________________________________________________
-//
-//  Methods for accessing to invalid strips
-//_____________________________________________________________________
-Bool_t AliITSdcsSSD::IsValidP(Int_t strip) {
-    // isvalidP
-    Int_t nElem = fInvalidP->GetSize();
-
-    for(Int_t i = 0; i<nElem; i++) if(fInvalidP->At(i) == strip) return kFALSE;
-    return kTRUE;
-}
-//______________________________________________________________________
-Bool_t AliITSdcsSSD::IsValidN(Int_t strip) {
-    // is valid N
-    Int_t nElem = fInvalidN->GetSize();
-
-    for(Int_t i = 0; i<nElem; i++) if(fInvalidN->At(i) == strip) return kFALSE;
-    return kTRUE;
-}
-//______________________________________________________________________
-TArrayS* AliITSdcsSSD::GetInvalidP() {
-    // get invalid P
-
-    return fInvalidP;
-}
-//______________________________________________________________________
-TArrayS* AliITSdcsSSD::GetInvalidN() {
-    // get invalid N
-
-    return fInvalidN;
-}
-//______________________________________________________________________
-Int_t AliITSdcsSSD::GetNInvalidP(){
-    // get numeber of invalid P
-
-    return fInvalidP->GetSize();
-}
-//______________________________________________________________________
-Int_t AliITSdcsSSD::GetNInvalidN() {
-    // get number of invalid N
-
-    return fInvalidN->GetSize();
-}
-//_____________________________________________________________________
-
-
-
-
-
diff --git a/ITS/AliITSdcsSSD.h b/ITS/AliITSdcsSSD.h
deleted file mode 100644 (file)
index f7ad61b..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-#ifndef ALIITSDCSSSD_H
-#define ALIITSDCSSSD_H
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-///////////////////////////////////////////////////////////////////////////
-//                                                                       //
-//  Class AliITSdcsSSD                                                   //
-//  describes Detector Control System parameters for one SSD module.     //
-//                                                                       //
-//  This class stores parametrers such as gain, threshold                //
-//  capacitive coupling.                                                 //
-//                                                                       //
-//  Class takes care of invalid strip menagement during                  //
-//  simulation and runtime                                               //
-//                                                                       //
-//                                                                       //
-//  created at: Warsaw University of Technology                          //
-//  ver. 1.0    WARSAW, 23.12.1999                                       //
-//                                                                       //
-///////////////////////////////////////////////////////////////////////////
-
-#include <TObject.h>
-
-class TArrayS;
-class TRandom;
-class AliITSsegmentation;
-class AliITSCalibration;
-
-class AliITSdcsSSD: public TObject {
-
- public:
-    AliITSdcsSSD(); // Default constructor
-    // Standard constructor
-    AliITSdcsSSD(AliITSsegmentation *s, AliITSCalibration *r); 
-    virtual ~AliITSdcsSSD(); // Destructor
-    AliITSdcsSSD(const AliITSdcsSSD &source); // copy constructor
-    AliITSdcsSSD& operator=(const AliITSdcsSSD &source); // assignment operator
-    //________________________________________________________________
-    // 
-    // Invalid strips management methods
-    //________________________________________________________________
-    // Parameters for invalid strips MonteCarlo
-    void SetInvalidParam(Float_t mean, Float_t sigma);
-    void GetInvalidParam(Float_t &mean, Float_t &sigma) const;
-    // Methods for creating invalid strips
-    void SetInvalidMC(Float_t mean, Float_t sigma);
-    void SetInvalidMC();
-    // Testing if strip is valid
-    Bool_t  IsValidN(Int_t strip);      //True if strip works properly
-    Bool_t  IsValidP(Int_t strip);      //True if strip works properly    
-    // Access to invalid strips
-    TArrayS *GetInvalidP();             //Array of invalid P strips
-    TArrayS *GetInvalidN();             //Array of invalid N strips
-    Int_t    GetNInvalidP();            //Number of invalid P strips
-    Int_t    GetNInvalidN();            //Number of invalid N strips    
-    // Creating invalid strips
-    void    SetInvalidP(Int_t,Bool_t){}//Set invalid if true
-    void    SetInvalidN(Int_t,Bool_t){}//Set invalid if true
-    Float_t  GetCouplingPR() const {// couplings
-      return fCouplingPR;}
-    Float_t  GetCouplingPL() const {// couplings
-      return fCouplingPL;}
-    Float_t  GetCouplingNR() const {// couplings
-      return fCouplingNR;}
-    Float_t  GetCouplingNL() const {// couplings
-      return fCouplingNL;}
-    
- protected:
-    //_____________________________________________
-    //
-    // Parameters for invalid strips simulatation 
-    //_____________________________________________    
-    Float_t  fCouplingPR;  // couplings
-    Float_t  fCouplingPL;  // couplings
-    Float_t  fCouplingNR;  // couplings
-    Float_t  fCouplingNL;  // couplings   
-
-    Float_t   fNstrips;    //Number of strips
-    Float_t   fNInvalid;   //Mean number of invalid strips (for simulation) 
-    Float_t   fISigma;     //RMS of invalid strips (Gaussian)
-
-    TArrayS  *fInvalidP;   //Array of invalid strips on P-side
-    TArrayS  *fInvalidN;   //Array of invalid strips on N-side
-
-    ClassDef(AliITSdcsSSD, 1)     // ITS SSD DCS specific class
-
-};
-#endif
index e96886e..4288161 100644 (file)
@@ -29,10 +29,6 @@ ClassImp(AliITSresponse)
 //______________________________________________________________________
 AliITSresponse::AliITSresponse():
 TObject(),
-fFileName1(),
-fFileName2(),
-fFileName3(),
-fWrite(kFALSE),
 fDiffCoeff(0.),
 fDiffCoeff1(0.){
   
index d61e664..448bd3e 100644 (file)
@@ -27,20 +27,7 @@ class AliITSresponse : public TObject {
       fDiffCoeff=p1; fDiffCoeff1=p2;}
     virtual void  DiffCoeff(Float_t &diff,Float_t &diff1) const {
       diff=fDiffCoeff; diff1=fDiffCoeff1;}
-    virtual void  SetParamOptions(const char*,const char*) = 0;
-   
-    virtual void  ParamOptions(char *,char*) const = 0;
-    virtual void  SetFilenames(const char *f1="",const char *f2="",
-                              const char *f3=""){
-       fFileName1=f1; fFileName2=f2; fFileName3=f3;}
-
-    virtual void   Filenames(char* input,char* baseline,char* param) {
-        strcpy(input,fFileName1.Data());  strcpy(baseline,fFileName2.Data());  
-        strcpy(param,fFileName3.Data());}
 
-    virtual void    SetOutputOption(Bool_t write=kFALSE) {fWrite = write;}
-       
-    virtual Bool_t  OutputOption() const {return fWrite;}
 
  protected:
 
@@ -48,17 +35,11 @@ class AliITSresponse : public TObject {
          Warning(method,"This method is not implemented for this sub-class");}
    
  private:
-
-    TString  fFileName1; // input keys : run, module #
-    TString  fFileName2; // baseline & noise val or output code
-                                // signal or monitored bgr.
-    TString  fFileName3; // param values or output coded signal
-    Bool_t   fWrite;     // Write option for the compression algorithms
     Float_t  fDiffCoeff;      // Diffusion Coefficient (scaling the time)
     Float_t  fDiffCoeff1;     // Diffusion Coefficient (constant term)
     
 
-    ClassDef(AliITSresponse,4) // Detector type response virtual base class 
+    ClassDef(AliITSresponse,5) // Detector type response virtual base class 
 };
 
 #endif
index e1d4dd9..b857dbd 100644 (file)
@@ -33,11 +33,9 @@ const Float_t AliITSresponseSDD::fgkDynamicRangeDefault = 132.;
 const Float_t AliITSresponseSDD::fgkfChargeLossDefault = 0;
 const Float_t AliITSresponseSDD::fgkDiffCoeffDefault = 3.23;
 const Float_t AliITSresponseSDD::fgkDiffCoeff1Default = 30.;
-const TString AliITSresponseSDD::fgkParam1Default = "same";
-const TString AliITSresponseSDD::fgkParam2Default = "same";
 const TString AliITSresponseSDD::fgkOptionDefault = "ZS";
 const Float_t AliITSresponseSDD::fgkDriftSpeedDefault = 7.3;
-const Float_t AliITSresponseSDD::fgkTimeOffsetDefault = 53.57;
+const Float_t AliITSresponseSDD::fgkTimeOffsetDefault = 54.30;
 const Float_t AliITSresponseSDD::fgkADC2keVDefault = 5.243;
 const Float_t AliITSresponseSDD::fgkNsigmasDefault = 3.;
 const Int_t AliITSresponseSDD::fgkNcompsDefault = 121;
@@ -57,9 +55,7 @@ fMaxAdc(fgkMaxAdcDefault),
 fNsigmas(fgkNsigmasDefault),
 fGaus(),
 fNcomps(fgkNcompsDefault),
-fOption(),
-fParam1(),
-fParam2() {
+fOption(){
   // default constructor
   fGaus = 0;
   SetDiffCoeff(fgkDiffCoeffDefault,fgkDiffCoeff1Default);
@@ -69,9 +65,7 @@ fParam2() {
   SetElectronics();
   SetDynamicRange(fgkDynamicRangeDefault);
   SetChargeLoss(fgkfChargeLossDefault);
-  SetParamOptions(fgkParam1Default.Data(),fgkParam2Default.Data());
   SetZeroSupp(fgkOptionDefault);
-  SetOutputOption();
 }
 
 
index ae69204..41b53ea 100644 (file)
@@ -50,11 +50,6 @@ class AliITSresponseSDD : public AliITSresponse {
     virtual Float_t ADC2keV()const {return fADC2keV;}
     static Float_t DefaulttADC2keV() {return fgkADC2keVDefault;}
 
-    virtual void SetParamOptions(const char *opt1,const char *opt2) {
-       // Parameters: "same" or read from "file" 
-       fParam1=opt1; fParam2=opt2;}
-    virtual void   ParamOptions(char *opt1,char *opt2) const {// options
-       strcpy(opt1,fParam1.Data()); strcpy(opt2,fParam2.Data());}
  
     void    SetZeroSupp (const char *opt) {
        // Zero-suppression option - could be ZS or NOTSUPP
@@ -89,8 +84,6 @@ class AliITSresponseSDD : public AliITSresponse {
     static const Float_t fgkfChargeLossDefault; // default for fChargeLoss
     static const Float_t fgkDiffCoeffDefault; // default for fDiffCoeff
     static const Float_t fgkDiffCoeff1Default; // default for fDiffCoeff1 
-    static const TString fgkParam1Default; // default for fParam1
-    static const TString fgkParam2Default; // default for fParam2
     static const TString fgkOptionDefault; // default for fOption
     static const Float_t fgkDriftSpeedDefault; // default for drift speed
     static const Float_t fgkTimeOffsetDefault; // default for fTimeOffset
@@ -111,15 +104,13 @@ class AliITSresponseSDD : public AliITSresponse {
     TArrayF   *fGaus;          // Gaussian lookup table for signal generation
     Int_t      fNcomps;        // Number of samplings along the gaussian
     TString    fOption;        // Zero-suppresion option (ZS or non-ZS)
-    TString    fParam1;        // Read baselines from file option
-    TString    fParam2;        // Read compression algo thresholds from file
 
  private:
 
    AliITSresponseSDD(const AliITSresponseSDD &ob); // copy constructor
    AliITSresponseSDD& operator=(const AliITSresponseSDD & /* source */); // ass. op.
 
-    ClassDef(AliITSresponseSDD,11) // Base response class 
+    ClassDef(AliITSresponseSDD,12) // Base response class 
     
     };
 #endif
index 3258b48..b28e1e2 100644 (file)
@@ -23,10 +23,6 @@ class AliITSresponseSPD :  public AliITSresponse {
         {fEccDiff=ecc;}   
     virtual  void   GetSigmaDiffusionAsymmetry(Double_t &ecc) const 
         {ecc=fEccDiff;}
-    virtual void   SetParamOptions(const char* /* a */,const char* /* b */)
-      {NotImplemented("SetParamOptions");}
-    virtual void   ParamOptions(char *,char*) const
-      {NotImplemented("ParamOptions");} 
 
  protected:
 
index d6b585a..00431ff 100644 (file)
@@ -24,8 +24,6 @@
 
 
 const Float_t AliITSresponseSSD::fgkDiffCoeffDefault = 0.;
-const TString AliITSresponseSSD::fgkOption1Default = "";
-const TString AliITSresponseSSD::fgkOption2Default = "";
 const Double_t AliITSresponseSSD::fgkfCouplingPR = 0.01;
 const Double_t AliITSresponseSSD::fgkfCouplingPL = 0.01;
 const Double_t AliITSresponseSSD::fgkfCouplingNR = 0.01;
@@ -43,13 +41,10 @@ fCouplingPR(0),
 fCouplingPL(0),
 fCouplingNR(0),
 fCouplingNL(9),
-fZSThreshold(0),
-fOption1(),
-fOption2(){
+fZSThreshold(0){
     // Default Constructor
 
   SetDiffCoeff(fgkDiffCoeffDefault,0.);
-  SetParamOptions(fgkOption1Default.Data(),fgkOption2Default.Data());
   SetADCpereV();
   SetKeVperADC();
   SetCouplings(fgkfCouplingPR,fgkfCouplingPL,fgkfCouplingNR,fgkfCouplingNL);
@@ -64,9 +59,7 @@ fCouplingPR(ob.fCouplingPR),
 fCouplingPL(ob.fCouplingPL),
 fCouplingNR(ob.fCouplingNR),
 fCouplingNL(ob.fCouplingNL),
-fZSThreshold(ob.fZSThreshold),
-fOption1(ob.fOption1),
-fOption2(ob.fOption2) {
+fZSThreshold(ob.fZSThreshold){
   // Copy constructor
 
 }
index 15ee0d8..7a1d650 100644 (file)
@@ -16,14 +16,7 @@ class AliITSresponseSSD : public AliITSresponse {
  public:
     AliITSresponseSSD();
     virtual ~AliITSresponseSSD() {;}
-    virtual void    SetParamOptions(const char *opt1, const char *opt2) {
-       // parameters: "SetInvalid" to simulate the invalid strips
-       fOption1=opt1; fOption2=opt2;
-    }
-    virtual void    ParamOptions(char *opt1,char *opt2) const {
-       // options
-       strcpy(opt1,fOption1.Data());  strcpy(opt2,fOption2.Data());
-    }
+
     void SetADCpereV(Double_t a=120./24888.9){fADCpereV = a;}
     Double_t DEvToADC(Double_t eV) const {return eV*fADCpereV;}
     Int_t IEvToADC(Double_t eV) const { // Converts electron-hole pairs to
@@ -49,8 +42,6 @@ class AliITSresponseSSD : public AliITSresponse {
 
 protected:
     static const Float_t fgkDiffCoeffDefault; //default for fDiffCoeff
-    static const TString fgkOption1Default; // default for fOption1
-    static const TString fgkOption2Default; // default for fOption2
 
     static const Double_t fgkfCouplingPR;  // default value for couplings
     static const Double_t fgkfCouplingPL;  // default value for couplings
@@ -68,13 +59,11 @@ protected:
     static const Int_t fgkZSThreshold; // threshold for the zero suppresion
     Int_t fZSThreshold; 
 
-     TString fOption1;         // Simulate invalid strips option
-    TString fOption2;         // Not used for the moment
 
  private:
     AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
     AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
 
-    ClassDef(AliITSresponseSSD,4) //Response class for SSD
+    ClassDef(AliITSresponseSSD,5) //Response class for SSD
 };
 #endif
index 0b22ce1..63d8780 100644 (file)
@@ -177,8 +177,6 @@ void AliITSsimulationSDD::Init(){
     fElectronics = new AliITSetfSDD(timeStep/fScaleSize,
                                     res->Electronics());
 
-    char opt1[20], opt2[20];
-    res->ParamOptions(opt1,opt2);
 
     fITS       = (AliITS*)gAlice->GetModule("ITS");
  
@@ -678,9 +676,7 @@ void AliITSsimulationSDD::ChargeToSignal(Int_t mod,Bool_t bAddNoise, Bool_t bAdd
   // add baseline, noise, gain, electronics and ADC saturation effects
   // apply dead channels
 
-  char opt1[20], opt2[20];
   AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(mod);
-  res->GetParamOptions(opt1,opt2);
   Double_t baseline=0; 
   Double_t noise=0; 
   Double_t gain=0; 
index afd10c1..8605149 100644 (file)
Binary files a/ITS/Calib/RespSDD/Run0_999999999_v0_s0.root and b/ITS/Calib/RespSDD/Run0_999999999_v0_s0.root differ
index 377348e..86a3781 100644 (file)
Binary files a/ITS/Calib/RespSPD/Run0_9999999_v0_s0.root and b/ITS/Calib/RespSPD/Run0_9999999_v0_s0.root differ
index 3db40d3..3305a5d 100644 (file)
@@ -50,7 +50,6 @@
 #pragma link C++ class  AliITSHuffman+;
 #pragma link C++ class  AliITSetfSDD+;
 // SSD simulation and reconstruction
-#pragma link C++ class  AliITSdcsSSD+;
 #pragma link C++ class AliITSsDigitize+;
 #pragma link C++ class AliITSDigitizer+;
 #pragma link C++ class AliITSFDigitizer+;
index ba11239..08b35bb 100644 (file)
@@ -2,7 +2,6 @@
 #include "AliCDBManager.h"
 #include "AliITSCalibrationSDD.h"
 #include "AliITSgeomTGeo.h"
-#include "AliITSresponseSDD.h"
 #include "AliCDBMetaData.h"
 #include "AliCDBStorage.h"
 #include "AliCDBId.h"
 #include <TRandom3.h>
 #endif
 
-void StoreCalibSDD(Int_t firstRun=0,Int_t lastRun=9999999, Int_t lastRunResp=999999999 ){
+void StoreCalibSDD(Int_t firstRun=0,Int_t lastRun=9999999){
   ///////////////////////////////////////////////////////////////////////
   // Macro to generate and store the calibration files for SDD         //
   // Generates:                                                        //
   //  1 file with 260 AliITSCalibrationSDD objects with                //
   //    baselines, noise, gain, drift speed for each module (CalibSDD) //
-  //  1 file with the AliITSrespionseSDD object (RespSDD)              //
   ///////////////////////////////////////////////////////////////////////
   
   if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
@@ -26,28 +24,15 @@ void StoreCalibSDD(Int_t firstRun=0,Int_t lastRun=9999999, Int_t lastRunResp=999
   }
   
 
-  AliCDBMetaData *md1= new AliCDBMetaData(); // metaData describing the object
-  md1->SetObjectClassName("TObjArray");
-  md1->SetResponsible("Francesco Prino");
-  md1->SetBeamPeriod(0);
-  md1->SetComment("Simulated data");
-
-  AliCDBMetaData *md2 = new AliCDBMetaData();
-  md2->SetObjectClassName("AliITSresponse");
-  md2->SetResponsible("Francesco Prino");
-  md2->SetBeamPeriod(0);
-  md2->SetComment("Simulated data");
-
+  AliCDBMetaData *md= new AliCDBMetaData(); // metaData describing the object
+  md->SetObjectClassName("TObjArray");
+  md->SetResponsible("Francesco Prino");
+  md->SetBeamPeriod(0);
+  md->SetComment("Simulated data");
 
   AliCDBId idCalSDD("ITS/Calib/CalibSDD",firstRun, lastRun);
-  TObjArray respSDD(260);
-  respSDD.SetOwner(kFALSE);
-
-
-
-  AliCDBId idRespSDD("ITS/Calib/RespSDD",firstRun, lastRunResp);
-  AliITSresponseSDD* rd = new AliITSresponseSDD();
-
+  TObjArray calSDD(260);
+  calSDD.SetOwner(kFALSE);
 
   // BAD modules data 
   const Int_t nbadmod=6;
@@ -249,14 +234,14 @@ void StoreCalibSDD(Int_t firstRun=0,Int_t lastRun=9999999, Int_t lastRunResp=999
       resd->SetChipBad(3);
     }
 
-    respSDD.Add(resd);
+    calSDD.Add(resd);
     printf("Added module %d\n",mod);
        }
     
   FILE* out = fopen("deadchannels.dat","w");
   for(Int_t i=0;i<260;i++){
     fprintf(out,"MODULE=%d\n",i);
-    AliITSCalibrationSDD* cl = (AliITSCalibrationSDD*)respSDD.At(i);
+    AliITSCalibrationSDD* cl = (AliITSCalibrationSDD*)calSDD.At(i);
     Int_t ndead=cl->GetDeadChannels();
     fprintf(out,"n %d\n",ndead);
     for(Int_t n=0;n<ndead;n++){
@@ -264,6 +249,5 @@ void StoreCalibSDD(Int_t firstRun=0,Int_t lastRun=9999999, Int_t lastRunResp=999
     }   
   }
   fclose(out);
-  AliCDBManager::Instance()->GetDefaultStorage()->Put(&respSDD, idCalSDD, md1);   
-  AliCDBManager::Instance()->GetDefaultStorage()->Put(rd, idRespSDD, md2);  
+  AliCDBManager::Instance()->GetDefaultStorage()->Put(&calSDD, idCalSDD, md);   
 }
index ff74be5..2a0e5a2 100644 (file)
@@ -19,7 +19,6 @@ SRCS =        AliITS.cxx \
                AliITSsimulationSSD.cxx \
                AliITSTableSSD.cxx \
                AliITSetfSDD.cxx \
-               AliITSdcsSSD.cxx \
                AliITSHuffman.cxx \
                AliITSstatistics.cxx \
                AliITSstatistics2.cxx \