Update of calibration framework
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 18 Jan 2006 17:04:30 +0000 (17:04 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 18 Jan 2006 17:04:30 +0000 (17:04 +0000)
21 files changed:
TRD/AliTRDCalChamberPos.cxx [moved from TRD/AliTRDCalChamber.cxx with 87% similarity]
TRD/AliTRDCalChamberPos.h [moved from TRD/AliTRDCalChamber.h with 85% similarity]
TRD/AliTRDCalPIDLQ.cxx [new file with mode: 0644]
TRD/AliTRDCalPIDLQ.h [new file with mode: 0644]
TRD/AliTRDCalStackPos.cxx [moved from TRD/AliTRDCalStack.cxx with 88% similarity]
TRD/AliTRDCalStackPos.h [moved from TRD/AliTRDCalStack.h with 82% similarity]
TRD/AliTRDCommonParam.cxx
TRD/AliTRDCommonParam.h
TRD/AliTRDSimParam.cxx
TRD/AliTRDSimParam.h
TRD/AliTRDcalibDB.cxx
TRD/AliTRDcalibDB.h
TRD/AliTRDdigitizer.cxx
TRD/AliTRDparameter.cxx
TRD/AliTRDparameter.h
TRD/AliTRDpidESD.cxx
TRD/Calib/PIDLQ/Run0_0_v0_s0.root [new file with mode: 0644]
TRD/TRDbaseLinkDef.h
TRD/TRDrecLinkDef.h
TRD/libTRDbase.pkg
TRD/libTRDrec.pkg

similarity index 87%
rename from TRD/AliTRDCalChamber.cxx
rename to TRD/AliTRDCalChamberPos.cxx
index 99b5f97..c4111b5 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "AliTRDCalChamber.h"
+#include "AliTRDCalChamberPos.h"
 
-ClassImp(AliTRDCalChamber)
+ClassImp(AliTRDCalChamberPos)
 
 //_____________________________________________________________________________
-AliTRDCalChamber::AliTRDCalChamber():TNamed()
+AliTRDCalChamberPos::AliTRDCalChamberPos():TNamed()
 {
   //
-  // AliTRDCalChamber default constructor
+  // AliTRDCalChamberPos default constructor
   //
 
   for (Int_t idet = 0; idet < kNdet; idet++) {
@@ -41,11 +41,11 @@ AliTRDCalChamber::AliTRDCalChamber():TNamed()
 }
 
 //_____________________________________________________________________________
-AliTRDCalChamber::AliTRDCalChamber(const Text_t *name, const Text_t *title)
+AliTRDCalChamberPos::AliTRDCalChamberPos(const Text_t *name, const Text_t *title)
                 :TNamed(name,title)
 {
   //
-  // AliTRDCalChamber constructor
+  // AliTRDCalChamberPos constructor
   //
 
   for (Int_t idet = 0; idet < kNdet; idet++) {
similarity index 85%
rename from TRD/AliTRDCalChamber.h
rename to TRD/AliTRDCalChamberPos.h
index 2f9f3cb..5a879bb 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef AliTRDCALCHAMBER_H
-#define AliTRDCALCHAMBER_H
+#ifndef AliTRDCALCHAMBERPOS_H
+#define AliTRDCALCHAMBERPOS_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
 
 #include "TNamed.h"
 
-class AliTRDCalChamber : public TNamed {
+class AliTRDCalChamberPos : public TNamed {
   public:
     enum { kNdet = 540 };
   
-    AliTRDCalChamber();
-    AliTRDCalChamber(const Text_t* name, const Text_t* title);
+    AliTRDCalChamberPos();
+    AliTRDCalChamberPos(const Text_t* name, const Text_t* title);
   
     const Float_t* GetChamberPos(Int_t det) const { return fChamberPos[det]; };
     const Float_t* GetChamberRot(Int_t det) const { return fChamberRot[det]; };
@@ -33,7 +33,7 @@ class AliTRDCalChamber : public TNamed {
     Float_t fChamberPos[kNdet][3];                    //  Deviations of the positions of the chambers from the ideal position
     Float_t fChamberRot[kNdet][3];                    //  Rotation of the chambers in respect to the ideal position
     
-    ClassDef(AliTRDCalChamber,1)                      
+    ClassDef(AliTRDCalChamberPos,1)                      
 };
 
 #endif
diff --git a/TRD/AliTRDCalPIDLQ.cxx b/TRD/AliTRDCalPIDLQ.cxx
new file mode 100644 (file)
index 0000000..624226f
--- /dev/null
@@ -0,0 +1,341 @@
+/**************************************************************************
+ * 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.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//-----------------------------------------------------------------
+// Class for dE/dx and Time Bin of Max. Cluster for Electrons and 
+// pions in TRD. 
+// It is instantiated in class AliTRDpidESD for particle identification
+// in TRD
+// Prashant Shukla <shukla@pi0.physi.uni-heidelberg.de>
+//-----------------------------------------------------------------
+
+#include "AliTRDCalPIDLQ.h"
+#include <TH1F.h>
+#include <TFile.h>
+
+ClassImp(AliTRDCalPIDLQ)
+
+Char_t* AliTRDCalPIDLQ::fpartName[AliPID::kSPECIES] = {"electron", "muon", "pion", "kaon", "proton"};
+    
+//_________________________________________________________________________
+AliTRDCalPIDLQ::AliTRDCalPIDLQ(): TNamed()
+{
+  //
+  //  The Default constructor
+  //
+  
+  Init();
+}
+
+//_________________________________________________________________________
+AliTRDCalPIDLQ::AliTRDCalPIDLQ(const Text_t *name, const Text_t *title) : TNamed(name, title)
+{
+  //
+  //  The main constructor
+  //
+  
+  Init();
+}
+
+//_____________________________________________________________________________
+AliTRDCalPIDLQ::AliTRDCalPIDLQ(const AliTRDCalPIDLQ &c) : TNamed(c)
+{
+  //
+  // copy constructor
+  //
+
+  Init();
+  
+  ((AliTRDCalPIDLQ &) c).Copy(*this);
+}
+
+//_________________________________________________________________________
+AliTRDCalPIDLQ::~AliTRDCalPIDLQ()
+{
+  //
+  // Destructor
+  //
+  
+  CleanUp();
+}
+
+//_________________________________________________________________________
+void AliTRDCalPIDLQ::CleanUp()
+{
+  if (fHistdEdx)
+  {
+    delete fHistdEdx;
+    fHistdEdx = 0;
+  }
+  
+  if (fHistTimeBin)
+  {
+    delete fHistTimeBin;
+    fHistTimeBin = 0;
+  }
+
+  if (fTrackMomentum)
+  {
+    delete[] fTrackMomentum;
+    fTrackMomentum = 0;
+  }
+}
+
+//_____________________________________________________________________________
+AliTRDCalPIDLQ &AliTRDCalPIDLQ::operator=(const AliTRDCalPIDLQ &c)
+{
+  //
+  // Assignment operator
+  //
+
+  if (this != &c) ((AliTRDCalPIDLQ &) c).Copy(*this);
+  return *this;
+}
+
+//_____________________________________________________________________________
+void AliTRDCalPIDLQ::Copy(TObject &c) const
+{
+  //
+  // Copy function
+  //
+
+  AliTRDCalPIDLQ& target = (AliTRDCalPIDLQ &) c;
+  
+  target.CleanUp();
+  
+  target.fNMom = fNMom;
+  
+  target.fTrackMomentum = new Double_t[fNMom];
+  for (Int_t i=0; i<fNMom; ++i)
+    target.fTrackMomentum[i] = fTrackMomentum[i];
+      
+  target.fMeanChargeRatio = fMeanChargeRatio;
+
+  target.fNbins = fNbins;
+  target.fBinSize = fBinSize;
+
+  if (fHistdEdx)
+    target.fHistdEdx = (TObjArray*) fHistdEdx->Clone();
+  
+  if (fHistTimeBin)
+    target.fHistTimeBin = (TObjArray*) fHistTimeBin->Clone();
+    
+  TObject::Copy(c);
+}
+
+//_________________________________________________________________________
+void AliTRDCalPIDLQ::Init()
+{
+  fNMom = 11;
+  
+  fTrackMomentum = new Double_t[fNMom];
+  Double_t trackMomentum[11] = {0.6, 0.8, 1, 1.5, 2, 3, 4, 5, 6, 8, 10};
+  for (Int_t imom = 0; imom < 11; imom++)
+    fTrackMomentum[imom] = trackMomentum[imom];
+  
+  fHistdEdx = new TObjArray(AliPID::kSPECIES * fNMom);
+  fHistdEdx->SetOwner();
+  fHistTimeBin = new TObjArray(AliPID::kSPECIES * fNMom);
+  fHistTimeBin->SetOwner();  
+  
+  // ADC Gain normalization
+  fMeanChargeRatio=1.0;
+  
+  // Number of bins and bin size
+  fNbins = 0;
+  fBinSize = 0.;
+}
+
+//_________________________________________________________________________
+Bool_t AliTRDCalPIDLQ::ReadData(Char_t *responseFile)
+{
+  //
+  // Read the TRD dEdx histograms.
+  //
+  // Read histogram Root file  
+  TFile *histFile = new TFile(responseFile, "READ");
+  if (!histFile || !histFile->IsOpen()) {
+    Error("AliTRDCalPIDLQ", "opening TRD histgram file %s failed", responseFile);
+    return kFALSE;
+  }
+  gROOT->cd();
+
+  // Read histograms
+  Char_t text[200];
+  for (Int_t particle = 0; particle < AliPID::kSPECIES; ++particle)
+  {
+    Char_t* particleKey = "";
+    switch (particle)
+    {
+      case AliPID::kElectron: particleKey = "EL"; break;
+      case AliPID::kPion: particleKey = "PI"; break;
+      case AliPID::kMuon: particleKey = "MU"; break;
+      case AliPID::kKaon: particleKey = "KA"; break;
+      case AliPID::kProton: particleKey = "PR"; break;
+    }
+    
+    for (Int_t imom = 0; imom < fNMom; imom++) 
+    {
+      sprintf(text, "h1dEdx%s%01d", particleKey, imom+1);
+      TH1F* hist = (TH1F*)histFile->Get(text)->Clone();
+      hist->Scale(1.0/hist->Integral());
+      fHistdEdx->AddAt(hist, GetHistID(particle, imom));
+  
+      if (particle == AliPID::kElectron || particle == AliPID::kPion)
+      {
+        sprintf(text,"h1MaxTimBin%s%01d", particleKey, imom+1);
+        TH1F* hist = (TH1F*)histFile->Get(text)->Clone();
+        hist->Scale(1.0/hist->Integral());
+        fHistTimeBin->AddAt(hist, GetHistID(particle,imom));
+      }
+    }
+  }
+  
+  histFile->Close();
+  delete histFile;
+  
+  // Number of bins and bin size
+  TH1F* hist = (TH1F*) fHistdEdx->At(GetHistID(AliPID::kPion, 1));
+  fNbins   = hist->GetNbinsX();
+  fBinSize = hist->GetBinWidth(1);
+  
+  return kTRUE;
+}
+
+//_________________________________________________________________________
+Double_t  AliTRDCalPIDLQ::GetMean(Int_t k, Int_t ip) const
+{
+  //
+  // Gets mean of de/dx dist. of e
+  printf("Mean for particle = %s and momentum = %.2f is:\n", fpartName[k], fTrackMomentum[ip]);
+  if (k < 0 || k > AliPID::kSPECIES)
+    return 0;
+  
+  return ((TH1F*) fHistdEdx->At(GetHistID(k,ip)))->GetMean();
+}
+
+//_________________________________________________________________________
+Double_t  AliTRDCalPIDLQ::GetNormalization(Int_t k, Int_t ip) const
+{
+  //
+  // Gets Normalization of de/dx dist. of e
+
+  printf("Normalization for particle = %s and momentum = %.2f is:\n",fpartName[k], fTrackMomentum[ip]);
+  if (k < 0 || k > AliPID::kSPECIES)
+    return 0;
+  
+  return ((TH1F*) fHistdEdx->At(GetHistID(k,ip)))->Integral();
+}
+
+//_________________________________________________________________________
+TH1F* AliTRDCalPIDLQ::GetHistogram(Int_t k, Int_t ip) const
+{
+  //
+  //
+  printf("Histogram for particle = %s and momentum = %.2f is:\n", fpartName[k], fTrackMomentum[ip]);
+  if (k < 0 || k > AliPID::kSPECIES)
+    return 0;
+  
+  return (TH1F*) fHistdEdx->At(GetHistID(k,ip));
+}
+
+//_________________________________________________________________________
+Double_t AliTRDCalPIDLQ::GetProbability(Int_t k, Double_t mom, Double_t dedx1) const
+{
+  //
+  // Gets the Probability of having dedx at a given momentum (mom)
+  // and particle type k (0 for e) and (2 for pi)
+  // from the precalculated de/dx distributions 
+  
+  Double_t dedx = dedx1/fMeanChargeRatio;
+  Int_t iEnBin= ((Int_t) (dedx/fBinSize+1));
+  if(iEnBin > fNbins) iEnBin = fNbins;
+
+  if (k < 0 || k > AliPID::kSPECIES)
+    return 1;
+  
+  TH1F* hist1 = 0;
+  TH1F* hist2 = 0;
+  Double_t mom1 = 0;
+  Double_t mom2 = 0;
+  
+  // Lower limit
+  if (mom<=fTrackMomentum[0]) 
+  {
+    hist1 = (TH1F*) fHistdEdx->At(GetHistID(k,1));
+    hist2 = (TH1F*) fHistdEdx->At(GetHistID(k,0));
+    mom1 = fTrackMomentum[1];
+    mom2 = fTrackMomentum[0];
+  }
+    
+  // Upper Limit
+  if(mom>=fTrackMomentum[fNMom-1]) 
+  {
+    hist1 = (TH1F*) fHistdEdx->At(GetHistID(k,fNMom-1));
+    hist2 = (TH1F*) fHistdEdx->At(GetHistID(k,fNMom-2));
+    mom1 = fTrackMomentum[fNMom-1];
+    mom2 = fTrackMomentum[fNMom-2];
+  }
+    
+  // In the range
+  for (Int_t ip=1; ip<fNMom; ip++) 
+  {
+    if ((fTrackMomentum[ip-1]<= mom) && (mom<fTrackMomentum[ip])) 
+    {
+      hist1 = (TH1F*) fHistdEdx->At(GetHistID(k,ip));
+      hist2 = (TH1F*) fHistdEdx->At(GetHistID(k,ip-1));
+      mom1 = fTrackMomentum[ip];
+      mom2 = fTrackMomentum[ip-1];
+    }
+  }
+  
+  Double_t slop = (hist1->GetBinContent(iEnBin) - hist2->GetBinContent(iEnBin)) / (mom1 - mom2);
+  return hist2->GetBinContent(iEnBin) + slop * (mom - mom2);
+}
+
+//_________________________________________________________________________
+Double_t AliTRDCalPIDLQ::GetProbabilityT(Int_t k, Double_t mom, Int_t timbin) const
+{
+  //
+  // Gets the Probability of having timbin at a given momentum (mom)
+  // and particle type k (0 for e) and (2 for pi)
+  // from the precalculated timbin distributions 
+  
+  if (timbin<=0) 
+    return 0.;
+  Int_t iTBin=timbin+1;
+  
+  // everything which is not electron counts as pion for time bin
+  if (k != AliPID::kElectron)
+    k = AliPID::kPion;
+
+  if (mom<=fTrackMomentum[0]) 
+    return ((TH1F*) fHistTimeBin->At(GetHistID(k,0)))->GetBinContent(iTBin);
+  
+  if (mom>=fTrackMomentum[fNMom-1]) 
+    return ((TH1F*) fHistTimeBin->At(GetHistID(k,fNMom-1)))->GetBinContent(iTBin);
+  
+  for (Int_t ip=1; ip<fNMom; ip++)
+  {
+    if ((fTrackMomentum[ip-1]<= mom) && (mom<fTrackMomentum[ip])) 
+    {
+      Double_t slop=(((TH1F*) fHistTimeBin->At(GetHistID(k,ip)))->GetBinContent(iTBin) - ((TH1F*) fHistTimeBin->At(GetHistID(k,ip-1)))->GetBinContent(iTBin)) / (fTrackMomentum[ip] - fTrackMomentum[ip-1]);
+      // Linear Interpolation
+      return ((TH1F*) fHistTimeBin->At(GetHistID(k,ip-1)))->GetBinContent(iTBin) + slop * (mom - fTrackMomentum[ip-1]);
+    }
+  }
+  
+  return -1;
+}
diff --git a/TRD/AliTRDCalPIDLQ.h b/TRD/AliTRDCalPIDLQ.h
new file mode 100644 (file)
index 0000000..2600a8b
--- /dev/null
@@ -0,0 +1,73 @@
+#ifndef ALITRDCALPIDLQ_H
+#define ALITRDCALPIDLQ_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/*-----------------------------------------------------------------
+   Class for dE/dx and Time Bin of Max. Cluster for Electrons and 
+   pions in TRD. 
+   It is instantiated in class AliTRDpidESD for particle identification
+   in TRD
+   Prashant Shukla <shukla@pi0.physi.uni-heidelberg.de>
+   -----------------------------------------------------------------*/
+
+#include <TNamed.h>
+#include <AliPID.h>
+
+class TH1F;
+class TObjArray;
+
+class AliTRDCalPIDLQ : public TNamed {
+  public:
+    AliTRDCalPIDLQ(); 
+    AliTRDCalPIDLQ(const Text_t *name, const Text_t *title);
+    
+    AliTRDCalPIDLQ(const AliTRDCalPIDLQ& pd);  // Copy Constructor
+    virtual ~AliTRDCalPIDLQ();               // Destructor
+    
+    AliTRDCalPIDLQ &operator=(const AliTRDCalPIDLQ &c);
+    virtual void Copy(TObject &c) const;
+
+    Double_t GetMeanChargeRatio() const { return fMeanChargeRatio; } 
+
+    Double_t GetMomentum(Int_t ip) const {return fTrackMomentum[ip];}
+                      // Gets the momentum for given histogram number ip
+    Double_t GetMean(Int_t iType, Int_t ip) const;        
+                      // Particle type is iType and histogram number is ip         
+    Double_t GetNormalization(Int_t iType, Int_t ip) const;
+
+    TH1F* GetHistogram(Int_t iType, Int_t ip) const;
+
+    Double_t GetProbability(Int_t iType, Double_t mom, Double_t dedx) const;
+                      // Gets the Probability of having dedx
+    Double_t GetProbabilityT(Int_t iType, Double_t mom, Int_t timbin) const;
+                      // Gets the Probability of having timbin
+    Int_t GetNbins() const {return fNbins;}         // Number of Energy bins
+    Double_t GetBinSize() const {return fBinSize;}  // Size of Energy bin
+
+    Bool_t ReadData(Char_t *responseFile);       // Read histograms
+                      // Update the histograms from responseFile
+    void SetMeanChargeRatio(Double_t ratio) { fMeanChargeRatio = ratio; }  
+
+  protected:
+    void Init();                // Reset data
+    void CleanUp();             // Delete pointers;
+    inline Int_t GetHistID(Int_t particle, Int_t mom) const { return particle*fNMom + mom; }
+    
+    static Char_t *fpartName[AliPID::kSPECIES]; //! Names of particle species
+    
+    Int_t fNMom;                // Number of momenta  
+    Double_t* fTrackMomentum;   //[fNMom] Track momenta for which response functions are available
+    Double_t fMeanChargeRatio;  // Ratio of mean charge from real Det. to prob. dist.
+
+    Int_t fNbins;               // Number of Energy bins
+    Double_t fBinSize;          // Size of Energy bin
+    
+    TObjArray *fHistdEdx;           //-> Prob. of dEdx for 5 particles (e, pi, muon, kaon, proton) and for several momenta
+    TObjArray *fHistTimeBin;        //-> Prob. of max time bin for 5 particles (e, pi, muon, kaon, proton) and for several momenta
+    
+    ClassDef(AliTRDCalPIDLQ, 1)
+};
+
+
+#endif
+
similarity index 88%
rename from TRD/AliTRDCalStack.cxx
rename to TRD/AliTRDCalStackPos.cxx
index 34d0aa6..e29c916 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "AliTRDCalStack.h"
+#include "AliTRDCalStackPos.h"
 
-ClassImp(AliTRDCalStack)
+ClassImp(AliTRDCalStackPos)
 
 //_____________________________________________________________________________
-AliTRDCalStack::AliTRDCalStack():TNamed()
+AliTRDCalStackPos::AliTRDCalStackPos():TNamed()
 {
   //
-  // AliTRDCalStack default constructor
+  // AliTRDCalStackPos default constructor
   //
 
   for (Int_t idet = 0; idet < kNstacks; idet++) {
@@ -41,11 +41,11 @@ AliTRDCalStack::AliTRDCalStack():TNamed()
 }
 
 //_____________________________________________________________________________
-AliTRDCalStack::AliTRDCalStack(const Text_t *name, const Text_t *title)
+AliTRDCalStackPos::AliTRDCalStackPos(const Text_t *name, const Text_t *title)
                 :TNamed(name,title)
 {
   //
-  // AliTRDCalStack constructor
+  // AliTRDCalStackPos constructor
   //
 
   for (Int_t idet = 0; idet < kNstacks; idet++) {
similarity index 82%
rename from TRD/AliTRDCalStack.h
rename to TRD/AliTRDCalStackPos.h
index b1382da..d2a3d5d 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef AliTRDCALSTACK_H
-#define AliTRDCALSTACK_H
+#ifndef AliTRDCALSTACKPOS_H
+#define AliTRDCALSTACKPOS_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
 
 #include "TNamed.h"
 
-class AliTRDCalStack : public TNamed {
+class AliTRDCalStackPos : public TNamed {
   public:
     enum { kNdet = 540, kNstacks = 90, kNcham = 5, kNsect = 18 };
   
-    AliTRDCalStack();
-    AliTRDCalStack(const Text_t* name, const Text_t* title);
+    AliTRDCalStackPos();
+    AliTRDCalStackPos(const Text_t* name, const Text_t* title);
   
     const Float_t* GetStackPos(Int_t chamber, Int_t sector) const { return fStackPos[GetStackNumber(chamber, sector)]; };
     const Float_t* GetStackRot(Int_t chamber, Int_t sector) const { return fStackPos[GetStackNumber(chamber, sector)]; };
@@ -35,10 +35,10 @@ class AliTRDCalStack : public TNamed {
     Float_t fStackPos[kNstacks][3];                    //  Deviations of the positions of the stacks from the ideal position
     Float_t fStackRot[kNstacks][3];                    //  Rotation of the stacks in respect to the ideal position
     
-    ClassDef(AliTRDCalStack,1)                     
+    ClassDef(AliTRDCalStackPos,1)                     
 };
     
-void AliTRDCalStack::SetPos(Int_t chamber, Int_t sector, Float_t x, Float_t y, Float_t z) 
+void AliTRDCalStackPos::SetPos(Int_t chamber, Int_t sector, Float_t x, Float_t y, Float_t z) 
 { 
   Int_t stack = GetStackNumber(chamber, sector); 
   fStackPos[stack][0] = x; 
@@ -46,7 +46,7 @@ void AliTRDCalStack::SetPos(Int_t chamber, Int_t sector, Float_t x, Float_t y, F
   fStackPos[stack][2] = z; 
 }
 
-void AliTRDCalStack::SetRot(Int_t chamber, Int_t sector, Float_t x, Float_t y, Float_t z) 
+void AliTRDCalStackPos::SetRot(Int_t chamber, Int_t sector, Float_t x, Float_t y, Float_t z) 
 { 
   Int_t stack = GetStackNumber(chamber, sector); 
   fStackRot[stack][0] = x; 
index 4abfffd..7905b84 100644 (file)
@@ -79,7 +79,6 @@ AliTRDCommonParam::AliTRDCommonParam()
   fField              = 0.0;
 
   fExBOn              = kFALSE;
-  fPRFOn              = kFALSE;
   
   fPadPlaneArray      = 0;
   
@@ -96,9 +95,6 @@ void AliTRDCommonParam::Init()
   // E x B effects
   fExBOn          = kTRUE;
 
-  // The pad response function
-  fPRFOn          = kTRUE;
-
   // The magnetic field strength in Tesla
   Double_t x[3] = { 0.0, 0.0, 0.0 };
   Double_t b[3];
@@ -167,17 +163,7 @@ void AliTRDCommonParam::Copy(TObject &p) const
     return;
   
   target->fExBOn              = fExBOn;
-  target->fPRFOn              = fPRFOn;
-  /*target->fPRFbin             = fPRFbin;
-  target->fPRFlo              = fPRFlo;
-  target->fPRFhi              = fPRFhi;
-  target->fPRFwid             = fPRFwid;
-  target->fPRFpad             = fPRFpad;
-  if (target->fPRFsmp) delete [] target->fPRFsmp;
-  target->fPRFsmp = new Float_t[fPRFbin];
-  for (Int_t iBin = 0; iBin < fPRFbin; iBin++) {
-    target->fPRFsmp[iBin] = fPRFsmp[iBin];
-  }*/
+  target->fField              = fField;
 }
 
 //_____________________________________________________________________________
index 6aa4e19..43ff2dd 100644 (file)
@@ -29,17 +29,13 @@ class AliTRDCommonParam : public TObject
     
     void SetField(Float_t field)                        { fField          = field;    };
     
-    virtual void     SetExB(Int_t exbOn = 1)                        { fExBOn          = exbOn;    };
-    
-    virtual void     SetPadResponse(Int_t prfOn = 1)                { fPRFOn          = prfOn;    };
+    void     SetExB(Int_t exbOn = 1)                        { fExBOn          = exbOn;    };
     
     Float_t  GetField()                               const { return fField; };
     
     Bool_t   ExBOn()                                  const { return fExBOn;         };
     
-    Bool_t   PRFOn()                                  const { return fPRFOn;         };
-    
-    virtual AliTRDpadPlane *GetPadPlane(Int_t p, Int_t c) const;
+    AliTRDpadPlane *GetPadPlane(Int_t p, Int_t c) const;
     Int_t    GetRowMax(Int_t p, Int_t c, Int_t /*s*/) const;
     Int_t    GetColMax(Int_t p) const;
     Double_t GetRow0(Int_t p, Int_t c, Int_t /*s*/) const;
@@ -54,16 +50,15 @@ class AliTRDCommonParam : public TObject
     Float_t              fField;                              //  Magnetic field
     
     Int_t                fExBOn;                              //  Switch for the ExB effects
-    Int_t                fPRFOn;                              //  Switch for the pad response
   
-    TObjArray  *fPadPlaneArray;                      //  Array of pad plane objects
+    TObjArray  *fPadPlaneArray;                               //!  Array of pad plane objects
   
   private:
     // this is a singleton, constructor is private!  
     AliTRDCommonParam();
-    ~AliTRDCommonParam();
+    virtual ~AliTRDCommonParam();
   
-    ClassDef(AliTRDCommonParam, 0)
+    ClassDef(AliTRDCommonParam, 1)
 };
 
 #endif
index 4190e66..01fa56b 100644 (file)
@@ -109,6 +109,8 @@ AliTRDSimParam::AliTRDSimParam()
   fTimeCoupling       = 0.0;
   fTimeStructOn       = kFALSE;
   
+  fPRFOn              = kFALSE;
+  
   Init();
 }
 
@@ -162,6 +164,9 @@ void AliTRDSimParam::Init()
   // Use drift time maps
   fTimeStructOn = kTRUE;
   
+  // The pad response function
+  fPRFOn          = kTRUE;
+
   ReInit();
 }
 
@@ -257,6 +262,8 @@ void AliTRDSimParam::Copy(TObject &p) const
   target->fAnodeWireOffset    = fAnodeWireOffset;
   target->fPadCoupling        = fPadCoupling;
   target->fTimeCoupling       = fTimeCoupling;
+  
+  target->fPRFOn              = fPRFOn;
 }
 
 //_____________________________________________________________________________
index 34b990b..102828c 100644 (file)
@@ -52,6 +52,8 @@ public:
   void SetAnodeWireOffset(Float_t offset = 0.25)      { fAnodeWireOffset = offset;};
   void SetTimeStruct(Bool_t tsOn = 1)                 { fTimeStructOn   = tsOn;     };
   
+  void     SetPadResponse(Int_t prfOn = 1)                { fPRFOn          = prfOn;    };
+    
   Float_t  GetGasGain()                             const { return fGasGain;           };
   Float_t  GetNoise()                               const { return fNoise;             };
   Float_t  GetChipGain()                            const { return fChipGain;          };
@@ -82,6 +84,8 @@ public:
   Float_t  GetAnodeWireOffset()                     const { return fAnodeWireOffset;   };
   Bool_t TimeStructOn()                             const { return fTimeStructOn;  };
     
+  Bool_t   PRFOn()                                  const { return fPRFOn;         };
+  
 protected:
   static AliTRDSimParam* fgInstance;     // Instance of this class (singleton implementation)
   static Bool_t fgTerminated;               // Defines if this class has already been terminated and therefore does not return instances in GetInstance anymore
@@ -119,6 +123,8 @@ protected:
   Float_t              fTimeCoupling;                       //  Time coupling factor (image charge of moving ions)
   Int_t                fTimeStructOn;                       //  Switch for cell time structure
   
+  Int_t                fPRFOn;                              //  Switch for the pad response
+  
 private:
   // this is a singleton, constructor is private!  
   AliTRDSimParam();
@@ -128,7 +134,7 @@ private:
   void ReInit();
   void SampleTRF();
   
-  ClassDef(AliTRDSimParam, 0)
+  ClassDef(AliTRDSimParam, 1)
 };
 
 #endif
index 34df464..bb0c734 100644 (file)
 #include "AliTRDCommonParam.h"
 
 #include "AliTRDCalROC.h"
-#include "AliTRDCalChamber.h"
-#include "AliTRDCalStack.h"
+#include "AliTRDCalChamberPos.h"
+#include "AliTRDCalStackPos.h"
 #include "AliTRDCalPad.h"
 #include "AliTRDCalDet.h"
 #include "AliTRDCalGlobals.h"
+#include "AliTRDCalPIDLQ.h"
 
 ClassImp(AliTRDcalibDB)
 
@@ -175,7 +176,7 @@ Bool_t AliTRDcalibDB::GetChamberPos(Int_t det, Float_t* xyz)
   // Returns the deviation of the chamber position from the nominal position.
   //
   
-  AliTRDCalChamber* chamber = dynamic_cast<AliTRDCalChamber*>(GetCachedCDBObject(kIDChamber));
+  AliTRDCalChamberPos* chamber = dynamic_cast<AliTRDCalChamberPos*>(GetCachedCDBObject(kIDChamber));
   if (!chamber)
     return kFALSE;
   
@@ -197,7 +198,7 @@ Bool_t AliTRDcalibDB::GetChamberRot(Int_t det, Float_t* xyz)
   // Returns the rotation of the chamber from the nominal position.
   //
   
-  AliTRDCalChamber* chamber = dynamic_cast<AliTRDCalChamber*>(GetCachedCDBObject(kIDChamber));
+  AliTRDCalChamberPos* chamber = dynamic_cast<AliTRDCalChamberPos*>(GetCachedCDBObject(kIDChamber));
   if (!chamber)
     return kFALSE;
   
@@ -219,7 +220,7 @@ Bool_t AliTRDcalibDB::GetStackPos(Int_t chamber, Int_t sector, Float_t* xyz)
   // Returns the deviation of the stack position from the nominal position.
   //
   
-  AliTRDCalStack* stack = dynamic_cast<AliTRDCalStack*>(GetCachedCDBObject(kIDStack));
+  AliTRDCalStackPos* stack = dynamic_cast<AliTRDCalStackPos*>(GetCachedCDBObject(kIDStack));
   if (!stack)
     return kFALSE;
   
@@ -241,7 +242,7 @@ Bool_t AliTRDcalibDB::GetStackRot(Int_t chamber, Int_t sector, Float_t* xyz)
   // Returns the rotation of the stack from the nominal position.
   //
   
-  AliTRDCalStack* stack = dynamic_cast<AliTRDCalStack*>(GetCachedCDBObject(kIDStack));
+  AliTRDCalStackPos* stack = dynamic_cast<AliTRDCalStackPos*>(GetCachedCDBObject(kIDStack));
   if (!stack)
     return kFALSE;
   
@@ -357,6 +358,22 @@ Int_t AliTRDcalibDB::GetNumberOfTimeBins()
 }
 
 //_____________________________________________________________________________
+AliTRDCalPIDLQ* AliTRDcalibDB::GetPIDLQObject()
+{
+  //
+  // Returns the object storing the distributions for PID with likelihood
+  //
+  
+  // FAKE
+  /*AliTRDCalPIDLQ* pid = new AliTRDCalPIDLQ();
+  pid->ReadData("$ALICE_ROOT/TRD/TRDdEdxHistogramsV1.root");
+  return pid;*/
+  
+  // TODO due to a bug in the CDB this does not work yet
+  return dynamic_cast<AliTRDCalPIDLQ*> (GetCachedCDBObject(kIDPIDLQ));
+}
+
+//_____________________________________________________________________________
 Float_t AliTRDcalibDB::GetOmegaTau(Float_t vdrift)
 {
   //
index 09c014a..09e5be5 100644 (file)
 #include "AliTRDCalPad.h"
 #include "AliTRDCalDet.h"
 
-class AliTRDCalChamber;
-class AliTRDCalStack;
-class AliTRDCalGlobals;
-
-// defines call to function by providing plane, chamber, sector instead of detector
-#define HEADER_PAD(funcname) \
-  Float_t funcname(Int_t plane, Int_t chamber, Int_t sector, Int_t col, Int_t row) \
-  { return funcname(AliTRDgeometry::GetDetector(plane, chamber, sector), col, row); }
-
-// defines call to function by providing plane, chamber, sector instead of detector
-#define HEADER_CHAMBER(funcname) \
-  Bool_t funcname(Int_t plane, Int_t chamber, Int_t sector, Float_t* xyz) \
-  { return funcname(AliTRDgeometry::GetDetector(plane, chamber, sector), xyz); }
+class AliTRDCalPIDLQ;
 
 class AliTRDcalibDB : public TObject
 {
@@ -49,36 +37,39 @@ public:
   void SetRun(Long64_t run);
   
   Bool_t GetChamberPos(Int_t det, Float_t* xyz);
-  HEADER_CHAMBER(GetChamberPos);
+  Bool_t GetChamberPos(Int_t plane, Int_t chamber, Int_t sector, Float_t* xyz) { return GetChamberPos(AliTRDgeometry::GetDetector(plane, chamber, sector), xyz); }  
   
   Bool_t GetChamberRot(Int_t det, Float_t* xyz);
-  HEADER_CHAMBER(GetChamberRot);
+  Bool_t GetChamberRot(Int_t plane, Int_t chamber, Int_t sector, Float_t* xyz) { return GetChamberRot(AliTRDgeometry::GetDetector(plane, chamber, sector), xyz); }  
   
   Bool_t GetStackPos(Int_t chamber, Int_t sector, Float_t* xyz);
   Bool_t GetStackRot(Int_t chamber, Int_t sector, Float_t* xyz);
    
   Float_t GetVdrift(Int_t det, Int_t col, Int_t row);
-  HEADER_PAD(GetVdrift);
+  Float_t GetVdrift(Int_t plane, Int_t chamber, Int_t sector, Int_t col, Int_t row) { return GetVdrift(AliTRDgeometry::GetDetector(plane, chamber, sector), col, row); }
     
   Float_t GetT0(Int_t det, Int_t col, Int_t row);
-  HEADER_PAD(GetT0);
+  Float_t GetT0(Int_t plane, Int_t chamber, Int_t sector, Int_t col, Int_t row) { return GetT0(AliTRDgeometry::GetDetector(plane, chamber, sector), col, row); }
   
   Float_t GetGainFactor(Int_t det, Int_t col, Int_t row);
-  HEADER_PAD(GetGainFactor);
+  Float_t GetGainFactor(Int_t plane, Int_t chamber, Int_t sector, Int_t col, Int_t row) { return GetGainFactor(AliTRDgeometry::GetDetector(plane, chamber, sector), col, row); }
 
   Float_t GetPRFWidth(Int_t det, Int_t col, Int_t row);
-  HEADER_PAD(GetPRFWidth);
+  Float_t GetPRFWidth(Int_t plane, Int_t chamber, Int_t sector, Int_t col, Int_t row) { return GetPRFWidth(AliTRDgeometry::GetDetector(plane, chamber, sector), col, row); }
   
   Float_t GetSamplingFrequency(); 
   Int_t GetNumberOfTimeBins();
   
+  AliTRDCalPIDLQ* GetPIDLQObject();
+  
   //Related functions, these depend on calibration data
   static Float_t GetOmegaTau(Float_t vdrift);
   Int_t PadResponse(Double_t signal, Double_t dist, Int_t plane, Double_t *pad) const;
   
 protected:
-  enum { kCDBCacheSize = 7 };   // Number of cached objects
-  enum { kIDVdrift = 0, kIDT0 = 1, kIDGainFactor = 2, kIDPRFWidth = 3, kIDGlobals = 4, kIDChamber = 5, kIDStack = 6 };    // IDs of cached objects
+  enum { kCDBCacheSize = 8 };   // Number of cached objects
+  enum { kIDVdrift = 0, kIDT0 = 1, kIDGainFactor = 2, kIDPRFWidth = 3, kIDGlobals = 4, 
+         kIDChamber = 5, kIDStack = 6, kIDPIDLQ = 7 };    // IDs of cached objects
   
   TObject* GetCachedCDBObject(Int_t id)
   {
@@ -109,6 +100,7 @@ protected:
       case kIDGlobals : return CacheCDBEntry(kIDGlobals, "TRD/Calib/Globals"); break;
       case kIDChamber : return CacheCDBEntry(kIDChamber, "TRD/Calib/Chamber"); break;
       case kIDStack : return CacheCDBEntry(kIDStack, "TRD/Calib/Stack"); break;
+      case kIDPIDLQ : return CacheCDBEntry(kIDPIDLQ, "TRD/Calib/PIDLQ"); break;
     }
     return 0;
   }
@@ -241,7 +233,4 @@ TObject* AliTRDcalibDB::CacheMergeCDBEntry(Int_t id, const char* cdbPadPath, con
   return fCDBCache[id];
 }
 
-#undef HEADER_PAD
-#undef HEADER_CHAMBER
-
 #endif
index 16d534f..431c4d4 100644 (file)
@@ -960,7 +960,7 @@ Bool_t AliTRDdigitizer::MakeDigits()
           Int_t signal = (Int_t) (-(simParam->GetGasGain()) * TMath::Log(ggRndm));
 
           // Apply the pad response 
-          if (commonParam->PRFOn()) {
+          if (simParam->PRFOn()) {
            // The distance of the electron to the center of the pad 
            // in units of pad width
             //Double_t dist = - colOffset / padPlane->GetColSize(colE);
index ce98dbc..e47ccfd 100644 (file)
@@ -21,6 +21,8 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+// WARNING: This class is obsolete. As soon as all function calls are replaced, the class will be removed.
+
 #include <iostream>
 
 #include "AliRun.h"
index a0a7d6f..92b4f9f 100644 (file)
@@ -11,6 +11,8 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+// WARNING: This class is obsolete. As soon as all function calls are replaced, the class will be removed.
+
 #include "TNamed.h"
 
 class TObjArray;
index ac899f2..e6dd9b7 100644 (file)
@@ -16,7 +16,6 @@
 //-----------------------------------------------------------------
 //           Implementation of the TRD PID class
 // Assigns the electron and pion liklihoods for each ESD track.
-// The AliTRDprobdist class is instantiated here.
 // The function MakePID(AliESD *event) calculates the probability
 // of having dedx and the probability of having timbin at a given 
 // momentum (mom) and particle type k (0 for e) and (2 for pi)
@@ -27,7 +26,8 @@
 #include "AliTRDpidESD.h"
 #include "AliESD.h"
 #include "AliESDtrack.h"
-#include "AliTRDprobdist.h"
+#include "AliTRDcalibDB.h"
+#include "AliTRDCalPIDLQ.h"
 
 ClassImp(AliTRDpidESD)
 
@@ -91,16 +91,18 @@ Int_t AliTRDpidESD::MakePID(AliESD *event)
   //
   //  This function calculates the "detector response" PID probabilities 
   //
-  // The class AliTRDprobdist contains precalculated prob dis.
-  AliTRDprobdist *pd = new AliTRDprobdist();
-  pd->SetADCNorm(1.0); // The factor is the ratio of Mean of pi charge dist.
-                    // for the New TRD code divided by the Mean of pi charge
-                    // dist. given in AliTRDprobdist object
+  
+  AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
+  if (!calibration)
+    return -1;
+  
+  // The class AliTRDCalPIDLQ contains precalculated prob dis.
+  AliTRDCalPIDLQ *pd = calibration->GetPIDLQObject();
 
   //  Example to get mean for particle 2 (pi) and momentum number 4 (2 GeV)
   //  printf("%.2f \n", pd->GetMean(2, 4));
   //  Example of use of Copy Constructor 
-  //  AliTRDprobdist *pd1 = new AliTRDprobdist(*pd);
+  //  AliTRDCalPIDLQ *pd1 = new AliTRDCalPIDLQ(*pd);
 
   Int_t ntrk=event->GetNumberOfTracks();
   for (Int_t i=0; i<ntrk; i++) {
diff --git a/TRD/Calib/PIDLQ/Run0_0_v0_s0.root b/TRD/Calib/PIDLQ/Run0_0_v0_s0.root
new file mode 100644 (file)
index 0000000..029b6d4
Binary files /dev/null and b/TRD/Calib/PIDLQ/Run0_0_v0_s0.root differ
index c3b67a6..1965679 100644 (file)
@@ -36,7 +36,8 @@
 #pragma link C++ class  AliTRDCalPad+;
 #pragma link C++ class  AliTRDCalDet+;
 #pragma link C++ class  AliTRDCalGlobals+;
-#pragma link C++ class  AliTRDCalChamber+;
-#pragma link C++ class  AliTRDCalStack+;
+#pragma link C++ class  AliTRDCalChamberPos+;
+#pragma link C++ class  AliTRDCalStackPos+;
+#pragma link C++ class  AliTRDCalPIDLQ+;
 
 #endif
index fda1187..e4c9663 100644 (file)
@@ -29,7 +29,6 @@
 #pragma link C++ class  AliTRDpidLQ+;
 #pragma link C++ class  AliTRDPartID+;
 #pragma link C++ class  AliTRDpidESD+;
-#pragma link C++ class  AliTRDprobdist+;
 
 #pragma link C++ class  AliTRDReconstructor+;
 #pragma link C++ class  AliTRDRecParam+;
index 12c9997..ab72588 100644 (file)
@@ -18,10 +18,11 @@ SRCS= AliTRDarrayI.cxx \
       AliTRDCalPad.cxx \
       AliTRDCalDet.cxx \
       AliTRDCalGlobals.cxx \
-      AliTRDCalChamber.cxx \
-      AliTRDCalStack.cxx \
+      AliTRDCalChamberPos.cxx \
+      AliTRDCalStackPos.cxx \
       AliTRDCommonParam.cxx \
-      AliTRDcalibDB.cxx
+      AliTRDcalibDB.cxx \
+      AliTRDCalPIDLQ.cxx
 
 HDRS= $(SRCS:.cxx=.h)                
 
index 98a4aa4..7b58537 100644 (file)
@@ -12,7 +12,6 @@ SRCS= AliTRDpixel.cxx \
       AliTRDpidLQ.cxx \
       AliTRDPartID.cxx \
       AliTRDpidESD.cxx \
-      AliTRDprobdist.cxx \
       AliTRDRecParam.cxx \
       AliTRDReconstructor.cxx