Unified SpaceCharge & GridLeak Calibration (winter 2013)

 Building on previous improvements to the calibration model (1,2) and introducing some new ones, here I describe the current model of calibration SpaceCharge & GridLeak.


gap : residual gap between padrows 13 & 14
sc : metric of SpaceCharge (as seen via signed DCAs to the primary vertex) representing the average charge density over the TPC volume <ρSC0>
L : luminosity
z : distance from the endcap
Dstatic : static, z-independent distortions
GLO : GridLeak luminosity dependence offset from zero
SO : SpaceCharge luminosity dependence offset from zero (possibly the same as GLO)
SC : SpaceCharge luminosity dependence coefficient
GL : SpaceCharge-to-GridLeak coefficient, ρGL0 = GL <ρSC0> (ρGL is assumed to be uniform in a thin sheet across the TPC)
DGL : distortion due to GridLeak, leading to non-zero gap values
CGL : correction applied for GridLeak (ideally the same as DGL when calibrated)
DSCGL : distortion due to SpaceCharge + GridLeak, leading to non-zero signed DCAs at the primary vertex
CSCGL : correction applied for SpaceCharge + GridLeak (ideally the same as DSCGL when calibrated)
g1 : conversion coefficient in GridLeak distortion
g2 : conversion coefficient in GridLeak correction
g3 : conversion coefficient of SpaceCharge into DSCGL
g4 : conversion coefficient of GridLeak into DSCGL
g5 : g3/g4
g3' : conversion coefficient of SpaceCharge into DSCGL in StMagUtilities::PredictSpaceChargeDistortion()
g4' : conversion coefficient of GridLeak into DSCGL in StMagUtilities::PredictSpaceChargeDistortion()
g5' = g3' / g4'
g3r = g3' / g3
g4r = g4' / g4
g5r = g5' / g5
*used : value of a parameter used when reconstructing data 

Formulas for GridLeak

When we look at data which has been corrected (and we have to, because the distortion is so large that looking at uncorrected data results in broken tracks due to the GridLeak, not allowing us to easily look at gap via the residuals), we have:

gap(z,L) = Dstatic + DGL - CGL
DGL = g1 z (L - GLO)
CGL = g2 z (L - SO) SC GL = g2 z sc GL

...and using sc as defined in the next section...

CGL = g2 z sc GL


Ideally, SO = GLO, and we can force this. But that ought to be determined. Anyhow...

gap(z,L) = Dstatic + g1 z (L - GLO) - g2 z scused GLused
gap(z,L) = Dstatic + z [g1 (L - GLO) - g2 scused GLused]

We define the slope and intercept in z as gapf and gapi respectively, and we can write the formula for gapf in a few ways:

gap(z,L) = gapi + z gapf
(i) Distortion minus correction gapf(L) = g1 (L - GLO) - g2 scused GLused
(ii) Collected coefficients gapf(L) = g2 [ (g1/g2) (L - GLO) - scused GLused ]
(iii) Linear in luminosity gapf(L) = [g2 SOused SCused GLused - g1 GLO] + L [g1 - g2 SCused GLused]

We disregard the intercept gapi = Dstatic, as it involves other possible distortions we don't wish to deal with here. And we will use the "Collected coefficients" form for the calibration.

Formulas for SpaceCharge:

Our formalism for SpaceCharge is as follows:

sc(L) = SC (L - SO)
sc(L) (g3 + g4 GL) = Dstatic + DSCGL   # Note that there is an assumption here of the luminosity offset (L - SO) applying for both SpaceCharge & GridLeak!
sc(L) = (Dstatic + DSCGL) / (g3 + g4 GL)
...but what we observe has distortion corrections applied, and we interpret the distortions (using StMagUtilities::PredictSpaceChargeDistortion(), assuming the GLused that we applied, and with some g3' and g4' that are built into the code, which we hope to be very close to their true counterparts g3 and g4)...
scobserved(L) = (Dstatic + DSCGL - CSCGL) / (g3' + g4' GLused)
DSCGL = g3 sc(L) + g4 GL sc(L) = sc(L) (g3 + g4 GL)
CSCGL = scused (g3 + g4 GLused)

