Reading muon trigger scalers with the DA of the muon trigger and transfer
[u/mrichter/AliRoot.git] / FASTSIM / AliMUONFastTracking.cxx
index ab0e12d..c38b83e 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.8  2004/01/27 18:02:38  hristov
-Removing some warning (Sun)
-
-Revision 1.7  2003/11/13 14:21:57  morsch
-Coding Rule violation corrections.
-
-Revision 1.6  2003/08/12 15:16:25  morsch
-Saver initialisation of fFitp  array. (Lenaic COUEDEL)
-
-Revision 1.5  2003/08/05 16:14:20  morsch
-Some problems with too big fluctuations corrected. (A. de Falco)
-
-Revision 1.2  2003/01/08 10:29:33  morsch
-Path to data file changed.
-
-Revision 1.1  2003/01/06 10:13:33  morsch
-First commit.
-
-*/
+/* $Id$ */
 
 //-------------------------------------------------------------------------
 //        Class AliMUONFastTracking 
@@ -46,24 +26,30 @@ First commit.
 //  AliFastMuonTrackingRes. 
 //-------------------------------------------------------------------------
 
-#include "AliMUONFastTracking.h"
-#include "AliMUONFastTrackingEntry.h"
-#include <TSpline.h>
-#include <TFile.h>
-#include <TH3.h>
-#include <TF1.h>
-#include <TRandom.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+
 #include <Riostream.h>
+#include <TF1.h>
+#include <TFile.h>
+#include <TH3.h>
+#include <TMath.h>
+#include <TRandom.h>
+#include <TSpline.h>
 
+#include "AliMUONFastTracking.h"
+#include "AliMUONFastTrackingEntry.h"
+
+using std::cout;
+using std::endl;
 ClassImp(AliMUONFastTracking)
 
 
 AliMUONFastTracking* AliMUONFastTracking::fgMUONFastTracking=NULL;
 
 static Double_t FitP(Double_t *x, Double_t *par){
+// Fit function
     Double_t dx = x[0] - par[0];
     Double_t dx2 = x[0] - par[4];
     Double_t sigma = par[1] * ( 1 + par[2] * dx);
@@ -75,10 +61,27 @@ static Double_t FitP(Double_t *x, Double_t *par){
     Double_t sigma2 = par[1] * par[5];
     Double_t fgauss = TMath::Exp(-0.5 * dx2 * dx2 / (sigma2 * sigma2));
     Double_t value = fasymm + par[3] * fgauss; 
-    return value;
+    return TMath::Abs(value);
 } 
 
-AliMUONFastTracking::AliMUONFastTracking(const AliMUONFastTracking & ft):TObject()
+AliMUONFastTracking::AliMUONFastTracking(const AliMUONFastTracking & ft):
+    TObject(),
+    fNbinp(10),
+    fPmin(0.),
+    fPmax(200.),
+    fDeltaP((fPmax-fPmin)/fNbinp),
+    fNbintheta(10),
+    fThetamin(2.),
+    fThetamax(9.),
+    fDeltaTheta((fThetamax-fThetamin)/fNbintheta),
+    fNbinphi(10),
+    fPhimin(-180.),
+    fPhimax(180.),
+    fDeltaPhi((fPhimax-fPhimin)/fNbinphi),
+    fPrintLevel(1),
+    fBkg(0.),
+    fSpline(0),
+    fClusterFinder(kOld)                                                                        
 {
 // Copy constructor
     ft.Copy(*this);
@@ -96,7 +99,23 @@ AliMUONFastTracking* AliMUONFastTracking::Instance()
     }
 }
 
-AliMUONFastTracking::AliMUONFastTracking() 
+AliMUONFastTracking::AliMUONFastTracking():
+    fNbinp(10),
+    fPmin(0.),
+    fPmax(200.),
+    fDeltaP((fPmax-fPmin)/fNbinp),
+    fNbintheta(10),
+    fThetamin(2.),
+    fThetamax(9.),
+    fDeltaTheta((fThetamax-fThetamin)/fNbintheta),
+    fNbinphi(10),
+    fPhimin(-180.),
+    fPhimax(180.),
+    fDeltaPhi((fPhimax-fPhimin)/fNbinphi),
+    fPrintLevel(1),
+    fBkg(0.),
+    fSpline(0),
+    fClusterFinder(kOld)
 {
 //
 // constructor
@@ -108,33 +127,6 @@ AliMUONFastTracking::AliMUONFastTracking()
       }
     }
   }
