Incorporating Efficiency into Physics Functions
Last Update: 01-Dec-05
Index
- Base PDF - without efficiency
- Efficiency vs x(meas)
- Efficiency vs x(true)
- Efficiency in Zero-Lifetime Sources
- Implementation in Code
- the Efficiency Class
Base PDF without Efficiency
PDF depends on:
- xm,t: vectors of measured,true observables
- p: vector of parameters
Without Efficiency correction
PDF(xm;p) =
∑a fa
Fa(xm;p)
Source-by-source physics function
Fa(xm;p) =
∫ dK H(K)
∫ dxt R(xt-xm;σ)
P(xt;K,p)
where P is the function describing the exponential decay
or oscillation.
Efficiency vs. x(meas)
Define:
ε(xm) =
Nisel /
Nigen
where Ni = number of events in the bin containing
xm.
Gives new PDF:
PDF(xm;p) =
∑a fa
Fa(xm;p)
ε(xm) Aa(p)
=
∑a fa
F'a(xm;p)
where Aa is a normalization factor, defined such
that the integral of the PDF is one, which will
depend on the values of the physics function parameters.
Aa must be re-calculated every time the new physics function,
F'a is evaluated, because the parameters might have
changed. This will involve another loop over the physics functions and
will slow things down terribly.
Efficiency vs. x(true)
Define:
ε(xt) =
Nisel /
Nigen
where Ni = number of events in the bin containing
xt.
Gives new PDF:
PDF(xm;p) =
∑a fa
F'a(xm;p)
where now
F'a(xm;p) =
∫ dK H(K)
∫ dxt
R(xt-xm;σ)
Pa(xt;K,p)
εa(xt)
Aa(p)
This has the possible benefit of being able to evaluate
Aa analytically if a simple functional form can be
found for ε(xt) since A is set by the
condition:
Aa(p)
= 1 / ∫ dxt
Pa(xt;K,p)
εa(xt)
However, this integral has to be coded explicitly for every
permutation of physics function, efficiency function and physics
function variable which would make the code terrible to maintain.
Efficiency in Zero-Lifetime Sources
x(true)
-
Fcc(xm;p)
= A ∫ dxt
ε(xt)
R(xm-xt;σ)
P(xt;p)
-
but, xt = 0
==> P(xt;p)
= δ(xt)
==> Fcc = A
ε(0)
R(xm;σ)
-
∫ dxm Fcc(xm)
= 1 ==> A = 1/ε(0)
-
Fcc(xm;p)
= R(xm;σ)
x(meas)
Here there is no nice expression for the physics function, so:
F'cc(xm;p)
= R(xm;σ)
&epsilon(xm)
A(p)
and A has to be recalculated every time F' is evaluated.
Implementation in Code - the Efficiency Class
General
Use eff vs. x(true) as a start.
Multiplies pdf in PDFEvt.
Functions
- Value( x ):
returns eff at Lt = x
x = var_phy[phys_ind_x]
- Norm( PhysFunc, var_phy, pars ):
returns normalization factor w/ eff included
requires loop over var[phys_ind_x]
Class Members
- pointer to eff function
- array of param's for eff function
(stored in big parameter list?)
- Integration var's: xlo, xhi, Nbins, bin width
Constructor Parameters
- type of efficiency function (integer)
- number of params
- list of param indices in big list
(the param values will get copied to a local array)
- integration parameters