We record (write out) the observed + used sc as our measurement:

scmeasured(L) = scobserved + scused

The scused term cancels with that from CSCGL only if g3' = g3 and g4' = g4 (i.e. g3r = g4r = 1). Otherwise we are left with:

scmeasured(L) = scused + [Dstatic + sc(L) (g3 + g4 GL) - scused (g3 + g4 GLused)] / (g3' + g4' GLused)
scmeasured(L) = scused + [Dstatic + SC (L - SO) (g3 + g4 GL) - scused (g3 + g4 GLused)] / (g3' + g4' GLused)

Let us modify SO to include the static distortions, as we do not have enough observables to separate these:
SO - { Dstatic / [ SC (g3 + g4 GL) ] } → SO   # This uses only fixed numbers (i.e. it doesn't depend on what we used)

scmeasured(L) = scused + [SC (L - SO) (g3 + g4 GL) - scused (g3 + g4 GLused)] / (g3' + g4' GLused)
scmeasured(L) = scused + [ SC (L - SO) (g5 + GL) - scused (g5 + GLused)] / [g4r (g5r g5 + GLused)]

This is the primary form we will use for the calibration. Only if g3r = g4r = g5r = 1 does this condense to:

scmeasured(L) = [ SC (L - SO) (g5 + GL) ] / (g5 + GLused)

Let us define an effective coefficient:
SCeffective = SC (g5 + GL)   # This uses only fixed numbers

scmeasured(L) = SCeffective (L - SOeffective) / (g5 + GLused)

This is a secondary form we will use in the calibration to help get approximate values in an initial fit, as it does not allow deviation from g3r = g4r = g5r = 1. To come full circule, for the sake of clarity, we could still define another effective coefficient:
SCeffective,2 = SCeffective / (g5 + GLused)   # Actually a function of GLused

scmeasured(L) = SCeffective,2 (L - SO)

This compares in form to our original formulation of sc = SC (L - SO). But we will not use this form.

A caveat

There is a simple scale dependence of all four coefficients g1-4 on the TPC wt through a variable which we have labeled in StMagUtilities as Const1. The dependence cancels in ratios, g1/g2, g3/g4 = g5, so the only place this constant appears is in the bare g2 in the GridLeak formula. Thus, it is slightly modified to make it correct:

gapf(L) = (Const1used / Const1reference) g2 [ (g1/g2) (L - GLO) - scused GLused ]

Fitting The Data

We do three fits. The first two fits are for SpaceCharge and GridLeak distortions separately to help obtain initial values in a third, unifying fit. These fits can be described as follows:



x = L
y = GLused


p0 = SO
p1 = SCeffective
p2 = g5


fSC(x,y) = p1 (x-p0) / (p2+y)





x = L
y = scused
w = Const1used


p0 = g2
p1 = g1/g2
p2 = GLO


fGL(x,y,w) = (w / Const1reference) p0 [ p1 (x-p2) - y) ]





x = L
y = scused
w = GLused


p0 = g2
p1 = g5
p2 = SC
p3 = SO
p4 = GL
p5 = GLO
p6 = g5r
p7 = g4r


fGL(x,y,w) = p0 [ p2 p4 (x-p5) + y w ]
fSC(y,w) = y + {[p2 (p1 + p4) (x-p3) - y (p1 + w)]/ [p7 (p6 p1+w)]}



This is coded into the calibration macro Calib_SC_GL.C.

Fitting both gapf and sc data simultaneously with in the Unified fit lets the fitter deliver errors on  our desired SC and GL parameters individually, though there exists significant correlations between several parameters. The calibration code allows to see these correlations via χ2 in the parameter phase space when running in debug mode.

Generally, for the Unified fit, we force p5 ≡ p3 (i.e. GLO ≡ SO), and p6 ≡ p7 ≡ 1 (i.e. g3r ≡ g4r ≡ g5r ≡ 1), but these conditions can be relaxed through control parameters in the code.