[u/mrichter/AliRoot.git] / FASTSIM / AliFastMuonTriggerEff.cxx

/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

#include "AliFastMuonTriggerEff.h"
#include <TFile.h>
#include <TTree.h>
#include <TROOT.h>
#include <stdlib.h>
#include <Rtypes.h>

// Debugging flag
//#define MYTRIGDEBUG

ClassImp(AliFastMuonTriggerEff)

AliFastMuonTriggerEff::AliFastMuonTriggerEff():
    AliFastResponse("Efficiency", "Muon Trigger Efficiency")
{
//
// Default constructor
//
    SetCut(kLow);
    fZones=0;
}


void AliFastMuonTriggerEff::Init()
{
//
//  Initialization
//
    printf("Initializing %s / %s", fName.Data(), fTitle.Data());
//

    fPhiMin   = -90. ;
    fPhiMax   =  90. ;
    fDphi     =   9. ;
    fThetaMin =   2. ;
    fThetaMax =   9. ;
    fDtheta   =   0.7;
    fDpt      =   0.1;

    InitTree();
}

void AliFastMuonTriggerEff::InitTree()
{
//
//  Initialize tables from tree
//
    TTree          *chain;   // pointer to the analyzed TTree or TChain
    Int_t           nSim, nZona;
    Double_t        pmin, pmax, tmin, tmax, phimin, phimax, bkg;
    Double_t        len50, hen50, leff, heff;
    Double_t        vLPt[50];
    Double_t        vHPt[50];
    Char_t file[100]="$(ALICE_ROOT)/FASTSIM/data/vettorpara.root";
//
//  Avoid memory leak in case of reinitialization
    if(fZones!=0) {
        printf("\nWarning: reinitialization of an object of class: AliFastMuonTriggerEff\n");
        for (Int_t i=0; i<fZones; i++) {
            if(fEffLow [i])delete[] fEffLow[i];
	    if(fEffHigh[i])delete[] fEffHigh[i];
        }
	if(fEffLow) {
	    delete[] fEffLow;
	    fEffLow=0;
        }
	if(fEffHigh) {
	    delete[] fEffHigh;
	    fEffHigh=0;
        }
    }
    printf("AliFastMuonTriggerEff: Initialization\n");
    TFile *f = new TFile(file);
    if(f->IsZombie()) {
        printf("Cannot open file: %s\n",file);
        return;
    }
    f->ls();
    
    TTree* tree = (TTree*)gDirectory->Get("fitPar");

//
//
    chain = tree;
    chain->SetMakeClass(1);
    
    chain->SetBranchAddress("nSim",&nSim);
    chain->SetBranchAddress("nZona",&nZona);
    chain->SetBranchAddress("ptmin",&pmin);
    chain->SetBranchAddress("ptmax",&pmax);
    chain->SetBranchAddress("Thetamin",&tmin);
    chain->SetBranchAddress("Thetamax",&tmax);
    chain->SetBranchAddress("Phimin",&phimin);
    chain->SetBranchAddress("Phimax",&phimax);
    chain->SetBranchAddress("Bkg",&bkg);
    chain->SetBranchAddress("EffLPt",vLPt);
    chain->SetBranchAddress("EffHPt",vHPt);
    chain->SetBranchAddress("Pt0.5Low",&len50);
    chain->SetBranchAddress("Pt0.5High",&hen50);
    chain->SetBranchAddress("EffLowMax",&leff);
    chain->SetBranchAddress("EffHighMax",&heff);
// 
//
    Int_t nentries = Int_t(chain->GetEntries());
    Int_t nbytes = 0, nb = 0;

// Count the number of zones of the parametrization
    Int_t nzone0=0, nzone1=0;
    for (Int_t jentry=0; jentry<nentries; jentry++) {
	nb = chain->GetEntry(jentry);
	if(bkg==0.) {
	     if(nSim==0)nzone0++;
	     if(nSim==1)nzone1++;
	}
    }
    
    printf("Trigger parametrisation for %d zones for Pt: 0. 5. GeV/c\n",nzone0);
    printf("and %d zones extended to 10. GeV/c\n",nzone1);
    fZones=nzone0+nzone1;
//    printf("Ciao\n");
    if(fZones<=0){
        printf("Number of zones must be greater than 0\n");
	exit(6);
    }
    
    fEffLow =new Float_t*[fZones];
    fEffHigh=new Float_t*[fZones];
    for (Int_t i=0; i<fZones; i++) {
        fEffLow [i]=new Float_t[50];
	fEffHigh[i]=new Float_t[50];
    }
    
//  Initialize look-up table to standard values
    Int_t isim, itheta, iphi;
    for (isim=0; isim<2; isim++) {
        for (itheta=0; itheta<10; itheta++) {
	    for (iphi=0; iphi<20; iphi++) {
	        fLook[isim][itheta][iphi]=0;
            }
	}
    }

//  Loading Trigger efficiencies
    Int_t myzone=0;
#ifdef MYTRIGDEBUG
            printf("Filling nSim nZona pmin pmax tmin tmax phimin phimax: ....\n");
#endif
    for (Int_t jentry=0; jentry<nentries; jentry++) {
//	Int_t ientry = LoadTree(jentry); 
	nb = chain->GetEntry(jentry);   
	nbytes += nb;
#ifdef MYTRIGDEBUG
       printf("Getting entry %d... ",jentry);
#endif
// For the time being it works with background 0
	if ((nSim == 0 || nSim == 1)&&bkg==0.) {
#ifdef MYTRIGDEBUG
            printf("Filling %d %d %6.2f %6.2f %6.2f %6.2f %6.2f %6.2f: ",
	    nSim,nZona,pmin,pmax,tmin,tmax,phimin,phimax);
#endif
	    for (Int_t k = 0; k < 50; k++) {
		fEffLow [myzone][k] = vLPt[k];
		fEffHigh[myzone][k] = vHPt[k];
#ifdef MYTRIGDEBUG
		if(k<15)printf(" %5.3f",vLPt[k]);
#endif
	    }
#ifdef MYTRIGDEBUG
            printf("\n");
#endif
	    myzone++;
	    iphi=Int_t(nZona/10)-10;
	    itheta=nZona%10;
	    if(iphi<0||iphi>19||itheta<0||itheta>9) {
	        printf("The format of data file is not consistent\nwith this version of the code\n");
	        printf("This should never happen: iphi %d, itheta: %d\n",iphi,itheta);
		exit(7);
	    }
	    fLook[nSim][itheta][iphi]=myzone;
	} else {
	    printf("Skipping entry with nSim=%d, bkg=%f\n",nSim,bkg);
	}
    }
#ifdef MYTRIGDEBUG
    printf("This is the content of the LUT after first step of initialization\n");
    for(isim=0; isim<2; isim++) {
        printf("isim=%d\n",isim);
        for(iphi=0; iphi<20; iphi++) {
	    printf("iphi: %2d:",iphi);
	    for(itheta=0; itheta<10; itheta++) {
	        printf(" %4d",fLook[isim][itheta][iphi]);
            }
	    printf("\n");
	}
    }
#endif
// Filling look=up table for the zones where the extended simulation does
// not exists
    for(iphi=0; iphi<20; iphi++) {
    	for(itheta=0; itheta<10; itheta++) {
	    if(fLook[0][itheta][iphi]==0) {
	        printf("Missing entry isim=%d itheta=%d iphi=%d\n",isim,itheta,iphi);
		exit(8);
	    }
	    if(fLook[0][itheta][iphi]<0||fLook[0][itheta][iphi]>fZones) {
	        printf("Problem with entry isim=%d itheta=%d iphi=%d\n",isim,itheta,iphi);
		exit(9);
	    }
	    if(fLook[1][itheta][iphi]==0) {
                 fLook[1][itheta][iphi]=-fLook[0][itheta][iphi];
	    }
	}
    }
#ifdef MYTRIGDEBUG
    for(isim=0; isim<2; isim++) {
        printf("isim=%d\n",isim);
        for(iphi=0; iphi<20; iphi++) {
	    printf("iphi: %2d:",iphi);
	    for(itheta=0; itheta<10; itheta++) {
	        printf(" %4d",fLook[isim][itheta][iphi]);
            }
	    printf("\n");
	}
    }
        for(iphi=0; iphi<20; iphi++) {
	    for(itheta=0; itheta<10; itheta++) {
    for(isim=0; isim<2; isim++) {
	        printf("%d %2d %2d %4d:",isim,iphi,itheta,fLook[isim][itheta][iphi]);
		if(fLook[isim][itheta][iphi]>0) {
		    myzone=fLook[isim][itheta][iphi]-1;
		    for(Int_t ipt=0; ipt<20; ipt++) {
		        //printf(" %5.3f",fEffLow[myzone][ipt]);
			printf(" %5.3f",fEffHigh[myzone][ipt]);
		    }
		    printf(" ...");
		    for(Int_t ipt=40; ipt<50; ipt++) {
		        //printf(" %5.3f",fEffLow[myzone][ipt]);
			printf(" %5.3f",fEffHigh[myzone][ipt]);
		    }		    
		}
		printf("\n");
            }
	}
    }    
#endif
    f->Close();
}