-
-    fClusterFinder = kOld; 
-    fPrintLevel = 1;  
-    // read binning; temporarily put by hand
-    Float_t pmin = 0, pmax = 200;
-    Int_t   nbinp = 10;
-    Float_t thetamin = 2, thetamax = 9;
-    Int_t   nbintheta=10;
-    Float_t phimin = -180, phimax =180;
-    Int_t   nbinphi=10;
-    //--------------------------------------
-
-    fNbinp = nbinp;
-    fPmin  = pmin;
-    fPmax  = pmax;
-    
-    fNbintheta = nbintheta;
-    fThetamin  = thetamin;
-    fThetamax  = thetamax;
-    
-    fNbinphi = nbinphi;
-    fPhimin  = phimin;
-    fPhimax  = phimax;
-    
-    fDeltaP     = (fPmax-fPmin)/fNbinp;
-    fDeltaTheta = (fThetamax-fThetamin)/fNbintheta;
-    fDeltaPhi   = (fPhimax-fPhimin)/fNbinphi;
 }
 
 void AliMUONFastTracking::Init(Float_t bkg)
@@ -154,8 +146,8 @@ void AliMUONFastTracking::Init(Float_t bkg)
   }
   
   char filename [100]; 
-  if (fClusterFinder==kOld) sprintf (filename,"$(ALICE_ROOT)/FASTSIM/data/MUONtrackLUT.root"); 
-  else sprintf (filename,"$(ALICE_ROOT)/FASTSIM/data/MUONtrackLUT-AZ.root"); 
+  if (fClusterFinder==kOld) snprintf (filename, 100, "$(ALICE_ROOT)/FASTSIM/data/MUONtrackLUT.root"); 
+  else snprintf (filename, 100, "$(ALICE_ROOT)/FASTSIM/data/MUONtrackLUT-AZ.root"); 
 
   TFile *file = new TFile(filename); 
   ReadLUT(file);
