Alternative SpaceCharge calibration

Goal: a more robust SpaceCharge calibration


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
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
DSCGL : distortion due to SpaceCharge + GridLeak, leading to signed DCAs at the primary vertex
CSCGL : correction applied for SpaceCharge + GridLeak (ideally the same as DSCGL when calibrated)
g3 : conversion coefficient of SpaceCharge distortion into sc
g4 : conversion coefficient of GridLeak distortion into sc
g5 : g3/g4
*used : value of a parameter used when reconstructing data



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::PredictSpaceCharge()) assuming the GL that we applied...
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 the observed + used sc as our measurement:

scmeasured(L) = scobserved + scused

The scused term cancels with that from CSCGL, and we are left with:

scmeasured(L) = (Dstatic + DSCGL) / (g3 + g4 GLused)
scmeasured(L) = (Dstatic + sc(L) (g3 + g4 GL)) / (g3 + g4 GLused)
scmeasured(L) = (Dstatic + SC (L - SO) (g3 + g4 GL)) / (g3 + g4 GLused)

Let us define an effective offset:
SOeffective = SO - { Dstatic / [ SC (g3 + g4 GL) ] }   # This uses only fixed numbers (i.e. it doesn't depend on what we used)

scmeasured(L) = [ SC (L - SOeffective) (g3 + g4 GL) ] / (g3 + g4 GLused)
scmeasured(L) = [ SC (L - SOeffective) (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)

Let us define another effective coefficient:
SCeffective,2 = SCeffective / (g5 + GLused)   # Actually a function of GLused

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

This compares in form to our original formulation of sc = SC (L - SO).



The old approach: Fit scmeasured(L) for SCeffective,2 and fit abitrarily as a second order polynomial function of GLused (i.e. SCeffective,2 = A + B GLused + C GLused2). Determine (SC GL) as a constant (i.e. SC GL = D) from fits to gapf(L) and subsequently LeakS as a function of SCusedGLused. Then solve for either SC or GL from the two formulas (two equations and two unknowns). This involves taking roots of nonlinear functions, so the appropriate root must be guessed, and the condition of non-intersection of the two equations must be considered.

The new approach: The formulas above, really for scmeasured(L,GLused), allow us to define a 3 parameter function of 2 dimensions which can be used to fit all of the data at once without special considerations:


x = L
y = GLused


p0 = SOeffective
p1 = SCeffective
p2 = g5


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





Note 1: When GLused = GL (the true GridLeak parameter), we find as we expect that we are measuring the true SC parameter:
scmeasured(L) = SC (L - SOeffective)

Note 2: Observe that (g3) and (g4 GL) determine the relative contributions of SpaceCharge and GridLeak to the signed DCA distortions respectively, or one can compare g5 to GL. If g5 is large compared to GL, then GridLeak would have no bearing on this distortion. Likewise, if g5 is small, then GridLeak dominates this distortion. When we learned about the existence of GridLeak, we quickly learned that these contribiutions are comparable, so we expect g5 to be similar to GL.

Note 3: There should be no reason for g3 and g4 to change for different data. In other words, g5 should be the same constant for every calibration, and this will be worth checking.


Different Offsets:

Let's take one step back and ask, "What if SpaceCharge and GridLeak do really have different luminosity scaler offsets?" This can be written using GLO for the GridLeak offset to differentiate it from the one for SpaceCharge. We then have:

DSCGL = [ g3 SC (L - SO) ] + [ g4 GL SC (L - GLO) ]
scmeasured = { [ SC (g3 + g4 GL) ] L + [Dstatic - SC (g3 SO + g4 GLO GL)]} / (g3 + g4 GLused)

This time, we define:
SOeffective,2 = [ (g3 SO + g4 GLO GL) - (Dstatic / SC) ] / (g3 + g4 GL)   # This uses only fixed numbers

scmeasured(L) = SC (L - SOeffective,2) (g3 + g4 GL) / (g3 + g4 GLused)
scmeasured(L) = SC (L - SOeffective,2) (g5 + GL) / (g5 + GLused)
scmeasured(L) = SCeffective (L - SOeffective,2) / (g5 + GLused)
scmeasured(L) = SCeffective,2 (L - SOeffective,2)

But this is exactly the same functional form as before. When GLO = SO, we have SOeffective,2 = SOeffective. When Dstatic = 0 also, then SOeffective,2 = SOeffective = GLO. This would be a desirable outcome, but is perhaps a condition which should not be imposed.


Unifying Fit:

In principle, using the similar formulas for an alternative GridLeak calibration, one can fit the gapf and sc data simulatneously, such that 6 parameters can be fit: g2, g5, SC, SOeffective,2, GL, GLO. This can be done by substituting (SC GL) for (gGL/g2) [parameter p1 in fGL] and reverting back to SC (g5 + GL) instead of SCeffective [parameter p1 in fSC]. Because we have no way of differentiating the effects of Dstatic from that of SO, from here on we just use SO instead of SOeffective,2. One could make this a 5 parameter fit by further imposing that SO = GLO.


x = L
y = SCused
w = SOused
v = GLused


p0 = g2
p1 = g5
p2 = SC
p3 = SO
p4 = GL
p5 = GLO


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



Fitting both the gapf and sc data simultaneously with fGL and fSC this way lets the fitter deliver errors on SC and GL individually, rathern than having to do the math of determining where the separate constraints on SC and GL from fGL and fSC intersect, and propogating errors manually.

More on this in my next post.