void AliFastMuonTriggerEff::Evaluate(Float_t charge, Float_t pt,
                Float_t theta, Float_t phi,Float_t& effLow, Float_t& effHigh,
		Float_t& /*eff*/)
{
//
//  Trigger efficiency for pt, theta, phi (low and high cut)
//
    effLow=0.;
    effHigh=0.;
    if(fZones==0) {
        printf("Call to uninitialized object of class: AliFastMuonTriggerEff\n");
	return;
    }
    if(pt<0) {
        printf("Warning: pt: %f < 0. GeV/c\n",pt);
	return;	
    }
    Int_t iPt   = Int_t(pt/fDpt)%50;
    Int_t iSim  = Int_t(pt/fDpt)/50;
    Int_t iPhi  = Int_t((phi-fPhiMin)/fDphi);
    if(phi<fPhiMin)iPhi=iPhi-1;
    Int_t iTheta = Int_t((theta-fThetaMin)/fDtheta);
#ifdef MYTRIGDEBUG
    printf("iSim iPt iTheta iPhi: %d %d %d %d\n",iSim,iPt,iTheta,iPhi);
#endif
    iPhi=iPhi-40*(iPhi/40);
#ifdef MYTRIGDEBUG
    printf("1: iPhi converted to: %d for angle equivalence\n",iPhi);
#endif
    if(iPhi<0)iPhi=-iPhi-1;
    if(iPhi>19)iPhi=39-iPhi;
#ifdef MYTRIGDEBUG
    printf("2: iPhi converted to: %d for the symmetry of the spectrometer\n",iPhi);
#endif
    if(charge==1.){
    } else if(charge==-1.) {
    iPhi=19-iPhi;
#ifdef MYTRIGDEBUG
    printf("3: iPhi converted to: %d for charge symmetry\n",iPhi);
#endif
    } else {
        printf("Warning: not understand charge: %f\n",charge);
        return;
    }
    if(iTheta<0||iTheta>9) {
        printf("Warning: theta: %f outside acceptance\n",theta);
        return;
    }
    if(iPt<0) {
        printf("Warning: what do you mean with pt: %f <0?\n",pt);
	return;
    }
    if(iSim>=fSim) {
        iSim=fSim-1;
	iPt=49;
#ifdef MYTRIGDEBUG
    printf("4: iSim iPt converted to: %d %d (last zone)\n",iSim,iPt);
#endif
    }
    Int_t iLook=fLook[iSim][iTheta][iPhi];
    if(iLook<0) {
#ifdef MYTRIGDEBUG
    printf("5: iLook iPt: %d %d converted to: ",iLook,iPt);
#endif
        iLook=-iLook-1;
	iPt=49;
#ifdef MYTRIGDEBUG
    printf("%d %d from look up table contents\n",iLook,iPt);
#endif
    } else {
        iLook=iLook-1;
    }
    effLow=fEffLow[iLook][iPt];
    effHigh=fEffHigh[iLook][iPt];
#ifdef MYTRIGDEBUG
    printf("6: charge, iSim, iTheta, iPhi, iPt: %f %d %d %d %d effLow: %f, effHigh: %f\n",
               charge,iSim,iTheta,iPhi,iPt,effLow,effHigh);
#endif
    
    //fEffLow [iPhi][iTheta][iPt];
    //fEffHigh[iPhi][iTheta][iPt];    
}