@@ -178,13 +170,13 @@ void AliMUONFastTracking::ReadLUT(TFile* file)
 
   const Float_t kBkg[4] = {0, 0.5, 1, 2};
   for (Int_t ibkg=0; ibkg<4; ibkg++) {
-    sprintf (tag,"BKG%g",kBkg[ibkg]); 
+    snprintf (tag, 40, "BKG%g",kBkg[ibkg]); 
     file->cd(tag);
     for (Int_t isplp = 0; isplp<kSplitP; isplp++) { 
       for (Int_t ispltheta = 0; ispltheta<kSplitTheta; ispltheta++) { 
-       sprintf (tag2,"heff[%d][%d]",isplp,ispltheta); 
+       snprintf (tag2, 40, "heff[%d][%d]",isplp,ispltheta); 
        heff[isplp][ispltheta] = (TH3F*)gDirectory->Get(tag2);
-       sprintf (tag2,"hacc[%d][%d]",isplp,ispltheta); 
+       snprintf (tag2, 40, "hacc[%d][%d]",isplp,ispltheta); 
        hacc[isplp][ispltheta] = (TH3F*)gDirectory->Get(tag2);
       }
     }    
@@ -209,42 +201,27 @@ void AliMUONFastTracking::ReadLUT(TFile* file)
          Float_t theta = fThetamin + fDeltaTheta * (itheta + 0.5);
          Float_t phi   = fPhimin   + fDeltaPhi   * (iphi   + 0.5);
          
-         fEntry[ip][itheta][iphi][ibkg]->fP          = p;
-         fEntry[ip][itheta][iphi][ibkg]->fMeanp      = 
-           hmeanp->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fSigmap     = 
-           TMath::Abs(hsigmap->GetBinContent(ip+1,itheta+1,iphi+1));
-         fEntry[ip][itheta][iphi][ibkg]->fSigma1p    = 
-           hsigma1p->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fChi2p      = 
-           hchi2p->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fNormG2     = 
-           hnormg2->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fMeanG2     = 
-           hmeang2->GetBinContent(ip+1,itheta+1,iphi+1);
-         if (ibkg == 0)  fEntry[ip][itheta][iphi][ibkg]->fSigmaG2 = 9999;
-         else fEntry[ip][itheta][iphi][ibkg]->fSigmaG2    = 
-           hsigmag2->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fTheta      = theta;
-         fEntry[ip][itheta][iphi][ibkg]->fMeantheta  = 
-           hmeantheta->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fSigmatheta = 
-           TMath::Abs(hsigmatheta->GetBinContent(ip+1,itheta+1,iphi+1));
-         fEntry[ip][itheta][iphi][ibkg]->fChi2theta  = 
-           hchi2theta->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fPhi        = phi;
-         fEntry[ip][itheta][iphi][ibkg]->fMeanphi    = 
-           hmeanphi->GetBinContent(ip+1,itheta+1,iphi+1);
-         fEntry[ip][itheta][iphi][ibkg]->fSigmaphi   = 
-           TMath::Abs(hsigmaphi->GetBinContent(ip+1,itheta+1,iphi+1));
-         fEntry[ip][itheta][iphi][ibkg]->fChi2phi    = 
-           hchi2phi->GetBinContent(ip+1,itheta+1,iphi+1);
+         fEntry[ip][itheta][iphi][ibkg]->SetP(p);
+         fEntry[ip][itheta][iphi][ibkg]->SetMeanp(hmeanp->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetSigmap(TMath::Abs(hsigmap->GetBinContent(ip+1,itheta+1,iphi+1)));
+         fEntry[ip][itheta][iphi][ibkg]->SetSigma1p(hsigma1p->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetChi2p(hchi2p->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetNormG2(hnormg2->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetMeanG2(hmeang2->GetBinContent(ip+1,itheta+1,iphi+1));
+         if (ibkg == 0)  fEntry[ip][itheta][iphi][ibkg]->SetSigmaG2(9999);
+         else fEntry[ip][itheta][iphi][ibkg]->SetSigmaG2(hsigmag2->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetTheta(theta);
+         fEntry[ip][itheta][iphi][ibkg]->SetMeantheta(hmeantheta->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetSigmatheta(TMath::Abs(hsigmatheta->GetBinContent(ip+1,itheta+1,iphi+1)));
+         fEntry[ip][itheta][iphi][ibkg]->SetChi2theta(hchi2theta->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetPhi(phi);
+         fEntry[ip][itheta][iphi][ibkg]->SetMeanphi(hmeanphi->GetBinContent(ip+1,itheta+1,iphi+1));
+         fEntry[ip][itheta][iphi][ibkg]->SetSigmaphi(TMath::Abs(hsigmaphi->GetBinContent(ip+1,itheta+1,iphi+1)));
+         fEntry[ip][itheta][iphi][ibkg]->SetChi2phi(hchi2phi->GetBinContent(ip+1,itheta+1,iphi+1));
          for (Int_t i=0; i<kSplitP; i++) { 
            for (Int_t j=0; j<kSplitTheta; j++) { 
-             fEntry[ip][itheta][iphi][ibkg]->fAcc[i][j] = 
-               hacc[i][j]->GetBinContent(ip+1,itheta+1,iphi+1);
-             fEntry[ip][itheta][iphi][ibkg]->fEff[i][j] = 
-               heff[i][j]->GetBinContent(ip+1,itheta+1,iphi+1);
+             fEntry[ip][itheta][iphi][ibkg]->SetAcc(i,j,hacc[i][j]->GetBinContent(ip+1,itheta+1,iphi+1));
+             fEntry[ip][itheta][iphi][ibkg]->SetEff(i,j,heff[i][j]->GetBinContent(ip+1,itheta+1,iphi+1));
            }
          }
        } // iphi 
@@ -258,11 +235,11 @@ void AliMUONFastTracking::ReadLUT(TFile* file)
   for (Int_t ip=0; ip< fNbinp; ip++){
     for (Int_t itheta=0; itheta< fNbintheta; itheta++){
       for (Int_t iphi=0; iphi< fNbinphi; iphi++){
-       graph->SetPoint(0,0.5,fEntry[ip][itheta][iphi][1]->fSigmaG2);
-       graph->SetPoint(1,1,fEntry[ip][itheta][iphi][2]->fSigmaG2);
-       graph->SetPoint(2,2,fEntry[ip][itheta][iphi][3]->fSigmaG2);
+       graph->SetPoint(0,0.5,fEntry[ip][itheta][iphi][1]->GetSigmaG2());
+       graph->SetPoint(1,1,fEntry[ip][itheta][iphi][2]->GetSigmaG2());
+       graph->SetPoint(2,2,fEntry[ip][itheta][iphi][3]->GetSigmaG2());
        graph->Fit("f","q"); 
-       fEntry[ip][itheta][iphi][0]->fSigmaG2 = f->Eval(0); 
+       fEntry[ip][itheta][iphi][0]->SetSigmaG2(f->Eval(0)); 
       }
     }
   }
@@ -340,7 +317,7 @@ Float_t AliMUONFastTracking::Efficiency(Float_t p,   Float_t theta,
   Int_t ibinp  = Int_t(nSplitP*(dp - fDeltaP * Int_t(dp / fDeltaP))/fDeltaP); 
   Float_t dtheta = theta - fThetamin;
   Int_t ibintheta  = Int_t(nSplitTheta*(dtheta - fDeltaTheta * Int_t(dtheta / fDeltaTheta))/fDeltaTheta); 
-  Float_t eff = fCurrentEntry[ip][itheta][iphi]->fEff[ibinp][ibintheta];
+  Float_t eff = fCurrentEntry[ip][itheta][iphi]->GetEff(ibinp,ibintheta);
   return eff;   
 }
 
@@ -361,7 +338,7 @@ Float_t AliMUONFastTracking::Acceptance(Float_t p,   Float_t theta,
   Int_t ibinp  = Int_t(nSplitP*(dp - fDeltaP * Int_t(dp / fDeltaP))/fDeltaP); 
   Float_t dtheta = theta - fThetamin;
   Int_t ibintheta  = Int_t(nSplitTheta*(dtheta - fDeltaTheta * Int_t(dtheta / fDeltaTheta))/fDeltaTheta); 
-  Float_t acc = fCurrentEntry[ip][itheta][iphi]->fAcc[ibinp][ibintheta];
+  Float_t acc = fCurrentEntry[ip][itheta][iphi]->GetAcc(ibinp,ibintheta);
   return acc;   
 }
 
@@ -373,7 +350,7 @@ Float_t AliMUONFastTracking::MeanP(Float_t p,   Float_t theta,
   //
     Int_t ip=0, itheta=0, iphi=0;
     GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
-    return fCurrentEntry[ip][itheta][iphi]->fMeanp;
+    return fCurrentEntry[ip][itheta][iphi]->GetMeanp();
 }
 
 Float_t AliMUONFastTracking::SigmaP(Float_t p,   Float_t theta, 
@@ -386,7 +363,7 @@ Float_t AliMUONFastTracking::SigmaP(Float_t p,   Float_t theta,
     Int_t index;
     GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
     // central value and corrections with spline 
-    Float_t sigmap = fCurrentEntry[ip][itheta][iphi]->fSigmap;
+    Float_t sigmap = fCurrentEntry[ip][itheta][iphi]->GetSigmap();
     if (!fSpline) return sigmap;
     // corrections vs p, theta, phi 
     index = iphi + fNbinphi * itheta;
@@ -394,9 +371,9 @@ Float_t AliMUONFastTracking::SigmaP(Float_t p,   Float_t theta,
     Float_t frac1 = fSplineSigmap[index][0]->Eval(p)/sigmap; 
     
     if (p>fPmax-fDeltaP/2.) {
-       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->fSigmap;
-       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->fSigmap;
-       Float_t s3 = fCurrentEntry[fNbinp-3][itheta][iphi]->fSigmap;
+       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->GetSigmap();
+       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->GetSigmap();
+       Float_t s3 = fCurrentEntry[fNbinp-3][itheta][iphi]->GetSigmap();
        Float_t p1  = fDeltaP * (fNbinp - 1 + 0.5) + fPmin;
        Float_t p2  = fDeltaP * (fNbinp - 2 + 0.5) + fPmin;
        Float_t p3  = fDeltaP * (fNbinp - 3 + 0.5) + fPmin;
@@ -434,14 +411,14 @@ Float_t AliMUONFastTracking::Sigma1P(Float_t p,   Float_t theta,
     GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
     if (p>fPmax) {
        // linear extrapolation of sigmap for p out of range 
-       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->fSigma1p;
-       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->fSigma1p;
+       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->GetSigma1p();
+       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->GetSigma1p();
        Float_t p1  = fDeltaP * (fNbinp - 1 + 0.5) + fPmin;
        Float_t p2  = fDeltaP * (fNbinp - 2 + 0.5) + fPmin;
        Float_t sigma = 1./(p1-p2) * ( (s1-s2)*p + (s2-s1)*p1 + s1*(p1-p2) ); 
        return sigma;
     }
-    else return fCurrentEntry[ip][itheta][iphi]->fSigma1p;
+    else return fCurrentEntry[ip][itheta][iphi]->GetSigma1p();
 }
 
 Float_t AliMUONFastTracking::NormG2(Float_t p,   Float_t theta, 
@@ -455,14 +432,14 @@ Float_t AliMUONFastTracking::NormG2(Float_t p,   Float_t theta,
     GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
     if (p>fPmax) {
        // linear extrapolation of sigmap for p out of range 
-       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->fNormG2;
-       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->fNormG2;
+       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->GetNormG2();
+       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->GetNormG2();
        Float_t p1  = fDeltaP * (fNbinp - 1 + 0.5) + fPmin;
        Float_t p2  = fDeltaP * (fNbinp - 2 + 0.5) + fPmin;
        Float_t norm = 1./(p1-p2) * ( (s1-s2)*p + (s2-s1)*p1 + s1*(p1-p2) ); 
        return norm;
     }
-    else return fCurrentEntry[ip][itheta][iphi]->fNormG2;
+    else return fCurrentEntry[ip][itheta][iphi]->GetNormG2();
 }
 
 Float_t AliMUONFastTracking::MeanG2(Float_t p,   Float_t theta, 
@@ -476,14 +453,14 @@ Float_t AliMUONFastTracking::MeanG2(Float_t p,   Float_t theta,
     GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
     if (p>fPmax) {
        // linear extrapolation of sigmap for p out of range 
-       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->fMeanG2;
-       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->fMeanG2;
+       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->GetMeanG2();
+       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->GetMeanG2();
        Float_t p1  = fDeltaP * (fNbinp - 1 + 0.5) + fPmin;
        Float_t p2  = fDeltaP * (fNbinp - 2 + 0.5) + fPmin;
        Float_t norm = 1./(p1-p2) * ( (s1-s2)*p + (s2-s1)*p1 + s1*(p1-p2) ); 
        return norm;
     }
-    else return fCurrentEntry[ip][itheta][iphi]->fMeanG2;
+    else return fCurrentEntry[ip][itheta][iphi]->GetMeanG2();
 }
 
 Float_t AliMUONFastTracking::SigmaG2(Float_t p,   Float_t theta, 
@@ -497,14 +474,14 @@ Float_t AliMUONFastTracking::SigmaG2(Float_t p,   Float_t theta,
     GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
     if (p>fPmax) {
        // linear extrapolation of sigmap for p out of range 
-       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->fSigmaG2;
-       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->fSigmaG2;
+       Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->GetSigmaG2();
+       Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->GetSigmaG2();
        Float_t p1  = fDeltaP * (fNbinp - 1 + 0.5) + fPmin;
        Float_t p2  = fDeltaP * (fNbinp - 2 + 0.5) + fPmin;
        Float_t sigma = 1./(p1-p2) * ( (s1-s2)*p + (s2-s1)*p1 + s1*(p1-p2) ); 
        return sigma;
     }
-    else return fCurrentEntry[ip][itheta][iphi]->fSigmaG2;
+    else return fCurrentEntry[ip][itheta][iphi]->GetSigmaG2();
 }
 
 
@@ -516,7 +493,7 @@ Float_t AliMUONFastTracking::MeanTheta(Float_t p,   Float_t theta,
   //
     Int_t ip=0, itheta=0, iphi=0;
     GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
-    return fCurrentEntry[ip][itheta][iphi]->fMeantheta;
+    return fCurrentEntry[ip][itheta][iphi]->GetMeantheta();
 }
 
 Float_t AliMUONFastTracking::SigmaTheta(Float_t p,   Float_t theta,  
@@ -529,7 +506,7 @@ Float_t AliMUONFastTracking::SigmaTheta(Float_t p,   Float_t theta,
   Int_t index;
   GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
   // central value and corrections with spline 
-  Float_t sigmatheta = fCurrentEntry[ip][itheta][iphi]->fSigmatheta;
+  Float_t sigmatheta = fCurrentEntry[ip][itheta][iphi]->GetSigmatheta();
   if (!fSpline) return sigmatheta;
   // corrections vs p, theta, phi 
   index = iphi + fNbinphi * itheta;
@@ -537,8 +514,8 @@ Float_t AliMUONFastTracking::SigmaTheta(Float_t p,   Float_t theta,
   Float_t frac1 = fSplineSigmatheta[index][0]->Eval(p)/sigmatheta; 
   if (p>fPmax-fDeltaP/2.) {
     // linear extrapolation of sigmap for p out of range 
-    Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->fSigmatheta;
-    Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->fSigmatheta;
+    Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->GetSigmatheta();
+    Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->GetSigmatheta();
     Float_t p1  = fDeltaP * (fNbinp - 1 + 0.5) + fPmin;
     Float_t p2  = fDeltaP * (fNbinp - 2 + 0.5) + fPmin;
     Float_t sigma = 1./(p1-p2) * ( (s1-s2)*p + (s2-s1)*p1 + s1*(p1-p2) ); 
@@ -566,7 +543,7 @@ Float_t AliMUONFastTracking::MeanPhi(Float_t p,   Float_t theta,
   //
   Int_t ip=0, itheta=0, iphi=0;
   GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
-  return fCurrentEntry[ip][itheta][iphi]->fMeanphi;
+  return fCurrentEntry[ip][itheta][iphi]->GetMeanphi();
 }
 
 Float_t AliMUONFastTracking::SigmaPhi(Float_t p,   Float_t theta, 
@@ -578,15 +555,15 @@ Float_t AliMUONFastTracking::SigmaPhi(Float_t p,   Float_t theta,
   Int_t index;
   GetIpIthetaIphi(p,theta,phi,charge,ip,itheta,iphi);
   // central value and corrections with spline 
-  Float_t sigmaphi = fCurrentEntry[ip][itheta][iphi]->fSigmaphi;
+  Float_t sigmaphi = fCurrentEntry[ip][itheta][iphi]->GetSigmaphi();
   if (!fSpline) return sigmaphi;
   // corrections vs p, theta, phi 
   index = iphi + fNbinphi * itheta;
   Float_t frac1 = fSplineSigmaphi[index][0]->Eval(p)/sigmaphi; 
   Double_t xmin,ymin,xmax,ymax;
   if (p>fPmax-fDeltaP/2.) {
-    Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->fSigmaphi;
-    Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->fSigmaphi;
+    Float_t s1 = fCurrentEntry[fNbinp-1][itheta][iphi]->GetSigmaphi();
+    Float_t s2 = fCurrentEntry[fNbinp-2][itheta][iphi]->GetSigmaphi();
     Float_t p1  = fDeltaP * (fNbinp - 1 + 0.5) + fPmin;
     Float_t p2  = fDeltaP * (fNbinp - 2 + 0.5) + fPmin;
     Float_t sigma = 1./(p1-p2) * ( (s1-s2)*p + (s2-s1)*p1 + s1*(p1-p2) ); 
@@ -638,27 +615,23 @@ void AliMUONFastTracking::SetSpline(){
   for (Int_t itheta=0; itheta< fNbintheta; itheta++){
     for (Int_t iphi=0; iphi< fNbinphi; iphi++){
       for (Int_t ip=0; ip<fNbinp; ip++) {
-       //      for (Int_t i=0; i<5; i++) { 
-       //        yeff[5 * ip + i]  = fCurrentEntry[ip][itheta][iphi]->fEff[i];
-       //        yacc[5 * ip + i]  = fCurrentEntry[ip][itheta][iphi]->fAcc[i];
-       //      }
-       ysigmap[ip]     = fCurrentEntry[ip][itheta][iphi]->fSigmap;
-       ysigma1p[ip]    = fCurrentEntry[ip][itheta][iphi]->fSigma1p;
-       ysigmatheta[ip] = fCurrentEntry[ip][itheta][iphi]->fSigmatheta;
-       ysigmaphi[ip]   = fCurrentEntry[ip][itheta][iphi]->fSigmaphi;
+       ysigmap[ip]     = fCurrentEntry[ip][itheta][iphi]->GetSigmap();
+       ysigma1p[ip]    = fCurrentEntry[ip][itheta][iphi]->GetSigma1p();
+       ysigmatheta[ip] = fCurrentEntry[ip][itheta][iphi]->GetSigmatheta();
+       ysigmaphi[ip]   = fCurrentEntry[ip][itheta][iphi]->GetSigmaphi();
       }
       if (fPrintLevel>3) cout << " creating new spline " << splname << endl;
-      sprintf (splname,"fSplineEff[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineEff[%d][%d]",ispline,ivar);
       fSplineEff[ispline][ivar] = new TSpline3(splname,xsp2,yeff,5 * nbins[ivar]);
-      sprintf (splname,"fSplineAcc[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineAcc[%d][%d]",ispline,ivar);
       fSplineAcc[ispline][ivar] = new TSpline3(splname,xsp2,yacc,5 * nbins[ivar]);
-      sprintf (splname,"fSplineSigmap[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmap[%d][%d]",ispline,ivar);
       fSplineSigmap[ispline][ivar] = new TSpline3(splname,xspl,ysigmap,nbins[ivar]);
-      sprintf (splname,"fSplineSigma1p[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigma1p[%d][%d]",ispline,ivar);
       fSplineSigma1p[ispline][ivar] = new TSpline3(splname,xspl,ysigma1p,nbins[ivar]);
-      sprintf (splname,"fSplineSigmatheta[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmatheta[%d][%d]",ispline,ivar);
       fSplineSigmatheta[ispline][ivar] = new TSpline3(splname,xspl,ysigmatheta,nbins[ivar]);
-      sprintf (splname,"fSplineSigmaphi[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmaphi[%d][%d]",ispline,ivar);
       fSplineSigmaphi[ispline][ivar] = new TSpline3(splname,xspl,ysigmaphi,nbins[ivar]);
       ispline++;
     }
@@ -671,25 +644,23 @@ void AliMUONFastTracking::SetSpline(){
     for (Int_t iphi=0; iphi< fNbinphi; iphi++){
       for (Int_t itheta=0; itheta< fNbintheta; itheta++){
        // for efficiency and acceptance let's take the central value
-       //      yeff[itheta]        = fCurrentEntry[ip][itheta][iphi]->fEff[2];
-       //      yacc[itheta]        = fCurrentEntry[ip][itheta][iphi]->fAcc[2];
-       ysigmap[itheta]     = fCurrentEntry[ip][itheta][iphi]->fSigmap;
-       ysigma1p[itheta]    = fCurrentEntry[ip][itheta][iphi]->fSigma1p;
-       ysigmatheta[itheta] = fCurrentEntry[ip][itheta][iphi]->fSigmatheta;
-       ysigmaphi[itheta]   = fCurrentEntry[ip][itheta][iphi]->fSigmaphi;
+       ysigmap[itheta]     = fCurrentEntry[ip][itheta][iphi]->GetSigmap();
+       ysigma1p[itheta]    = fCurrentEntry[ip][itheta][iphi]->GetSigma1p();
+       ysigmatheta[itheta] = fCurrentEntry[ip][itheta][iphi]->GetSigmatheta();
+       ysigmaphi[itheta]   = fCurrentEntry[ip][itheta][iphi]->GetSigmaphi();
       }
       if (fPrintLevel>3) cout << " creating new spline " << splname << endl;
-      sprintf (splname,"fSplineEff[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineEff[%d][%d]",ispline,ivar);
       fSplineEff[ispline][ivar] = new TSpline3(splname,xspl,yeff, nbins[ivar]);
-      sprintf (splname,"fSplineAcc[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineAcc[%d][%d]",ispline,ivar);
       fSplineAcc[ispline][ivar] = new TSpline3(splname,xspl,yacc, nbins[ivar]);
-      sprintf (splname,"fSplineSigmap[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmap[%d][%d]",ispline,ivar);
       fSplineSigmap[ispline][ivar] = new TSpline3(splname,xspl,ysigmap,nbins[ivar]);
-      sprintf (splname,"fSplineSigma1p[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigma1p[%d][%d]",ispline,ivar);
       fSplineSigma1p[ispline][ivar] = new TSpline3(splname,xspl,ysigma1p,nbins[ivar]);
-      sprintf (splname,"fSplineSigmatheta[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmatheta[%d][%d]",ispline,ivar);
       fSplineSigmatheta[ispline][ivar] = new TSpline3(splname,xspl,ysigmatheta,nbins[ivar]);
-      sprintf (splname,"fSplineSigmaphi[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmaphi[%d][%d]",ispline,ivar);
       fSplineSigmaphi[ispline][ivar] = new TSpline3(splname,xspl,ysigmaphi,nbins[ivar]);
       ispline++;
     }
@@ -702,25 +673,23 @@ void AliMUONFastTracking::SetSpline(){
     for (Int_t itheta=0; itheta< fNbintheta; itheta++){
       for (Int_t iphi=0; iphi< fNbinphi; iphi++){
        // for efficiency and acceptance let's take the central value
-       //      yeff[iphi]        = fCurrentEntry[ip][itheta][iphi]->fEff[2];
-       //      yacc[iphi]        = fCurrentEntry[ip][itheta][iphi]->fAcc[2];
-       ysigmap[iphi]     = fCurrentEntry[ip][itheta][iphi]->fSigmap;
-       ysigma1p[iphi]    = fCurrentEntry[ip][itheta][iphi]->fSigma1p;
-       ysigmatheta[iphi] = fCurrentEntry[ip][itheta][iphi]->fSigmatheta;
-       ysigmaphi[iphi]   = fCurrentEntry[ip][itheta][iphi]->fSigmaphi;
+       ysigmap[iphi]     = fCurrentEntry[ip][itheta][iphi]->GetSigmap();
+       ysigma1p[iphi]    = fCurrentEntry[ip][itheta][iphi]->GetSigma1p();
+       ysigmatheta[iphi] = fCurrentEntry[ip][itheta][iphi]->GetSigmatheta();
+       ysigmaphi[iphi]   = fCurrentEntry[ip][itheta][iphi]->GetSigmaphi();
       }
       if (fPrintLevel>3) cout << " creating new spline " << splname << endl;
-      sprintf (splname,"fSplineEff[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineEff[%d][%d]",ispline,ivar);
       fSplineEff[ispline][ivar] = new TSpline3(splname,xspl,yeff, nbins[ivar]);
-      sprintf (splname,"fSplineAcc[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineAcc[%d][%d]",ispline,ivar);
       fSplineAcc[ispline][ivar] = new TSpline3(splname,xspl,yacc, nbins[ivar]);
-      sprintf (splname,"fSplineSigmap[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmap[%d][%d]",ispline,ivar);
       fSplineSigmap[ispline][ivar] = new TSpline3(splname,xspl,ysigmap,nbins[ivar]);
-      sprintf (splname,"fSplineSigma1p[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigma1p[%d][%d]",ispline,ivar);
       fSplineSigma1p[ispline][ivar] = new TSpline3(splname,xspl,ysigma1p,nbins[ivar]);
-      sprintf (splname,"fSplineSigmatheta[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmatheta[%d][%d]",ispline,ivar);
       fSplineSigmatheta[ispline][ivar] = new TSpline3(splname,xspl,ysigmatheta,nbins[ivar]);
-      sprintf (splname,"fSplineSigmaphi[%d][%d]",ispline,ivar);
+      snprintf (splname, 40, "fSplineSigmaphi[%d][%d]",ispline,ivar);
       fSplineSigmaphi[ispline][ivar] = new TSpline3(splname,xspl,ysigmaphi,nbins[ivar]);
       ispline++;
     }
@@ -751,50 +720,50 @@ void AliMUONFastTracking::SetBackground(Float_t bkg){
   for (Int_t ip=0; ip< fNbinp; ip++){
     for (Int_t itheta=0; itheta< fNbintheta; itheta++){
       for (Int_t iphi=0; iphi< fNbinphi; iphi++){
-       fCurrentEntry[ip][itheta][iphi]->fP = fEntry[ip][itheta][iphi][ibkg]->fP;
-       fCurrentEntry[ip][itheta][iphi]->fTheta = fEntry[ip][itheta][iphi][ibkg]->fTheta;
-       fCurrentEntry[ip][itheta][iphi]->fPhi = fEntry[ip][itheta][iphi][ibkg]->fPhi;
-       fCurrentEntry[ip][itheta][iphi]->fChi2p = -1;
-       fCurrentEntry[ip][itheta][iphi]->fChi2theta = -1;
-       fCurrentEntry[ip][itheta][iphi]->fChi2phi = -1;
-
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fMeanp;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fMeanp;
-       fCurrentEntry[ip][itheta][iphi]      ->fMeanp = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fMeantheta;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fMeantheta;
-       fCurrentEntry[ip][itheta][iphi]      ->fMeantheta = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fMeanphi;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fMeanphi;
-       fCurrentEntry[ip][itheta][iphi]      ->fMeanphi = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fSigmap;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fSigmap;
-       fCurrentEntry[ip][itheta][iphi]      ->fSigmap = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fSigmatheta;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fSigmatheta;
-       fCurrentEntry[ip][itheta][iphi]      ->fSigmatheta = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fSigmaphi;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fSigmaphi;
-       fCurrentEntry[ip][itheta][iphi]      ->fSigmaphi = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fSigma1p;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fSigma1p;
-       fCurrentEntry[ip][itheta][iphi]      ->fSigma1p = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fNormG2;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fNormG2;
-       fCurrentEntry[ip][itheta][iphi]      ->fNormG2 = (y1 - y0) * x + y0;
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fMeanG2;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fMeanG2;
-       fCurrentEntry[ip][itheta][iphi]      ->fMeanG2 = (y1 - y0) * x + y0;
+       fCurrentEntry[ip][itheta][iphi]->SetP(fEntry[ip][itheta][iphi][ibkg]->GetP());
+       fCurrentEntry[ip][itheta][iphi]->SetTheta(fEntry[ip][itheta][iphi][ibkg]->GetTheta());
+       fCurrentEntry[ip][itheta][iphi]->SetPhi(fEntry[ip][itheta][iphi][ibkg]->GetPhi());
+       fCurrentEntry[ip][itheta][iphi]->SetChi2p(-1);
+       fCurrentEntry[ip][itheta][iphi]->SetChi2theta(-1);
+       fCurrentEntry[ip][itheta][iphi]->SetChi2phi(-1);
+
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetMeanp();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetMeanp();
+       fCurrentEntry[ip][itheta][iphi]      ->SetMeanp((y1 - y0) * x + y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetMeantheta();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetMeantheta();
+       fCurrentEntry[ip][itheta][iphi]      ->SetMeantheta((y1 - y0) * x +y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetMeanphi();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetMeanphi();
+       fCurrentEntry[ip][itheta][iphi]      ->SetMeanphi((y1 - y0) * x + y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetSigmap();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetSigmap();
+       fCurrentEntry[ip][itheta][iphi]      ->SetSigmap((y1 - y0) * x + y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetSigmatheta();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetSigmatheta();
+       fCurrentEntry[ip][itheta][iphi]      ->SetSigmatheta((y1 - y0) * x+y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetSigmaphi();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetSigmaphi();
+       fCurrentEntry[ip][itheta][iphi]      ->SetSigmaphi((y1 - y0) * x + y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetSigma1p();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetSigma1p();
+       fCurrentEntry[ip][itheta][iphi]      ->SetSigma1p((y1 - y0) * x + y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetNormG2();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetNormG2();
+       fCurrentEntry[ip][itheta][iphi]      ->SetNormG2((y1 - y0) * x + y0);
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetMeanG2();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetMeanG2();
+       fCurrentEntry[ip][itheta][iphi]      ->SetMeanG2((y1 - y0) * x + y0);
        
-       y0 = fEntry[ip][itheta][iphi][ibkg-1]->fSigmaG2;
-       y1 =   fEntry[ip][itheta][iphi][ibkg]->fSigmaG2;
-       fCurrentEntry[ip][itheta][iphi]      ->fSigmaG2 = (y1 - y0) * x + y0;
+       y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetSigmaG2();
+       y1 =   fEntry[ip][itheta][iphi][ibkg]->GetSigmaG2();
+       fCurrentEntry[ip][itheta][iphi]      ->SetSigmaG2((y1 - y0) * x + y0);
        for (Int_t i=0; i<kSplitP; i++) {
          for (Int_t j=0; j<kSplitTheta; j++) {
-           fCurrentEntry[ip][itheta][iphi]->fAcc[i][j] = fEntry[ip][itheta][iphi][ibkg]->fAcc[i][j];
-           y0 = fEntry[ip][itheta][iphi][ibkg-1]->fEff[i][j];
-           y1 =   fEntry[ip][itheta][iphi][ibkg]->fEff[i][j];
-           fCurrentEntry[ip][itheta][iphi]->fEff[i][j] = (y1 - y0) * x + y0;
+           fCurrentEntry[ip][itheta][iphi]->SetAcc(i,j,fEntry[ip][itheta][iphi][ibkg]->GetAcc(i,j));
+           y0 = fEntry[ip][itheta][iphi][ibkg-1]->GetEff(i,j);
+           y1 =   fEntry[ip][itheta][iphi][ibkg]->GetEff(i,j);
+           fCurrentEntry[ip][itheta][iphi]->SetEff(i,j, (y1 - y0) * x + y0);
          }
        }
       }
@@ -807,7 +776,7 @@ TF1* AliMUONFastTracking::GetFitP(Int_t ip,Int_t itheta,Int_t iphi) {
   // gets the correct prec-pgen distribution for a given LUT cell 
   if (!fFitp[ip][itheta][iphi]) {
     char name[256];
-    sprintf(name, "fit_%d_%d_%d", ip, itheta, iphi);
+    snprintf(name, 256, "fit_%d_%d_%d", ip, itheta, iphi);
     fFitp[ip][itheta][iphi] = new TF1(name ,FitP,-20.,20.,6);
     fFitp[ip][itheta][iphi]->SetNpx(500);    
     fFitp[ip][itheta][iphi]->SetParameters(0.,0.,0.,0.,0.,0.);