Changes to use the raw OCDB for SDD (F. Prino)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 7 Mar 2011 17:48:57 +0000 (17:48 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 7 Mar 2011 17:48:57 +0000 (17:48 +0000)
13 files changed:
ITS/AliITSCalibrationSDD.cxx
ITS/AliITSCalibrationSDD.h
ITS/AliITSClusterFinderV2SDD.cxx
ITS/AliITSCorrMapSDD.cxx
ITS/AliITSCorrMapSDD.h
ITS/AliITSSimuParam.cxx
ITS/AliITSSimuParam.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSsimulationSDD.cxx
ITS/macrosSDD/ShowResponseSDD.C
ITS/macrosSDD/StoreCalibSDD.C
ITS/macrosSDD/StoreRespSDD.C

index 8704e18..f8a6eb0 100644 (file)
@@ -151,8 +151,20 @@ void AliITSCalibrationSDD::GetCorrections(Float_t z, Float_t x, Float_t &devz, F
   return;
 }
 //______________________________________________________________________
+void AliITSCalibrationSDD::GetShiftsForSimulation(Float_t z, Float_t x, Float_t &devz, Float_t &devx, AliITSsegmentationSDD* seg){
+  //correction of coordinates using the maps stored in the DB
+  Int_t nSide=seg->GetSideFromLocalX(x);
+  devz=0;
+//     if(nSide==0) devz=fMapAW0->GetCorrection(z,x,seg);
+//     else devz=fMapAW1->GetCorrection(z,x,seg);
+  devx=0;
+  if(nSide==0) devx=fMapTW0->GetShiftForSimulation(z,x,seg);
+  else devx=fMapTW1->GetShiftForSimulation(z,x,seg);
+  return;
+}
+//______________________________________________________________________
 void AliITSCalibrationSDD::PrintGains() const{
-  //
+  // Print Gains
 
   if( GetDeadChips() == 0 && 
       GetDeadChannels() == 0 )
index 5e329f7..971c45b 100644 (file)
@@ -145,6 +145,7 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     virtual Bool_t IsAMAt20MHz() const {return fAMAt20MHz;}
 
     void GetCorrections(Float_t z, Float_t x, Float_t &devz, Float_t &devx, AliITSsegmentationSDD* seg);
+    void GetShiftsForSimulation(Float_t z, Float_t x, Float_t &devz, Float_t &devx, AliITSsegmentationSDD* seg);
     virtual Float_t GetThresholdAnode(Int_t anode, Double_t nsigma=2.2) const {
       return nsigma*fNoiseAfterEl[anode];}
 
index 0c95c66..ea8d394 100644 (file)
@@ -291,8 +291,8 @@ FindClustersSDD(AliBin* bins[2], TBits* anodeFired[2],
          y=trk[1];
          z=trk[2]; 
          
+         q+=(driftTime*rsdd->GetADCvsDriftTime(fModule)); // correction for zero supp.
          q/=rsdd->GetADCtokeV(fModule);
-         q+=(driftTime*rsdd->GetChargevsTime()); // correction for zero supp.
          if(cal-> IsAMAt20MHz()) q*=2.; // account for 1/2 sampling freq.
          if(q<repa->GetMinClusterChargeSDD()) continue; // remove noise clusters
          
index 6a466d8..b22cba9 100644 (file)
@@ -31,24 +31,34 @@ const Int_t AliITSCorrMapSDD::fgkNDriftPtsDefault = 72;
 
 ClassImp(AliITSCorrMapSDD)
 //______________________________________________________________________
-AliITSCorrMapSDD::AliITSCorrMapSDD():
-TNamed("defaultmap",""),
-fNAnodePts(fgkNAnodePtsDefault),
-fNDriftPts(fgkNDriftPtsDefault)
+AliITSCorrMapSDD::AliITSCorrMapSDD():TNamed("defaultmap",""),
+  fNAnodePts(fgkNAnodePtsDefault),
+  fNDriftPts(fgkNDriftPtsDefault),
+  fXt1(0.),
+  fXt2(0.),
+  fXm1(0.),
+  fXm2(0.),
+  fDrLen(0.)
 {
   // default constructor  
 }
 //______________________________________________________________________
 AliITSCorrMapSDD::AliITSCorrMapSDD(Char_t *mapname):
-TNamed(mapname,""),
-fNAnodePts(fgkNAnodePtsDefault),
-fNDriftPts(fgkNDriftPtsDefault)
+  TNamed(mapname,""),
+  fNAnodePts(fgkNAnodePtsDefault),
+  fNDriftPts(fgkNDriftPtsDefault),
+  fXt1(0.),
+  fXt2(0.),
+  fXm1(0.),
+  fXm2(0.),
+  fDrLen(0.)
 {
   // standard constructor
 }
 //______________________________________________________________________
-Float_t AliITSCorrMapSDD::GetCorrection(Float_t z, Float_t x, AliITSsegmentationSDD *seg){
-  // returns correction in cm starting from local coordinates on the module
+void AliITSCorrMapSDD::ComputeGridPoints(Float_t z, Float_t x, AliITSsegmentationSDD *seg, Bool_t isReco){
+  // extracts points from the discrete grid with the correction map
+
   const Double_t kMicronTocm = 1.0e-4; 
   Int_t nAnodes=seg->Npz();
   Int_t nAnodesHybrid=seg->NpzHalf();
@@ -56,11 +66,70 @@ Float_t AliITSCorrMapSDD::GetCorrection(Float_t z, Float_t x, AliITSsegmentation
   if(bina>nAnodes)  AliError("Wrong anode anumber!");
   if(bina>=nAnodesHybrid) bina-=nAnodesHybrid;
   Float_t stept = seg->Dx()*kMicronTocm/(Float_t)fNDriftPts;
-  Float_t drLen= seg->Dx()*kMicronTocm-TMath::Abs(x);
-  Int_t bint = TMath::Abs((Int_t)(drLen/stept));
+  fDrLen= seg->Dx()*kMicronTocm-TMath::Abs(x);
+  Int_t bint = TMath::Abs((Int_t)(fDrLen/stept));
   if(bint==fNDriftPts) bint-=1;
-  if(bint>=fNDriftPts) AliError("Wrong bin number along drift direction!");
-  return kMicronTocm*GetCellContent(bina,bint);
+  if(bint>=fNDriftPts){
+    AliError("Wrong bin number along drift direction!");
+    bint=fNDriftPts-1;
+  }
+  fXt1=stept*bint;
+  fXm1=fXt1-GetCellContent(bina,bint)*kMicronTocm;
+  if((bint+1)<fNDriftPts){
+    fXt2=stept*(bint+1);
+    fXm2=fXt2-GetCellContent(bina,bint+1)*kMicronTocm;
+  }else{
+    fXt2=stept*(bint-1);
+    fXm2=fXt2-GetCellContent(bina,bint-1)*kMicronTocm;
+  }
+  if(isReco){
+    if(fXm1<fDrLen && fXm2>fDrLen) return;
+    if(bint==0 || bint==(fNDriftPts-1)) return;
+    if(fXm1>fDrLen){
+      for(Int_t itry=1; itry<=10; itry++){
+       Float_t xmtest=(bint-itry)*stept-GetCellContent(bina,bint-itry)*kMicronTocm;
+       if(xmtest<fDrLen){
+         fXt1=stept*(bint-itry);
+         fXt2=fXt1+stept;
+         fXm1=fXt1-GetCellContent(bina,bint-itry)*kMicronTocm;
+         fXm2=fXt2-GetCellContent(bina,bint+1-itry)*kMicronTocm;
+         return;
+       }
+      }
+    }
+    if(fXm2<fDrLen){
+      for(Int_t itry=1; itry<=10; itry++){
+       Float_t xmtest=(bint+1+itry)*stept-GetCellContent(bina,bint+1+itry)*kMicronTocm;
+       if(xmtest>fDrLen){
+         fXt1=stept*(bint+itry);
+         fXt2=fXt1+stept;
+         fXm1=fXt1-GetCellContent(bina,bint+itry)*kMicronTocm;
+         fXm2=fXt2-GetCellContent(bina,bint+1+itry)*kMicronTocm;
+         return;
+       }
+      }
+    }
+  }
+}
+//______________________________________________________________________
+Float_t AliITSCorrMapSDD::GetCorrection(Float_t z, Float_t x, AliITSsegmentationSDD *seg){
+  // returns correction in cm starting from local coordinates on the module
+  ComputeGridPoints(z,x,seg,kTRUE);
+  Float_t m=(fXt2-fXt1)/(fXm2-fXm1);
+  Float_t q=fXt1-m*fXm1;
+  Float_t xcorr=m*fDrLen+q;
+  // fDrLen is the measured drift distance, xcorr is the corresponding true
+  return (xcorr-fDrLen); 
+}
+//______________________________________________________________________
+Float_t AliITSCorrMapSDD::GetShiftForSimulation(Float_t z, Float_t x, AliITSsegmentationSDD *seg){
+  // returns shift to be appiled in digitizarion (in cm) starting from local coordinates on the module
+  ComputeGridPoints(z,x,seg,kFALSE);
+  Float_t m=(fXm2-fXm1)/(fXt2-fXt1);
+  Float_t q=fXm1-m*fXt1;
+  Float_t xshifted=m*fDrLen+q;
+  // fDrLen is the true drift distance, xshifted is the one with map shift
+  return (fDrLen-xshifted);
 }
 //______________________________________________________________________
 TH2F* AliITSCorrMapSDD::GetMapHisto() const{
index 2f149c6..6ab1434 100644 (file)
@@ -38,18 +38,12 @@ class AliITSCorrMapSDD : public TNamed {
   }
 
   Bool_t CheckAnodeBounds(Int_t iAn) const {
-    if(iAn<0 || iAn>=fNAnodePts){
-      AliWarning(Form("Cell out of bounds, anode=%d",iAn));
-      return kFALSE;
-    }
-    return kTRUE;
+    if(iAn<0 || iAn>=fNAnodePts)return kFALSE;
+    else return kTRUE;
   }
   Bool_t CheckDriftBounds(Int_t iTb) const {
-    if(iTb<0 || iTb >= fNDriftPts){ 
-      AliWarning(Form("Cell out of bounds, time-bin=%d",iTb));
-      return kFALSE;
-    }
-    return kTRUE;
+    if(iTb<0 || iTb >= fNDriftPts)return kFALSE;
+    else return kTRUE;
   }
 
   virtual void Set1DMap(TH1F* /*hmap*/){
@@ -70,7 +64,9 @@ class AliITSCorrMapSDD : public TNamed {
     return -99999.;
   }
 
+  void    ComputeGridPoints(Float_t z, Float_t x, AliITSsegmentationSDD *seg, Bool_t isReco=kTRUE);
   Float_t GetCorrection(Float_t z, Float_t x, AliITSsegmentationSDD *seg);
+  Float_t GetShiftForSimulation(Float_t z, Float_t x, AliITSsegmentationSDD *seg);
   TH2F* GetMapHisto() const;
   TH1F* GetMapProfile() const;
   TH1F* GetResidualDistr(Float_t dmin=-300., Float_t dmax=300.) const;
@@ -86,6 +82,12 @@ class AliITSCorrMapSDD : public TNamed {
   Int_t fNAnodePts; // number of map points along anodes
   Int_t fNDriftPts; // number of map points along anodes
 
-  ClassDef(AliITSCorrMapSDD,1);
+  Float_t fXt1;   // true coordinate in lower grid point
+  Float_t fXt2;   // true coordinate in upper grid point
+  Float_t fXm1;   // measured coordinate in lower grid point
+  Float_t fXm2;   // measured coordinate in upper grid point
+  Float_t fDrLen; // drift length
+
+  ClassDef(AliITSCorrMapSDD,2);
 };
 #endif
index 6548c62..f409113 100644 (file)
@@ -41,6 +41,8 @@ const Float_t  AliITSSimuParam::fgkSDDDynamicRangeDefault = 1400./2.5; // mV/MOh
 const Int_t    AliITSSimuParam::fgkSDDMaxAdcDefault = 1024;
 const Float_t  AliITSSimuParam::fgkSDDChargeLossDefault = 0.;
 const Float_t  AliITSSimuParam::fgkSDDTrigDelayDefault = 54.3;
+const Float_t  AliITSSimuParam::fgkSDDMapPrecDefault = 20.; // 20 um from laser tests
+const Float_t  AliITSSimuParam::fgkSDDkeVtoADCDefault = 3.42;
 const Double_t AliITSSimuParam::fgkSSDCouplingPRDefault = 0.01;
 const Double_t AliITSSimuParam::fgkSSDCouplingPLDefault = 0.01;
 const Double_t AliITSSimuParam::fgkSSDCouplingNRDefault = 0.01;
@@ -55,39 +57,41 @@ ClassImp(AliITSSimuParam)
 //______________________________________________________________________
 AliITSSimuParam::AliITSSimuParam():
   TObject(),
-fGeVcharge(0.),
-fDOverV(0.),
+  fGeVcharge(0.),
+  fDOverV(0.),
 //fSPDBiasVoltage(fgkSPDBiasVoltageDefault),
 //fSPDThresh(fgkSPDThreshDefault),
 //fSPDSigma(fgkSPDSigmaDefault),
-fSPDCouplOpt(0),
-fSPDCouplCol(fgkSPDCouplColDefault),
-fSPDCouplRow(fgkSPDCouplRowDefault),
-fSPDEccDiff(0.),
-fSPDLorentzDrift(kTRUE),
-fSPDLorentzHoleWeight(fgkSPDLorentzHoleWeightDefault),
-fSPDAddNoisyFlag(kFALSE),
-fSPDRemoveDeadFlag(kFALSE),
-fSDDElectronics(0),
-fSDDDiffCoeff(0.),
-fSDDDiffCoeff1(0.),
-fSDDJitterError(fgkSDDJitterErrorDefault),
-fSDDDynamicRange(fgkSDDDynamicRangeDefault),
-fSDDMaxAdc(0.),
-fSDDChargeLoss(fgkSDDChargeLossDefault),
-fSDDTrigDelay(fgkSDDTrigDelayDefault),
-fSDDRawFormat(7),
-fSSDLorentzDrift(kTRUE),
-fSSDCouplingPR(0),
-fSSDCouplingPL(0),
-fSSDCouplingNR(0),
-fSSDCouplingNL(0),
-fSSDZSThreshold(fgkSSDZSThresholdDefault),
-fNsigmas(fgkNsigmasDefault),
-fNcomps(fgkNcompsDefault),
-fGaus(),
-fN(0.),
-fT(300.)
+  fSPDCouplOpt(0),
+  fSPDCouplCol(fgkSPDCouplColDefault),
+  fSPDCouplRow(fgkSPDCouplRowDefault),
+  fSPDEccDiff(0.),
+  fSPDLorentzDrift(kTRUE),
+  fSPDLorentzHoleWeight(fgkSPDLorentzHoleWeightDefault),
+  fSPDAddNoisyFlag(kFALSE),
+  fSPDRemoveDeadFlag(kFALSE),
+  fSDDElectronics(0),
+  fSDDDiffCoeff(0.),
+  fSDDDiffCoeff1(0.),
+  fSDDJitterError(fgkSDDJitterErrorDefault),
+  fSDDDynamicRange(fgkSDDDynamicRangeDefault),
+  fSDDMaxAdc(0.),
+  fSDDChargeLoss(fgkSDDChargeLossDefault),
+  fSDDTrigDelay(fgkSDDTrigDelayDefault),
+  fSDDMapPrec(fgkSDDMapPrecDefault),
+  fSDDkeVtoADC(fgkSDDkeVtoADCDefault),
+  fSDDRawFormat(7),
+  fSSDLorentzDrift(kTRUE),
+  fSSDCouplingPR(0),
+  fSSDCouplingPL(0),
+  fSSDCouplingNR(0),
+  fSSDCouplingNL(0),
+  fSSDZSThreshold(fgkSSDZSThresholdDefault),
+  fNsigmas(fgkNsigmasDefault),
+  fNcomps(fgkNcompsDefault),
+  fGaus(),
+  fN(0.),
+  fT(300.)
 {  
   // default constructor
   SetSPDBiasVoltageAll(fgkSPDBiasVoltageDefault);
@@ -104,40 +108,42 @@ fT(300.)
 }
 //______________________________________________________________________
 AliITSSimuParam::AliITSSimuParam(const AliITSSimuParam &simpar):
-TObject(),
-fGeVcharge(simpar.fGeVcharge),
-fDOverV(simpar.fDOverV),
-//fSPDBiasVoltage(simpar.fSPDBiasVoltage),
-//fSPDThresh(simpar.fSPDThresh),
-//fSPDSigma(simpar.fSPDSigma),
-fSPDCouplOpt(simpar.fSPDCouplOpt),
-fSPDCouplCol(simpar.fSPDCouplCol),
-fSPDCouplRow(simpar.fSPDCouplRow),
-fSPDEccDiff(simpar.fSPDEccDiff),
-fSPDLorentzDrift(simpar.fSPDLorentzDrift),
-fSPDLorentzHoleWeight(simpar.fSPDLorentzHoleWeight),
-fSPDAddNoisyFlag(simpar.fSPDAddNoisyFlag),
-fSPDRemoveDeadFlag(simpar.fSPDRemoveDeadFlag),
-fSDDElectronics(simpar.fSDDElectronics),
-fSDDDiffCoeff(simpar.fSDDDiffCoeff),
-fSDDDiffCoeff1(simpar.fSDDDiffCoeff1),
-fSDDJitterError(simpar.fSDDJitterError),
-fSDDDynamicRange(simpar.fSDDDynamicRange),
-fSDDMaxAdc(simpar.fSDDMaxAdc),
-fSDDChargeLoss(simpar.fSDDChargeLoss),
-fSDDTrigDelay(simpar.fSDDTrigDelay),
-fSDDRawFormat(simpar.fSDDRawFormat),
-fSSDLorentzDrift(simpar.fSSDLorentzDrift),
-fSSDCouplingPR(simpar.fSSDCouplingPR),
-fSSDCouplingPL(simpar.fSSDCouplingPL),
-fSSDCouplingNR(simpar.fSSDCouplingNR),
-fSSDCouplingNL(simpar.fSSDCouplingNL),
-fSSDZSThreshold(simpar.fSSDZSThreshold),
-fNsigmas(simpar.fNsigmas),
-fNcomps(simpar.fNcomps),
-fGaus(),
-fN(simpar.fN),
-fT(simpar.fT){
+  TObject(),
+  fGeVcharge(simpar.fGeVcharge),
+  fDOverV(simpar.fDOverV),
+  //fSPDBiasVoltage(simpar.fSPDBiasVoltage),
+  //fSPDThresh(simpar.fSPDThresh),
+  //fSPDSigma(simpar.fSPDSigma),
+  fSPDCouplOpt(simpar.fSPDCouplOpt),
+  fSPDCouplCol(simpar.fSPDCouplCol),
+  fSPDCouplRow(simpar.fSPDCouplRow),
+  fSPDEccDiff(simpar.fSPDEccDiff),
+  fSPDLorentzDrift(simpar.fSPDLorentzDrift),
+  fSPDLorentzHoleWeight(simpar.fSPDLorentzHoleWeight),
+  fSPDAddNoisyFlag(simpar.fSPDAddNoisyFlag),
+  fSPDRemoveDeadFlag(simpar.fSPDRemoveDeadFlag),
+  fSDDElectronics(simpar.fSDDElectronics),
+  fSDDDiffCoeff(simpar.fSDDDiffCoeff),
+  fSDDDiffCoeff1(simpar.fSDDDiffCoeff1),
+  fSDDJitterError(simpar.fSDDJitterError),
+  fSDDDynamicRange(simpar.fSDDDynamicRange),
+  fSDDMaxAdc(simpar.fSDDMaxAdc),
+  fSDDChargeLoss(simpar.fSDDChargeLoss),
+  fSDDTrigDelay(simpar.fSDDTrigDelay),
+  fSDDMapPrec(simpar.fSDDMapPrec),
+  fSDDkeVtoADC(simpar.fSDDkeVtoADC),
+  fSDDRawFormat(simpar.fSDDRawFormat),
+  fSSDLorentzDrift(simpar.fSSDLorentzDrift),
+  fSSDCouplingPR(simpar.fSSDCouplingPR),
+  fSSDCouplingPL(simpar.fSSDCouplingPL),
+  fSSDCouplingNR(simpar.fSSDCouplingNR),
+  fSSDCouplingNL(simpar.fSSDCouplingNL),
+  fSSDZSThreshold(simpar.fSSDZSThreshold),
+  fNsigmas(simpar.fNsigmas),
+  fNcomps(simpar.fNcomps),
+  fGaus(),
+  fN(simpar.fN),
+  fT(simpar.fT){
   // copy constructor
   for (Int_t i=0;i<240;i++) {
     fSPDBiasVoltage[i]=simpar.fSPDBiasVoltage[i];
@@ -150,11 +156,11 @@ fT(simpar.fT){
 
 //______________________________________________________________________
 AliITSSimuParam& AliITSSimuParam::operator=(const AliITSSimuParam& source){
-    // Assignment operator. 
-    this->~AliITSSimuParam();
-    new(this) AliITSSimuParam(source);
-    return *this;
-
+  // Assignment operator. 
+  this->~AliITSSimuParam();
+  new(this) AliITSSimuParam(source);
+  return *this;
+  
 }
 
 
@@ -176,6 +182,7 @@ void AliITSSimuParam::SetNLookUp(Int_t p1){
 }
 //________________________________________________________________________
 void AliITSSimuParam::PrintParameters() const{
+  // Dump all parameters
   printf("GeVToCharge               = %G\n",fGeVcharge);
   printf("DistanveOverVoltage       = %f \n",fDOverV);
   printf("\n");
@@ -199,6 +206,8 @@ void AliITSSimuParam::PrintParameters() const{
   printf("Max. ADC                  = %f\n",fSDDMaxAdc);
   printf("Charge Loss               = %f\n",fSDDChargeLoss);  
   printf("Trigger Delay (ns)        = %f\n",fSDDTrigDelay);  
+  printf("Smear from map (um)       = %f\n",fSDDMapPrec);
+  printf("keV->ADC conv. fact.        = %f\n",fSDDkeVtoADC);
   printf("Raw Data Format           = %d\n",fSDDRawFormat);  
   printf("\n");
   printf("=====  SSD parameters  =====\n");
@@ -541,6 +550,7 @@ Double_t AliITSSimuParam::ReverseBiasCurrent(Double_t temp,
 }
 //______________________________________________________________________
  void   AliITSSimuParam::SPDThresholds(const Int_t mod, Double_t& thresh, Double_t& sigma) const {
+   // Get SPD threshold values
     if(mod<0 || mod>239) {
        thresh=0;
        sigma=0; 
@@ -552,6 +562,7 @@ Double_t AliITSSimuParam::ReverseBiasCurrent(Double_t temp,
 }
 //_______________________________________________________________________
  void   AliITSSimuParam::SPDNoise(const Int_t mod,Double_t &noise, Double_t &baseline) const {
+   //Get SPD noise and baseline values
      if(mod<0 || mod>239) {
        noise=0;
        baseline=0; 
index 040fb6e..5f414e2 100644 (file)
@@ -73,9 +73,9 @@ class AliITSSimuParam : public TObject {
   Float_t GetSPDLorentzHoleWeight() const {return fSPDLorentzHoleWeight;}
   
   void   SetSPDAddNoisyFlag(Bool_t value) {fSPDAddNoisyFlag = value;}
-  Bool_t GetSPDAddNoisyFlag() {return fSPDAddNoisyFlag;}
+  Bool_t GetSPDAddNoisyFlag() const {return fSPDAddNoisyFlag;}
   void   SetSPDRemoveDeadFlag(Bool_t value) {fSPDRemoveDeadFlag = value;}
-  Bool_t GetSPDRemoveDeadFlag() {return fSPDRemoveDeadFlag;}
+  Bool_t GetSPDRemoveDeadFlag() const {return fSPDRemoveDeadFlag;}
   
   void SetSDDElectronics(Int_t p1=1) {fSDDElectronics=p1;   }
   Int_t GetSDDElectronics()  const {return fSDDElectronics;}
@@ -100,6 +100,12 @@ class AliITSSimuParam : public TObject {
   void    SetSDDTrigDelay(Double_t p1) {fSDDTrigDelay=p1;}
   Float_t GetSDDTrigDelay() const {return fSDDTrigDelay;}
 
+  void    SetSDDCorrMapPrecision(Double_t p1) {fSDDMapPrec=p1;}
+  Float_t GetSDDCorrMapPrecision() const {return fSDDMapPrec;}
+
+  void    SetSDDkeVtoADC(Double_t p1) {fSDDkeVtoADC=p1;}
+  Float_t GetSDDkeVtoADC() const {return fSDDkeVtoADC;}
+
   void    SetSDDRawDataFormatCarlos() {fSDDRawFormat=7;}
   void    SetSDDRawDataFormatFixLen8bitEncoded() {fSDDRawFormat=0;}
   Char_t  GetSDDRawDataFormat() const {return fSDDRawFormat;}
@@ -203,6 +209,8 @@ class AliITSSimuParam : public TObject {
   static const Int_t fgkSDDMaxAdcDefault; // default for fSDDMaxAdc
   static const Float_t fgkSDDChargeLossDefault; // default for fSDDChargeLoss
   static const Float_t fgkSDDTrigDelayDefault; // default for fSDDTrigDelay
+  static const Float_t fgkSDDMapPrecDefault; // default for fSDDTrigDelay
+  static const Float_t fgkSDDkeVtoADCDefault; // default for keV->ADC conv.
 
   static const Double_t fgkSSDCouplingPRDefault;  // default values
   static const Double_t fgkSSDCouplingPLDefault;  // for the
@@ -243,6 +251,8 @@ class AliITSSimuParam : public TObject {
   Float_t  fSDDMaxAdc;       // SDD ADC saturation value
   Float_t  fSDDChargeLoss;   // Set Linear Coefficient for Charge Loss 
   Float_t  fSDDTrigDelay;    // SDD time-zero
+  Float_t  fSDDMapPrec;      // SDD maps precision
+  Float_t  fSDDkeVtoADC;     // SDD keV->ADC conv. factor
   Char_t   fSDDRawFormat;    // Index for SDD RawFormat
   
   Bool_t   fSSDLorentzDrift;     // Flag to decide whether to simulate the Lorentz Drift or not in SSD
@@ -261,6 +271,6 @@ class AliITSSimuParam : public TObject {
   Double_t fN;  // the impurity concentration of the material in #/cm^3  (NOT USED!)
   Float_t fT;   // The temperature of the Si in Degree K.
 
-  ClassDef(AliITSSimuParam,5);
+  ClassDef(AliITSSimuParam,6);
 };
 #endif
index c9de511..b56e192 100644 (file)
@@ -32,6 +32,7 @@
 const Float_t AliITSresponseSDD::fgkTimeOffsetDefault = 54.30;
 const Float_t AliITSresponseSDD::fgkADC2keVDefault = 3.34;
 const Float_t AliITSresponseSDD::fgkChargevsTimeDefault = 0.00355;
+const Float_t AliITSresponseSDD::fgkADCvsDrTimeDefault = 0.0101;
 const Float_t AliITSresponseSDD::fgkCarlosRXClockPeriod = 25.;
 ClassImp(AliITSresponseSDD)
 
@@ -40,12 +41,14 @@ AliITSresponseSDD::AliITSresponseSDD():
 TObject(),
   fTimeOffset(fgkTimeOffsetDefault),
   fADC2keV(fgkADC2keVDefault),
-  fChargevsTime(fgkChargevsTimeDefault){
+  fChargevsTime(fgkChargevsTimeDefault)
+{
   // default constructor
   for(Int_t i=0; i<kNSDDmods;i++){
     fTimeZero[i]=fgkTimeOffsetDefault;
     fDeltaVDrift[i] = fDeltaVDrift[i+kNSDDmods] = 0.;
     fADCtokeV[i]=fgkADC2keVDefault;
+    fADCvsDriftTime[i]=fgkADCvsDrTimeDefault;
   }  
   SetVDCorr2Side(kTRUE); // default for new objects will be separate corrections for 2 sides (bwd compatible)
   //  SetVDCorrMult(kTRUE); // default for new objects will have multiplicative correction v'=(1+corr)*v (bwd compatible)
@@ -106,7 +109,8 @@ void AliITSresponseSDD::SetHalfLadderCTimeZero(Int_t lay, Int_t lad, Float_t tze
 }
 //_________________________________________________________________________
 void AliITSresponseSDD::PrintChargeCalibrationParams() const{
-  //
+  // Dump charge calibration parameters
+
   printf("ADC vs. drift time corr=%f\n",GetChargevsTime());
   printf("-------------------------------------\n");
   printf("Layer 3\n");
@@ -131,7 +135,8 @@ void AliITSresponseSDD::PrintChargeCalibrationParams() const{
 }
 //_________________________________________________________________________
 void AliITSresponseSDD::PrintTimeZeroes() const{
-  //
+  // Dump time zero values
+
   printf("Layer 3\n");
   for(Int_t ilad=1; ilad<=14; ilad++){
     for(Int_t idet=1; idet<=6;idet++){
@@ -155,7 +160,8 @@ void AliITSresponseSDD::PrintTimeZeroes() const{
 }
 //_________________________________________________________________________
 void AliITSresponseSDD::PrintVdriftCorerctions() const{
-  //
+  // Dump corrections to vdrift
+
   for(Int_t iMod=240; iMod<500; iMod++){
     printf("Module %d   dVleft=%f   dVright=%f\n",iMod,GetDeltaVDrift(iMod,0),GetDeltaVDrift(iMod,1));
   }
index 1fb39ec..40f5f82 100644 (file)
@@ -99,8 +99,24 @@ class AliITSresponseSDD : public TObject {
   virtual void SetChargevsTime(Float_t slope){fChargevsTime=slope;}
   virtual Float_t GetChargevsTime()const {return fChargevsTime;}
 
+  virtual void SetADCvsDriftTime(Int_t modIndex, Float_t slope){
+    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
+      AliError(Form("SDD module number %d out of range",modIndex));
+      return;
+    }
+    fADCvsDriftTime[modIndex-kNSPDmods]=slope;
+  }
+  virtual Float_t GetADCvsDriftTime(Int_t modIndex) const {
+    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
+      AliError(Form("SDD module number %d out of range",modIndex));
+      return 0.;
+    }
+    return fADCvsDriftTime[modIndex-kNSPDmods];
+  }
+
   static Float_t DefaultADC2keV() {return fgkADC2keVDefault;}
   static Float_t DefaultChargevsTime() {return fgkChargevsTimeDefault;}
+  static Float_t DefaultADCvsDriftTime() {return fgkADCvsDrTimeDefault;}
 
   static Float_t GetCarlosRXClockPeriod() {return fgkCarlosRXClockPeriod;}
   void PrintChargeCalibrationParams() const;
@@ -128,6 +144,7 @@ class AliITSresponseSDD : public TObject {
   static const Float_t fgkTimeOffsetDefault;   // default for fTimeOffset
   static const Float_t fgkADC2keVDefault;      // default for fADC2keV
   static const Float_t fgkChargevsTimeDefault; // default for fChargevsTime
+  static const Float_t fgkADCvsDrTimeDefault;  // default for fADCvsDriftTime
   static const Float_t fgkCarlosRXClockPeriod; // clock period for CarlosRX
 
   Float_t  fTimeOffset;             // Time offset due to electronic delays 
@@ -136,15 +153,17 @@ class AliITSresponseSDD : public TObject {
   Float_t  fDeltaVDrift[2*kNSDDmods];  // Vdrift correction (um/ns) for each module left (<kNSDDmods) and right (>=kNSDDmods) sides
   Float_t  fADC2keV;                // Conversion factor from ADC to keV
                                     // --> obsolete, kept for backw. comp. 
-  Float_t  fChargevsTime;           // Correction for zero suppression effect
-  Float_t  fADCtokeV[kNSDDmods]; // ADC to keV conversion for each module
+  Float_t  fChargevsTime;           // --> obsolete, kept for backw. comp. 
+
+  Float_t  fADCvsDriftTime[kNSDDmods]; // Correction for zero suppression effect
+  Float_t  fADCtokeV[kNSDDmods];       // ADC to keV conversion for each module
 
  private:
 
   AliITSresponseSDD(const AliITSresponseSDD &ob); // copy constructor
   AliITSresponseSDD& operator=(const AliITSresponseSDD & /* source */); // ass. op.
 
-  ClassDef(AliITSresponseSDD,20) 
+  ClassDef(AliITSresponseSDD,21) 
      
     };
 #endif
index 3c06b4d..9739fd7 100644 (file)
@@ -399,9 +399,13 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
   Double_t  nsigma     = simpar->GetNSigmaIntegration(); //
   Int_t     nlookups   = simpar->GetGausNLookUp();       //
   Float_t   jitter     = simpar->GetSDDJitterError(); // 
+  Float_t   mapsmear   = simpar->GetSDDCorrMapPrecision(); // 
   Float_t   trigDelay  = simpar->GetSDDTrigDelay(); // compensation for MC time zero
   if(res->IsAMAt20MHz()) trigDelay+=12.5; // compensation for discretization step
+
   Float_t   timeZero=fDetType->GetResponseSDD()->GetTimeZero(fModule);
+  Float_t   adcscale   = fDetType->GetResponseSDD()->GetADCtokeV(fModule);
+  adcscale/=simpar->GetSDDkeVtoADC();
 
   // Piergiorgio's part (apart for few variables which I made float
   // when i thought that can be done
@@ -456,6 +460,8 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
     Float_t zloc=xL[2]+0.5*dxL[2];
     zAnode=seg->GetAnodeFromLocal(xloc,zloc); // anode number in the range 0.-511.
     driftSpeed = res->GetDriftSpeedAtAnode(zAnode);
+    driftSpeed+= fDetType->GetResponseSDD()->GetDeltaVDrift(fModule,zAnode>255);
+
     if(timeStep*fMaxNofSamples < sddLength/driftSpeed) {
       AliWarning("Time Interval > Allowed Time Interval");
     }
@@ -476,14 +482,20 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
       AliDebug(1,Form("TOF for hit %d on mod %d (particle %d)=%g",ii,fModule,h->Track(),tof));
     }
 
+    Float_t corrx=0, corrz=0;
+    res->GetShiftsForSimulation(xL[2],xL[0],corrz,corrx,seg);
+    xL[2]-=corrz;
+    xL[0]-=corrx;
+    xL[0] += 0.0001*gRandom->Gaus( 0, mapsmear); //
     xL[0] += 0.0001*gRandom->Gaus( 0, jitter ); //
+
     pathInSDD = TMath::Sqrt(dxL[0]*dxL[0]+dxL[1]*dxL[1]+dxL[2]*dxL[2]);
     
     if (fFlag && pathInSDD) { depEnergy *= (0.03/pathInSDD); }
     drPath = TMath::Abs(10000.*(dxL[0]+2.*xL[0])*0.5);
     drPath = sddLength-drPath;
     if(drPath < 0) {
-      AliDebug(1, // this should be fixed at geometry level
+      AliInfo( // this should be fixed at geometry level
               Form("negative drift path drPath=%e sddLength=%e dxL[0]=%e xL[0]=%e",
                    drPath,sddLength,dxL[0],xL[0]));
       continue;
@@ -508,6 +520,7 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
       theAverage+=avAnode;
       zAnode = seg->GetAnodeFromLocal(avDrft,avAnode);
       driftSpeed = res->GetDriftSpeedAtAnode(zAnode);  
+      driftSpeed+= fDetType->GetResponseSDD()->GetDeltaVDrift(fModule,zAnode>255);
       driftPath = TMath::Abs(10000.*avDrft);
       driftPath = sddLength-driftPath;
       if(driftPath < 0) {
@@ -533,6 +546,7 @@ void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
        (timeStep*eVpairs*2.*acos(-1.));
       chargeloss = 1.-cHloss*driftPath/1000.;
       amplitude *= chargeloss;
+      amplitude *= adcscale;
       width  = 2.*nsigma/(nlookups-1);
       // Spread the charge 
       nsplitAn = 4; 
index f47aed7..0470009 100644 (file)
@@ -11,6 +11,7 @@
 #include <TLatex.h>
 #include <TCanvas.h>
 #include <TObjArray.h>
+#include <TPaveStats.h>
 #include "AliCDBEntry.h"
 #include "AliITSresponseSDD.h"
 #endif
@@ -35,39 +36,47 @@ void ShowResponseSDD(TString filename="$ALICE_ROOT/OCDB/ITS/Calib/RespSDD/Run0_9
   TH1F* hdistVdriftCorrLeft=new TH1F("hdistVdriftCorrLeft","",100,-0.2,0.2);
   TH1F* hdistVdriftCorrRight=new TH1F("hdistVdriftCorrRight","",100,-0.2,0.2);
   TH1F* hADCtokeV=new TH1F("hADCtokeV","",260,239.5,499.5);
+  TH1F* hADCvsTime=new TH1F("hADCvsTime","",260,239.5,499.5);
   Float_t averTz=0.;
   Float_t averCv0=0.;
   Float_t averCv1=0.;
   Float_t averAk=0.;
+  Float_t averAt=0.;
   for(Int_t iMod=240; iMod<500; iMod++){
     Float_t tz=r->GetTimeZero(iMod);
     Float_t cv0=r->GetDeltaVDrift(iMod,kFALSE);
     Float_t cv1=r->GetDeltaVDrift(iMod,kTRUE);
     Float_t ak=r->GetADCtokeV(iMod);
+    Float_t at=r->GetADCvsDriftTime(iMod);
     hTimeZero->SetBinContent(iMod-240+1,tz);    
     hVdriftCorrLeft->SetBinContent(iMod-240+1,cv0);
     hVdriftCorrRight->SetBinContent(iMod-240+1,cv1);
     hdistVdriftCorrLeft->Fill(cv0);
     hdistVdriftCorrRight->Fill(cv1);
     hADCtokeV->SetBinContent(iMod-240+1,ak);
+    hADCvsTime->SetBinContent(iMod-240+1,at);
     averTz+=tz;
     averCv0+=cv0;
     averCv1+=cv1;
     averAk+=ak;
+    averAt+=at;
   }
   averTz/=260.;
   averCv0/=260.;
   averCv1/=260.;
   averAk/=260.;
+  averAt/=260.;
 
   hTimeZero->SetMarkerStyle(20);
   hADCtokeV->SetMarkerStyle(20);
+  hADCvsTime->SetMarkerStyle(20);
   hVdriftCorrLeft->SetMarkerStyle(22);
   hVdriftCorrLeft->SetMarkerColor(2);
   hVdriftCorrRight->SetMarkerStyle(24);
   hVdriftCorrRight->SetMarkerColor(4);
   hTimeZero->SetMaximum(hTimeZero->GetMaximum()*1.2);
   hADCtokeV->SetMaximum(hADCtokeV->GetMaximum()*1.2);
+  hADCvsTime->SetMaximum(hADCvsTime->GetMaximum()*1.2);
   Float_t maxV=TMath::Max(hVdriftCorrLeft->GetMaximum(),hVdriftCorrRight->GetMaximum());
   Float_t minV=TMath::Min(hVdriftCorrLeft->GetMinimum(),hVdriftCorrRight->GetMinimum());
   Float_t scale=TMath::Max(TMath::Abs(maxV),TMath::Abs(minV));
@@ -84,6 +93,7 @@ void ShowResponseSDD(TString filename="$ALICE_ROOT/OCDB/ITS/Calib/RespSDD/Run0_9
   printf("Charge vs. Time correction factor = %f\n",r->GetChargevsTime());
 
   TCanvas* c1=new TCanvas("c1","Time Zero");
+  hTimeZero->SetStats(0);
   hTimeZero->Draw("P");
   hTimeZero->GetXaxis()->SetTitle("Module Id");
   hTimeZero->GetYaxis()->SetTitle("Time Zero (ns)");
@@ -92,7 +102,10 @@ void ShowResponseSDD(TString filename="$ALICE_ROOT/OCDB/ITS/Calib/RespSDD/Run0_9
   tt->Draw();
   c1->Modified();
 
-  TCanvas* c2=new TCanvas("c2","Vdrift Corr");
+  TCanvas* c2=new TCanvas("c2","Vdrift Corr",800,900);
+  c2->Divide(1,2);
+  c2->cd(1);
+  hVdriftCorrLeft->SetStats(0);
   hVdriftCorrLeft->Draw("P");
   hVdriftCorrRight->Draw("PSAME");
   hVdriftCorrLeft->GetXaxis()->SetTitle("Module Id");
@@ -105,26 +118,40 @@ void ShowResponseSDD(TString filename="$ALICE_ROOT/OCDB/ITS/Calib/RespSDD/Run0_9
   tc1->SetNDC();
   tc1->SetTextColor(4);
   tc1->Draw();
-  c2->Modified();
-
-  TCanvas* c2b=new TCanvas("c2b","Vdrift Corr");
+  c2->cd(2);
+  hdistVdriftCorrLeft->SetLineColor(2);
+  hdistVdriftCorrLeft->GetXaxis()->SetTitle("Vdrift correction (#mum/ns)");
   hdistVdriftCorrLeft->Draw(); 
-  hdistVdriftCorrRight->SetLineColor(2);
+  c2->Update();
+  TPaveStats *stL=(TPaveStats*)hdistVdriftCorrLeft->GetListOfFunctions()->FindObject("stats");
+  stL->SetY1NDC(0.71);
+  stL->SetY2NDC(0.9);
+  stL->SetTextColor(2);
+  hdistVdriftCorrRight->SetLineColor(4);
   hdistVdriftCorrRight->Draw("SAMES");
-  hdistVdriftCorrLeft->GetXaxis()->SetTitle("Vdrift correction (#mum/ns)");
-  c2b->Modified();
+  c2->Update();
+  TPaveStats *stR=(TPaveStats*)hdistVdriftCorrRight->GetListOfFunctions()->FindObject("stats");
+  stR->SetY1NDC(0.51);
+  stR->SetY2NDC(0.7);
+  stR->SetTextColor(4);
 
-  TCanvas* c3=new TCanvas("c3","ADC calib");
+  TCanvas* c3=new TCanvas("c3","ADC calib",800,900);
+  c3->Divide(1,2);
+  c3->cd(1);
+  hADCvsTime->SetStats(0);
+  hADCvsTime->Draw("P");
+  hADCvsTime->GetXaxis()->SetTitle("Module Id");
+  hADCvsTime->GetYaxis()->SetTitle("ADC vs. Drift Time Slope (ADC/ns)");
+  TLatex* ts=new TLatex(0.2,0.8,Form("Average ADCvsTime = %.3f",averAt));
+  ts->SetNDC();
+  ts->Draw(); 
+  c3->cd(2);
+  hADCtokeV->SetStats(0);
   hADCtokeV->Draw("P");
   hADCtokeV->GetXaxis()->SetTitle("Module Id");
   hADCtokeV->GetYaxis()->SetTitle("ADC to keV conv. factor");
   TLatex* ta=new TLatex(0.2,0.8,Form("Average ADCtokeV = %.3f",averAk));
   ta->SetNDC();
   ta->Draw(); 
-  TLatex* tb=new TLatex(0.2,0.72,Form("Charge vs. Time correction factor = %f\n",r->GetChargevsTime()));
-  tb->SetNDC();
-  tb->SetTextColor(kGreen+1);
-  tb->Draw();
-  c3->Modified();
 
 }
index 49a5c9d..a6531b5 100644 (file)
@@ -77,7 +77,7 @@ void StoreCalibSDD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::Infinity(), Bo
   
   for(Int_t mod=0;mod<260;mod++){
     AliITSCalibrationSDD* resd = new AliITSCalibrationSDD("simulated");
-
+    resd->SetAMAt20MHz();
     Int_t nBadUp = 0;
     Int_t nBadDown = 0;
       
index b149cb1..5045435 100644 (file)
@@ -35,7 +35,8 @@ void StoreRespSDD(Int_t firstRun=0, Int_t lastRun=AliCDBRunRange::Infinity()){
 //   rd->SetLayer3CTimeZero(287);
 //   rd->SetLayer4ATimeZero(202);
 //   rd->SetLayer4CTimeZero(230);
-  for(Int_t iMod=240; iMod<500; iMod++) rd->SetDeltaVDrift(iMod,0.);
-
+  for(Int_t iMod=240; iMod<500; iMod++){
+    rd->SetADCtokeV(iMod,2.97);
+  }
   AliCDBManager::Instance()->GetDefaultStorage()->Put(rd, idRespSDD, md);  
 }