Float_t AliFastMuonTriggerEff::Evaluate(Float_t charge, Float_t pt,
                   Float_t theta, Float_t phi)
{
    //
    // Trigger efficiency for pt, theta, phi depending of fCut
    // 
    if(fZones==0) {
        printf("Call to uninitialized object of class: AliFastMuonTriggerEff\n");
	return 0.;
    }
    Float_t eff;
    Float_t effLow, effHigh;
    
    Evaluate(charge,pt,theta,phi,effLow,effHigh);
    if (fCut == kLow) 
	eff  = effLow;
    else
	eff  = effHigh;

    return eff;
}
Commit	Line	Data
6255180c	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
803d1ab0	16	/* $Id$ */
6255180c	17
	18	#include "AliFastMuonTriggerEff.h"
	19	#include <TFile.h>
	20	#include <TTree.h>
	21	#include <TROOT.h>
	22	#include <stdlib.h>
4476e71e	23	#include <Rtypes.h>
6255180c	24
	25	// Debugging flag
	26	//#define MYTRIGDEBUG
	27
925e6570	28	ClassImp(AliFastMuonTriggerEff)
6255180c	29
	30	AliFastMuonTriggerEff::AliFastMuonTriggerEff():
	31	AliFastResponse("Efficiency", "Muon Trigger Efficiency")
	32	{
	33	//
	34	// Default constructor
	35	//
	36	SetCut(kLow);
	37	fZones=0;
	38	}
	39
	40
	41	void AliFastMuonTriggerEff::Init()
	42	{
	43	//
	44	// Initialization
	45	//
	46	printf("Initializing %s / %s", fName.Data(), fTitle.Data());
	47	//
	48
	49	fPhiMin = -90. ;
	50	fPhiMax = 90. ;
	51	fDphi = 9. ;
	52	fThetaMin = 2. ;
	53	fThetaMax = 9. ;
	54	fDtheta = 0.7;
	55	fDpt = 0.1;
	56
	57	InitTree();
	58	}
	59
	60	void AliFastMuonTriggerEff::InitTree()
	61	{
	62	//
	63	// Initialize tables from tree
	64	//
	65	TTree *chain; // pointer to the analyzed TTree or TChain
	66	Int_t nSim, nZona;
	67	Double_t pmin, pmax, tmin, tmax, phimin, phimax, bkg;
	68	Double_t len50, hen50, leff, heff;
	69	Double_t vLPt[50];
	70	Double_t vHPt[50];
5566e139	71	Char_t file[100]="$(ALICE_ROOT)/FASTSIM/data/vettorpara.root";
6255180c	72	//
	73	// Avoid memory leak in case of reinitialization
	74	if(fZones!=0) {
	75	printf("\nWarning: reinitialization of an object of class: AliFastMuonTriggerEff\n");
	76	for (Int_t i=0; i<fZones; i++) {
	77	if(fEffLow [i])delete[] fEffLow[i];
	78	if(fEffHigh[i])delete[] fEffHigh[i];
	79	}
	80	if(fEffLow) {
	81	delete[] fEffLow;
	82	fEffLow=0;
	83	}
	84	if(fEffHigh) {
	85	delete[] fEffHigh;
	86	fEffHigh=0;
	87	}
	88	}
	89	printf("AliFastMuonTriggerEff: Initialization\n");
	90	TFile *f = new TFile(file);
	91	if(f->IsZombie()) {
	92	printf("Cannot open file: %s\n",file);
	93	return;
	94	}
	95	f->ls();
	96
	97	TTree* tree = (TTree*)gDirectory->Get("fitPar");
	98
	99	//
	100	//
	101	chain = tree;
	102	chain->SetMakeClass(1);
	103
	104	chain->SetBranchAddress("nSim",&nSim);
	105	chain->SetBranchAddress("nZona",&nZona);
	106	chain->SetBranchAddress("ptmin",&pmin);
	107	chain->SetBranchAddress("ptmax",&pmax);
	108	chain->SetBranchAddress("Thetamin",&tmin);
	109	chain->SetBranchAddress("Thetamax",&tmax);
	110	chain->SetBranchAddress("Phimin",&phimin);
	111	chain->SetBranchAddress("Phimax",&phimax);
	112	chain->SetBranchAddress("Bkg",&bkg);
	113	chain->SetBranchAddress("EffLPt",vLPt);
	114	chain->SetBranchAddress("EffHPt",vHPt);
	115	chain->SetBranchAddress("Pt0.5Low",&len50);
	116	chain->SetBranchAddress("Pt0.5High",&hen50);
	117	chain->SetBranchAddress("EffLowMax",&leff);
	118	chain->SetBranchAddress("EffHighMax",&heff);
	119	//
	120	//
	121	Int_t nentries = Int_t(chain->GetEntries());
	122	Int_t nbytes = 0, nb = 0;
	123
	124	// Count the number of zones of the parametrization
	125	Int_t nzone0=0, nzone1=0;
	126	for (Int_t jentry=0; jentry<nentries; jentry++) {
	127	nb = chain->GetEntry(jentry);
	128	if(bkg==0.) {
	129	if(nSim==0)nzone0++;
	130	if(nSim==1)nzone1++;
	131	}
	132	}
	133
	134	printf("Trigger parametrisation for %d zones for Pt: 0. 5. GeV/c\n",nzone0);
	135	printf("and %d zones extended to 10. GeV/c\n",nzone1);
136	fZones=nzone0+nzone1;
137	// printf("Ciao\n");
138	if(fZones<=0){
139	printf("Number of zones must be greater than 0\n");
140	exit(6);
141	}
142
143	fEffLow =new Float_t*[fZones];
144	fEffHigh=new Float_t*[fZones];
145	for (Int_t i=0; i<fZones; i++) {
146	fEffLow [i]=new Float_t[50];
147	fEffHigh[i]=new Float_t[50];
148	}
149
150	// Initialize look-up table to standard values
151	Int_t isim, itheta, iphi;
152	for (isim=0; isim<2; isim++) {
153	for (itheta=0; itheta<10; itheta++) {
154	for (iphi=0; iphi<20; iphi++) {
155	fLook[isim][itheta][iphi]=0;
156	}
157	}
158	}
159
160	// Loading Trigger efficiencies
161	Int_t myzone=0;
162	#ifdef MYTRIGDEBUG
163	printf("Filling nSim nZona pmin pmax tmin tmax phimin phimax: ....\n");
164	#endif
165	for (Int_t jentry=0; jentry<nentries; jentry++) {
166	// Int_t ientry = LoadTree(jentry);
167	nb = chain->GetEntry(jentry);
168	nbytes += nb;
169	#ifdef MYTRIGDEBUG
170	printf("Getting entry %d... ",jentry);
171	#endif
172	// For the time being it works with background 0
173	if ((nSim == 0 \|\| nSim == 1)&&bkg==0.) {
174	#ifdef MYTRIGDEBUG
175	printf("Filling %d %d %6.2f %6.2f %6.2f %6.2f %6.2f %6.2f: ",
176	nSim,nZona,pmin,pmax,tmin,tmax,phimin,phimax);
177	#endif
178	for (Int_t k = 0; k < 50; k++) {
179	fEffLow [myzone][k] = vLPt[k];
180	fEffHigh[myzone][k] = vHPt[k];
181	#ifdef MYTRIGDEBUG
182	if(k<15)printf(" %5.3f",vLPt[k]);
183	#endif
184	}
185	#ifdef MYTRIGDEBUG
186	printf("\n");
187	#endif
188	myzone++;
189	iphi=Int_t(nZona/10)-10;
190	itheta=nZona%10;
191	if(iphi<0\|\|iphi>19\|\|itheta<0\|\|itheta>9) {
192	printf("The format of data file is not consistent\nwith this version of the code\n");
193	printf("This should never happen: iphi %d, itheta: %d\n",iphi,itheta);
194	exit(7);
195	}
196	fLook[nSim][itheta][iphi]=myzone;
197	} else {
198	printf("Skipping entry with nSim=%d, bkg=%f\n",nSim,bkg);
199	}
200	}
201	#ifdef MYTRIGDEBUG
202	printf("This is the content of the LUT after first step of initialization\n");
203	for(isim=0; isim<2; isim++) {
204	printf("isim=%d\n",isim);
205	for(iphi=0; iphi<20; iphi++) {
206	printf("iphi: %2d:",iphi);
207	for(itheta=0; itheta<10; itheta++) {
208	printf(" %4d",fLook[isim][itheta][iphi]);
209	}
210	printf("\n");
211	}
212	}
213	#endif
214	// Filling look=up table for the zones where the extended simulation does
215	// not exists
216	for(iphi=0; iphi<20; iphi++) {
217	for(itheta=0; itheta<10; itheta++) {
218	if(fLook[0][itheta][iphi]==0) {
219	printf("Missing entry isim=%d itheta=%d iphi=%d\n",isim,itheta,iphi);
220	exit(8);
221	}
222	if(fLook[0][itheta][iphi]<0\|\|fLook[0][itheta][iphi]>fZones) {
223	printf("Problem with entry isim=%d itheta=%d iphi=%d\n",isim,itheta,iphi);
224	exit(9);
225	}
226	if(fLook[1][itheta][iphi]==0) {
227	fLook[1][itheta][iphi]=-fLook[0][itheta][iphi];
228	}
229	}
230	}
231	#ifdef MYTRIGDEBUG
232	for(isim=0; isim<2; isim++) {
233	printf("isim=%d\n",isim);
234	for(iphi=0; iphi<20; iphi++) {
235	printf("iphi: %2d:",iphi);
236	for(itheta=0; itheta<10; itheta++) {
237	printf(" %4d",fLook[isim][itheta][iphi]);
238	}
239	printf("\n");
240	}
241	}
242	for(iphi=0; iphi<20; iphi++) {
243	for(itheta=0; itheta<10; itheta++) {
244	for(isim=0; isim<2; isim++) {
245	printf("%d %2d %2d %4d:",isim,iphi,itheta,fLook[isim][itheta][iphi]);
246	if(fLook[isim][itheta][iphi]>0) {
247	myzone=fLook[isim][itheta][iphi]-1;
248	for(Int_t ipt=0; ipt<20; ipt++) {
249	//printf(" %5.3f",fEffLow[myzone][ipt]);
250	printf(" %5.3f",fEffHigh[myzone][ipt]);
251	}
252	printf(" ...");
253	for(Int_t ipt=40; ipt<50; ipt++) {
254	//printf(" %5.3f",fEffLow[myzone][ipt]);
255	printf(" %5.3f",fEffHigh[myzone][ipt]);
256	}
257	}
258	printf("\n");
259	}
260	}
261	}
262	#endif
263	f->Close();
264	}
265
266	void AliFastMuonTriggerEff::Evaluate(Float_t charge, Float_t pt,
88445b6c	267	Float_t theta, Float_t phi,Float_t& effLow, Float_t& effHigh,
88445b6c	268	Float_t& /eff/)
6255180c	269	{
	270	//
	271	// Trigger efficiency for pt, theta, phi (low and high cut)
	272	//
	273	effLow=0.;
	274	effHigh=0.;
	275	if(fZones==0) {
	276	printf("Call to uninitialized object of class: AliFastMuonTriggerEff\n");
	277	return;
	278	}
	279	if(pt<0) {
	280	printf("Warning: pt: %f < 0. GeV/c\n",pt);
	281	return;
	282	}
	283	Int_t iPt = Int_t(pt/fDpt)%50;
	284	Int_t iSim = Int_t(pt/fDpt)/50;
	285	Int_t iPhi = Int_t((phi-fPhiMin)/fDphi);
	286	if(phi<fPhiMin)iPhi=iPhi-1;
	287	Int_t iTheta = Int_t((theta-fThetaMin)/fDtheta);
	288	#ifdef MYTRIGDEBUG
	289	printf("iSim iPt iTheta iPhi: %d %d %d %d\n",iSim,iPt,iTheta,iPhi);
	290	#endif
	291	iPhi=iPhi-40*(iPhi/40);
	292	#ifdef MYTRIGDEBUG
	293	printf("1: iPhi converted to: %d for angle equivalence\n",iPhi);
	294	#endif
	295	if(iPhi<0)iPhi=-iPhi-1;
	296	if(iPhi>19)iPhi=39-iPhi;
	297	#ifdef MYTRIGDEBUG
	298	printf("2: iPhi converted to: %d for the symmetry of the spectrometer\n",iPhi);
	299	#endif
	300	if(charge==1.){
	301	} else if(charge==-1.) {
	302	iPhi=19-iPhi;
	303	#ifdef MYTRIGDEBUG
	304	printf("3: iPhi converted to: %d for charge symmetry\n",iPhi);
	305	#endif
	306	} else {
	307	printf("Warning: not understand charge: %f\n",charge);
	308	return;
	309	}
	310	if(iTheta<0\|\|iTheta>9) {
	311	printf("Warning: theta: %f outside acceptance\n",theta);
	312	return;
	313	}
	314	if(iPt<0) {
	315	printf("Warning: what do you mean with pt: %f <0?\n",pt);
	316	return;
	317	}
	318	if(iSim>=fSim) {
	319	iSim=fSim-1;
	320	iPt=49;
	321	#ifdef MYTRIGDEBUG
	322	printf("4: iSim iPt converted to: %d %d (last zone)\n",iSim,iPt);
	323	#endif
	324	}
	325	Int_t iLook=fLook[iSim][iTheta][iPhi];
	326	if(iLook<0) {
	327	#ifdef MYTRIGDEBUG
	328	printf("5: iLook iPt: %d %d converted to: ",iLook,iPt);
	329	#endif
	330	iLook=-iLook-1;
	331	iPt=49;
	332	#ifdef MYTRIGDEBUG
333	printf("%d %d from look up table contents\n",iLook,iPt);
334	#endif
335	} else {
336	iLook=iLook-1;
337	}
338	effLow=fEffLow[iLook][iPt];
339	effHigh=fEffHigh[iLook][iPt];
340	#ifdef MYTRIGDEBUG
341	printf("6: charge, iSim, iTheta, iPhi, iPt: %f %d %d %d %d effLow: %f, effHigh: %f\n",
342	charge,iSim,iTheta,iPhi,iPt,effLow,effHigh);
343	#endif
344
345	//fEffLow [iPhi][iTheta][iPt];
346	//fEffHigh[iPhi][iTheta][iPt];
347	}
348
349	Float_t AliFastMuonTriggerEff::Evaluate(Float_t charge, Float_t pt,
350	Float_t theta, Float_t phi)
351	{
352	//
353	// Trigger efficiency for pt, theta, phi depending of fCut
354	//
355	if(fZones==0) {
356	printf("Call to uninitialized object of class: AliFastMuonTriggerEff\n");
357	return 0.;
358	}
359	Float_t eff;
360	Float_t effLow, effHigh;
361
362	Evaluate(charge,pt,theta,phi,effLow,effHigh);
363	if (fCut == kLow)
364	eff = effLow;
365	else
366	eff = effHigh;
367
368	return eff;
369	}