def print_fit(self,par,outfile):
"""print the energy and amplitude results from a fit"""
fit = self.results
name = self.name
p = fit.p
self.chi2_cal()
self.chi2_aug_part()
self.Q = conf_int(self.chi2/2, par.ncon, self.dof/2)
dE = exp(p['log('+name+':dE)'])
E = [sum(dE[:i+1]) for i in range(self.nexp)]
a = exp(p['log('+name+':a)'])
if self.name != 'pimom0':
dEo = exp(p['log('+name+':dEo)'])
Eo = [sum(dEo[:i+1]) for i in range(self.nexp)]
ao = exp(p['log('+name+':ao)'])
ofile = open(outfile,'a')
if self.dof > 0:
chi2dof = self.chi2/self.dof
else:
chi2dof = 99.9
if chi2dof > 99:
chi2dof = 99.9
form = "{:s} & {:2d} - {:2d} & {:d}+{:d} & {:4.1f} & {:3d} & {:4.2f} "
ena = "& {:<11s} & {:<11s} "
ofile.write( form.format( self.name,self.tmin,self.tmax,self.nexp,self.noxp,chi2dof,self.dof,self.Q ) )
for i in range(self.nexp):
ofile.write( ena.format(E[i].fmt(ndecimal=4),a[i].fmt(ndecimal=4),Eo[i].fmt(ndecimal=4),ao[i].fmt(ndecimal=4)) )
ofile.write(" \\\\ \n")
def test_make_prior(self):
" EigenBasis.make_prior "
tdata = np.arange(4.)
datafmt = 'G.{s1}.{s2}'
srcs = 'ab'
G = self.make_G(tdata=tdata, keyfmt=datafmt, srcs=srcs)
basis = EigenBasis(
data=G, keyfmt=datafmt, srcs=srcs, t=(1,2),
)
nterm = 4
ampl = '1.0(2)', '0.03(20)', '0.2(2.0)'
dEfac = '1(1)'
one, small, big = ampl
# case 1 - canonical
prior = basis.make_prior(
nterm=nterm, keyfmt='a.{s1}', ampl=ampl, dEfac=dEfac, eig_srcs=True
)
dE = gv.gvar(nterm * [dEfac]) * (self.E[1] - self.E[0])
dE[0] += self.E[0] - dE[0].mean
self.assert_gvclose(gv.exp(prior['log(a.dE)']), dE)
a0 = gv.gvar(nterm * [big])
a0[0] = gv.gvar(one)
a0[1] = gv.gvar(small)
self.assert_gvclose(prior['a.0'], a0)
a1 = gv.gvar(nterm * [big])
a1[0] = gv.gvar(small)
a1[1] = gv.gvar(one)
self.assert_gvclose(prior['a.1'], a1)
# default values
ampl = '1.0(3)', '0.03(10)', '0.2(1.0)'
dEfac = '1(1)'
one, small, big = ampl
# case 2 - omit state
prior = basis.make_prior(nterm=nterm, keyfmt='a.{s1}', states=[0], eig_srcs=True)
a0 = gv.gvar(nterm * [big])
a0[0] = gv.gvar(one)
self.assert_gvclose(prior['a.0'], a0)
a1 = gv.gvar(nterm * [big])
self.assert_gvclose(prior['a.1'], a1)
# case 3 - swap states
prior = basis.make_prior(nterm=nterm, keyfmt='a.{s1}', states=[1, 0], eig_srcs=True)
dE = gv.gvar(nterm * ['1(1)']) * (self.E[1] - self.E[0])
dE[0] += self.E[0] - dE[0].mean
self.assert_gvclose(gv.exp(prior['log(a.dE)']), dE)
a1 = gv.gvar(nterm * [big])
a1[0] = gv.gvar(one)
a1[1] = gv.gvar(small)
self.assert_gvclose(prior['a.1'], a1)
a0 = gv.gvar(nterm * [big])
a0[0] = gv.gvar(small)
a0[1] = gv.gvar(one)
self.assert_gvclose(prior['a.0'], a0)
def test_make_prior(self):
" EigenBasis.make_prior "
tdata = np.arange(4.0)
datafmt = "G.{s1}.{s2}"
srcs = "ab"
G = self.make_G(tdata=tdata, keyfmt=datafmt, srcs=srcs)
basis = EigenBasis(data=G, keyfmt=datafmt, srcs=srcs, t=(1, 2))
nterm = 4
ampl = "1.0(2)", "0.03(20)", "0.2(2.0)"
dEfac = "1(1)"
one, small, big = ampl
# case 1 - canonical
prior = basis.make_prior(nterm=nterm, keyfmt="a.{s1}", ampl=ampl, dEfac=dEfac, eig_srcs=True)
dE = gv.gvar(nterm * [dEfac]) * (self.E[1] - self.E[0])
dE[0] += self.E[0] - dE[0].mean
self.assert_gvclose(gv.exp(prior["log(a.dE)"]), dE)
a0 = gv.gvar(nterm * [big])
a0[0] = gv.gvar(one)
a0[1] = gv.gvar(small)
self.assert_gvclose(prior["a.0"], a0)
a1 = gv.gvar(nterm * [big])
a1[0] = gv.gvar(small)
a1[1] = gv.gvar(one)
self.assert_gvclose(prior["a.1"], a1)
# default values
ampl = "1.0(3)", "0.03(10)", "0.2(1.0)"
dEfac = "1(1)"
one, small, big = ampl
# case 2 - omit state
prior = basis.make_prior(nterm=nterm, keyfmt="a.{s1}", states=[0], eig_srcs=True)
a0 = gv.gvar(nterm * [big])
a0[0] = gv.gvar(one)
self.assert_gvclose(prior["a.0"], a0)
a1 = gv.gvar(nterm * [big])
self.assert_gvclose(prior["a.1"], a1)
# case 3 - swap states
prior = basis.make_prior(nterm=nterm, keyfmt="a.{s1}", states=[1, 0], eig_srcs=True)
dE = gv.gvar(nterm * ["1(1)"]) * (self.E[1] - self.E[0])
dE[0] += self.E[0] - dE[0].mean
self.assert_gvclose(gv.exp(prior["log(a.dE)"]), dE)
a1 = gv.gvar(nterm * [big])
a1[0] = gv.gvar(one)
a1[1] = gv.gvar(small)
self.assert_gvclose(prior["a.1"], a1)
a0 = gv.gvar(nterm * [big])
a0[0] = gv.gvar(small)
a0[1] = gv.gvar(one)
self.assert_gvclose(prior["a.0"], a0)
def fcn_all_twostate(x, p):
ans = {}
Zg1 = p["Zg1"]
Zg2 = p["Zg2"]
Mg1 = p["Mg1"]
Mg2 = p["Mg2"]
corr_gg_1 = gv.exp(-Mg1 * x["tg"]) + gv.exp(-Mg1 * (NT - x["tg"]))
corr_gg_2 = gv.exp(-Mg2 * x["tg"]) + gv.exp(-Mg2 * (NT - x["tg"]))
ans["GG"] = Zg1 * corr_gg_1 + Zg2 * corr_gg_2
return ans
def print_prior(self,par,outfile):
"""print the priors and result for comparison"""
fit = self.results
p = self.prior
name = self.name
f = fit.p
dE = exp(f['log('+name+':dE)'])
E = [sum(dE[:i+1]) for i in range(self.nexp)]
a = exp(f['log('+name+':a)'])
if self.name != 'pimom0':
dEo = exp(f['log('+name+':dEo)'])
Eo = [sum(dEo[:i+1]) for i in range(self.nexp)]
ao = exp(f['log('+name+':ao)'])
pdE = exp(p['log('+name+':dE)'])
pa = exp(p['log('+name+':a)'])
if self.name != 'pimom0':
pdEo = exp(p['log('+name+':dEo)'])
pao = exp(p['log('+name+':ao)'])
ofile = open(outfile,'a')
ofile.write("{:s} & Prior & Value & & Prior & Value \\\\ # {:d}-{:d} {:d}+{:d} \n".format(
name,self.tmin,self.tmax,self.nexp,self.nexp))
form = "$a_{:d}$ & {:<11s} & {:<11s} & $dE_{:d}$ & {:<11s} & {:<11s} \\\\ \n"
for state in range(self.nexp):
ofile.write( form.format( state,pa[state].fmt(),a[state].fmt(),
state,pdE[state].fmt(),dE[state].fmt() ) )
if self.name != 'pimom0':
form = "$a'_{:d}$ & {:<11s} & {:<11s} & $dE'_{:d}$ & {:<11s} & {:<11s} \\\\ \n"
for state in range(self.nexp):
ofile.write( form.format( state,pao[state].fmt(),ao[state].fmt(),
state,pdEo[state].fmt(),dEo[state].fmt() ) )
def print_2pt_prior(self,par,ofile,name):
fit = self.results
p = self.prior
f = fit.p
dE = exp(f['log('+name+':dE)'])
E = [sum(dE[:i+1]) for i in range(self.nexp)]
a = exp(f['log('+name+':a)'])
if self.name != 'pimom0':
dEo = exp(f['log('+name+':dEo)'])
Eo = [sum(dEo[:i+1]) for i in range(self.nexp)]
ao = exp(f['log('+name+':ao)'])
pdE = exp(p['log('+name+':dE)'])
pa = exp(p['log('+name+':a)'])
if self.name != 'pimom0':
pdEo = exp(p['log('+name+':dEo)'])
pao = exp(p['log('+name+':ao)'])
ofile.write("{:5s} \n".format(name))
form = "{:<12s} {:<12s} "
self.prior_line(ofile,"odd prior",form,self.nexp,pa,pdE)
self.prior_line(ofile,"odd fittd",form,self.nexp,a,dE)
if self.name != 'pimom0':
self.prior_line(ofile,"evn prior",form,self.nexp,pao,pdEo)
self.prior_line(ofile,"evn fittd",form,self.nexp,ao,dEo)
def amp_superav2(c):
"""
Takes superaverage of correlator c, then effective amplitude,
then applies a correction factor sqrt( 4 / 1 + cosh(m_{eff}(t)) ).
This is because taking the superaverage shifts the effective amplitude of a correlator,
this correction cancels that shift.
"""
c = superav2(c)
m = effective_mass(c)
return [
safesqrt(c[t] * exp(m[t] * t) * 2 /
(1 + (exp(-m[t]) + exp(-2 * m[t])) / 2))
for t in range(len(c) - 2)
]
def setUp(self):
## prior
self.prior = gv.BufferDict()
nt = NTERM
self.prior['a'] = gv.gvar(nt*["0.50(1)"])
self.prior['ao'] = gv.gvar(nt*["0.250(5)"])
self.prior['logb'] = gv.log(gv.gvar(nt*["0.60(1)"]))
self.prior['bo'] = gv.gvar(nt*["0.30(1)"])
self.prior['logdEa'] = gv.log(gv.gvar(nt*["0.50(1)"]))
self.prior['logdEao'] = gv.log(gv.gvar(nt*["0.60(1)"]))
self.prior['logdEb'] = gv.log(gv.gvar(nt*["0.45(1)"]))
self.prior['logdEbo'] = gv.log(gv.gvar(nt*["0.65(1)"]))
self.prior['Vnn'] = gv.gvar(nt*[nt*["2.00(1)"]])
self.prior['Vno'] = gv.gvar(nt*[nt*["1.00(1)"]])
self.prior['Von'] = gv.gvar(nt*[nt*["1.00(1)"]])
self.prior['Voo'] = gv.gvar(nt*[nt*["2.00(1)"]])
nsym = int(nt*(nt+1)/2)
self.prior['Vnn_sym'] = gv.gvar(nsym*["2.00(1)"])
self.prior['Voo_sym'] = gv.gvar(nsym*["2.00(1)"])
## actual parameters, time ranges, corr counter
self.p = next(gv.raniter(self.prior))
for x in ['b', 'dEa', 'dEao', 'dEb', 'dEbo']:
self.p[x] = gv.exp(self.p['log' + x])
self.T = 18.
self.tdata = np.arange(self.T)
self.tfit = self.tdata[1:]
self.ncorr = 0
self.ran = gv.gvar(0,1)
def compute_flux(ia, isig, iwid):
idia = orb.cgvar.dawsni(isig / (math.sqrt(2) * iwid))
expa2 = gvar.exp(isig**2. / 2. / iwid**2.)
if not np.isclose(gvar.mean(idia), 0):
return ia * math.pi / math.sqrt(2.) * isig * expa2 / idia
else:
return gvar.gvar(np.inf, np.inf)
def setUp(self):
## prior
self.prior = gv.BufferDict()
nt = NTERM
self.prior["a"] = gv.gvar(nt * ["0.50(1)"])
self.prior["ao"] = gv.gvar(nt * ["0.250(5)"])
self.prior["log(b)"] = gv.log(gv.gvar(nt * ["0.60(1)"]))
self.prior["bo"] = gv.gvar(nt * ["0.30(1)"])
self.prior["log(dEa)"] = gv.log(gv.gvar(nt * ["0.50(1)"]))
self.prior["log(dEao)"] = gv.log(gv.gvar(nt * ["0.60(1)"]))
self.prior["log(dEb)"] = gv.log(gv.gvar(nt * ["0.45(1)"]))
self.prior["log(dEbo)"] = gv.log(gv.gvar(nt * ["0.65(1)"]))
self.prior["Vnn"] = gv.gvar(nt * [nt * ["2.00(1)"]])
self.prior["Vno"] = gv.gvar(nt * [nt * ["1.00(1)"]])
self.prior["Von"] = gv.gvar(nt * [nt * ["1.00(1)"]])
self.prior["Voo"] = gv.gvar(nt * [nt * ["2.00(1)"]])
nsym = int(nt * (nt + 1) / 2)
self.prior["Vnn_sym"] = gv.gvar(nsym * ["2.00(1)"])
self.prior["Voo_sym"] = gv.gvar(nsym * ["2.00(1)"])
## actual parameters, time ranges, corr counter
self.p = next(gv.raniter(self.prior))
for x in ["b", "dEa", "dEao", "dEb", "dEbo"]:
self.p[x] = gv.exp(self.p["log(" + x + ")"])
self.T = 18.0
self.tdata = np.arange(self.T)
self.tfit = self.tdata[1:]
self.ncorr = 0
self.ran = gv.gvar(0, 1)
def effective_amp(c):
"""
Returns effective amplitude
a_{eff}(t) = sqrt( C(t) * exp( m_{eff}(t) * t ) )
"""
m = effective_mass(c)
return [safesqrt(c[t] * exp(m[t] * t)) for t in range(len(c) - 1)]
def test_det(self):
m = self.make_random([[1., 0.1], [0.1, 2.]])
detm = linalg.det(m)
self.assertTrue(gv.equivalent(detm, m[0,0] * m[1,1] - m[0,1] * m[1,0]))
m = self.make_random([[1.0,2.,3.],[0,4,5], [0,0,6]])
self.assertTrue(gv.equivalent(linalg.det(m), m[0, 0] * m[1, 1] * m[2, 2]))
s, logdet = linalg.slogdet(m)
self.assertTrue(gv.equivalent(s * gv.exp(logdet), linalg.det(m)))
def test_apply(self):
" EigenBasis EigenBasis.apply EigenBasis.unapply "
for tdata in [[1.0, 2.0, 3.0, 4.0], [2.0, 4.0, 6.0, 8.0], [0, 1.0, 2.0]]:
tdata = np.array(tdata)
G = self.make_G(tdata, keyfmt="{s1}{s2}", srcs="ab")
basis = EigenBasis(data=G, keyfmt="{s1}{s2}", srcs="ab", t=2, tdata=tdata)
np.testing.assert_allclose(basis.E, self.E)
newG = basis.apply(G, "{s1}{s2}")
newG_mean = gv.mean(newG)
np.testing.assert_allclose(newG_mean["00"], gv.exp(-self.E[0] * tdata))
np.testing.assert_allclose(newG_mean["11"], gv.exp(-self.E[1] * tdata))
np.testing.assert_allclose(newG_mean["01"], 0, atol=1e-10)
np.testing.assert_allclose(newG_mean["10"], 0, atol=1e-10)
oldG = basis.unapply(newG, "{s1}{s2}")
for k in ["aa", "ab", "ba", "bb"]:
np.testing.assert_allclose(gv.mean(oldG[k] - G[k]), 0, atol=1e-10)
np.testing.assert_allclose(gv.sdev(oldG[k] - G[k]), 0, atol=1e-10)
def make_G(self, tdata, keyfmt, srcs):
G = collections.OrderedDict()
tdata = np.array(tdata)
for i, s1 in enumerate(srcs):
for j, s2 in enumerate(srcs):
key = keyfmt.format(s1=s1, s2=s2)
G[key] = 0
for n in range(2):
G[key] += self.u[n, i] * self.u[n, j] * gv.exp(-self.E[n] * tdata) * gv.gvar("1.00(1)")
return G
def apply_invfn_op(key,val):
bkey = get_basekey(key)
if bkey[0] is None:
return val
else:
if bkey[0] == 'log':
return gv.exp(val)
elif bkey[0] == 'sqrt':
return val*val
else:
raise KeyError("Unknown function operation:",bkey[0])
def unpack(p, k):
""" unpacks parameter k in dictionary p """
ans = []
for ki in k:
if ki is None:
ans.append(None)
elif len(ki) > 3 and ki[:3] == "log":
ans.append(gv.exp(p[ki]))
else:
ans.append(p[ki])
return ans
def make_bootstrap(fitter,dset,n_bs):
bs_datalist = (gvd.avg_data(d) for d in gvd.bootstrap_iter(dset,n_bs));
bs = gvd.Dataset();
for bs_fit in fitter.bootstrap_iter(bs_datalist):
p = bs_fit.pmean;
for key in p:
bkey = utf.get_basekey(key)
if bkey[0] == 'log':
bs.append(key[3:],gv.exp(p[key]));
else:
bs.append(key,p[key]);
bs_avg = gvd.avg_data(bs,bstrap=True);
return bs_avg;
def corr3(p, m):
""" build a corr3 -- p=param, m=model """
def make_prop(p, t, a, dE, s, tp):
f = make_f(tp)
a = unpack(p, a)
dE = unpack(p, dE)
s = (s[0], 0.0 if s[1] == 0.0 else s[1] * (-1) ** t)
prop = []
for ai, dEi, si in zip(a, dE, s):
if ai is None or dEi is None:
prop.append(None)
continue
ans = []
sumdE = 0.0
for aij, dEij in zip(ai, dEi):
sumdE += dEij
ans.append(si * aij * f(sumdE, t))
prop.append(ans)
return prop
t = np.array(m.tdata)
aprop = make_prop(p=p, t=t, a=m.a, dE=m.dEa, s=m.sa, tp=m.tpa)
bprop = make_prop(p=p, t=m.T - t, a=m.b, dE=m.dEb, s=m.sb, tp=m.tpb)
ans = 0.0
for i, (apropi, Vi) in enumerate(zip(aprop, m.V)):
if apropi is None:
continue
for j, (bpropj, Vij) in enumerate(zip(bprop, Vi)):
if bpropj is None or Vij is None:
continue
V = gv.exp(p[Vij]) if Vij[:3] == "log" else p[Vij]
if i == j and m.symmetric_V:
na = len(apropi)
nb = len(bpropj)
assert na == nb
iterV = iter(V)
V = np.empty((na, nb), dtype=V.dtype)
for k in range(na):
for l in range(k, nb):
V[k, l] = next(iterV)
if k != l:
V[l, k] = V[k, l]
if m.transpose_V or (i > j and m.symmetric_V):
V = V.T
for ak, Vk in zip(apropi, V):
V_b = 0.0
for bl, Vkl in zip(bpropj, Vk):
V_b += Vkl * bl
ans += ak * V_b
return ans
def gaussian1d(x,h,a,dx,fwhm):
"""Return a 1D gaussian given a set of parameters.
:param x: Array giving the positions where the gaussian is evaluated
:param h: Height
:param a: Amplitude
:param dx: Position of the center
:param fwhm: FWHM, :math:`\\text{FWHM} = \\text{Width} \\times 2 \\sqrt{2 \\ln 2}`
"""
if not isinstance(x, np.ndarray):
x = np.array(x)
w = fwhm / (2. * gvar.sqrt(2. * gvar.log(2.)))
return h + a * gvar.exp(-(x - dx)**2. / (2. * w**2.))
def test_apply(self):
" EigenBasis EigenBasis.apply EigenBasis.unapply "
for tdata in [
[1., 2., 3., 4.],
[2., 4., 6., 8.],
[0, 1., 2.],
]:
tdata = np.array(tdata)
G = self.make_G(tdata, keyfmt='{s1}{s2}', srcs='ab')
basis = EigenBasis(
data=G, keyfmt='{s1}{s2}', srcs='ab',
t=2, tdata=tdata,
)
np.testing.assert_allclose(basis.E, self.E)
newG = basis.apply(G, '{s1}{s2}')
newG_mean = gv.mean(newG)
np.testing.assert_allclose(newG_mean['00'], gv.exp(-self.E[0] * tdata))
np.testing.assert_allclose(newG_mean['11'], gv.exp(-self.E[1] * tdata))
np.testing.assert_allclose(newG_mean['01'], 0, atol=1e-10)
np.testing.assert_allclose(newG_mean['10'], 0, atol=1e-10)
oldG = basis.unapply(newG, '{s1}{s2}')
for k in ['aa', 'ab', 'ba', 'bb']:
np.testing.assert_allclose(gv.mean(oldG[k] - G[k]), 0, atol=1e-10)
np.testing.assert_allclose(gv.sdev(oldG[k] - G[k]), 0, atol=1e-10)
def gaussian1d_complex(x,h,a,dx,fwhm):
"""Return a 1D gaussian given a set of parameters.
:param x: Array giving the positions where the gaussian is evaluated
:param h: Height
:param a: Amplitude
:param dx: Position of the center
:param fwhm: FWHM, :math:`\\text{FWHM} = \\text{Width} \\times 2 \\sqrt{2 \\ln 2}`
"""
if not isinstance(x, np.ndarray):
x = np.array(x)
w = fwhm / (2. * gvar.sqrt(2. * gvar.log(2.)))
b = (x - dx) / (np.sqrt(2) * w)
return (h + a * gvar.exp(-b**2.), h + a * 2 / np.sqrt(np.pi) * special.dawsn(b))
def setUp(self):
## prior
self.prior = gv.BufferDict()
nt = NTERM
self.prior['a'] = gv.gvar(nt*["0.50(1)"])
self.prior['ao'] = gv.gvar(nt*["0.250(5)"])
self.prior['logb'] = gv.log(gv.gvar(nt*["0.60(1)"]))
self.prior['bo'] = gv.gvar(nt*["0.30(1)"])
self.prior['logdE'] = gv.log(gv.gvar(nt*["0.50(1)"]))
self.prior['logdEo'] = gv.log(gv.gvar(nt*["0.60(1)"]))
## actual parameters, time ranges, corr counter
self.p = next(gv.raniter(self.prior))
for x in ['b', 'dE', 'dEo']:
self.p[x] = gv.exp(self.p['log' + x])
self.tp = 10.
self.tdata = np.arange(self.tp)
self.tfit = self.tdata[1:]
self.ncorr = 0
self.ran = gv.gvar(0,1)
Anom = 1 # amplitude guess for actual states (unknown sign)
xAnom = 1e-3 # amplitude guess for possibly unconstrained states
## -- list of keys
nkey_s8 = ('log(En)' ,'log(c1n)','c2n','c3n','c5n','c6n','k1n','k2n','k3n','k5n','k6n')
okey_s8 = ('log(Eo)' ,'log(c1o)','c2o','c3o','c5o','c6o','k1o','k2o','k3o','k5o','k6o')
nkey_s8p = ('log(En)','log(c4n)','c7n','k4n','k7n')
okey_s8p = ('log(Eo)','log(c4o)','c7o','k4o','k7o')
#nkey_s8p = ('log(En)','c4n','c7n','k4n','k7n')
#okey_s8p = ('log(Eo)','c4o','c7o','k4o','k7o')
nkey_s16 = ('log(En)','log(c2n)','c3n','c4n','c6n','k2n','k3n','k4n','k6n')
okey_s16 = ('log(Eo)','log(c2o)','c3o','c4o','c6o','k2o','k3o','k4o','k6o')
## -- HISQ a=0.15 l3248 physical
# S8
define_init_s8['log(En)']=list(gv.exp([0.710,.039,.039,.140,.054,.376,.065,.083] + [1]*10))
define_init_s8['log(Eo)']=list(gv.exp([1.170,.039,.039,.020,.100,.020,.1,.1] + [1]*10))
#define_init_s8['log(En)']=list(gv.exp([0.780,.019,.037,.095,.035,.142,.1,.1] + [1]*10))
#define_init_s8['log(Eo)']=list(gv.exp([0.932,.030,.081,.183,.030,.046,0.1,.1] + [1]*10))
define_init_s8['log(c1n)']=list(gv.exp([Alog]*num_nreal_s8 + [xAlog]*10))
define_init_s8['log(c1o)']=list(gv.exp([Alog]*num_oreal_s8 + [xAlog]*10))
for key in nkey_s8[2:]+okey_s8[2:]:
define_init_s8[key]=[Anom]*num_nreal_s8 + [xAnom]*10
# S8'
define_init_s8p['log(En)']=list(gv.exp([0.9401,.0854,.1212,.2111,.4103] + [1]*10))
#define_init_s8p['log(En)']=list(gv.exp([0.8520,.2293,.0753,.1132] + [1]*10))
#define_init_s8p['log(En)']=list(gv.exp([0.8520,.1426,.2754] + [1]*10))
#define_init_s8p['log(En)']=list(gv.exp([0.9701,.0825,.2754] + [1]*10))
#define_init_s8p['log(En)']=list(gv.exp([.955,0.045,.35,.84] + [1]*10))
define_init_s8p['log(Eo)']=list(gv.exp([1.2124,0.1966,0.7216,.32] + [1]*10))
def g(E, t):
return gv.exp(-E * t)
def fitargs(z,nexp=nexp,prior=prior,f=f,data=(x,y),p0=p0):
z = gv.exp(z)
prior['a'] = [gv.gvar(0.5,0.5*z[0]) for i in range(nexp)]
return dict(prior=prior,data=data,fcn=f,p0=p0)
def fcn(x, p):
return p[0] * gv.exp(-p[1] * x)
def fcn3(x, p):
return gv.exp(-p[0] - p[1] * x - p[2] * x**2)
def f(E, t, tp=tp):
return gv.exp(-E * t) + gv.exp(-E * (tp - t))
def fcn(x, p):
return gv.exp(-p[0] - p[1] * x - p[2] * x**2 - p[3] * x**3)
def fcn(x, p): # fit function of x and parameters p
ans = {}
for k in ["data1", "data2"]:
ans[k] = gv.exp(p['a'] + x[k] * p['b'])
ans['b/a'] = p['b'] / p['a']
return ans
def g(E, t):
return gv.exp(-E * t) - gv.exp(-E * (-tp - t))
def fcn(x, p): # fit function of x and parameters p
ans = {}
for k in ["data1", "data2"]:
ans[k] = gv.exp(p["a"] + x[k] * p["b"])
ans["b/a"] = p["b"] / p["a"]
return ans
def print_fit(self,par,outfile):
"""print the energy and amplitude results from a fit"""
fit = self.results
name = self.name
p = fit.p
self.chi2_cal()
#self.chi2_aug_part()
self.Q = conf_int(self.chi2/2, par.ncon, self.dof/2)
nexp = self.child.nexp
name = self.child.name
CdE = exp(p['log('+name+':dE)'])
CE = [sum(CdE[:i+1]) for i in range(nexp)]
a = exp(p['log('+name+':a)'])
if self.name != 'pimom0':
CdEo = exp(p['log('+name+':dEo)'])
CEo = [sum(CdEo[:i+1]) for i in range(nexp)]
ao = exp(p['log('+name+':ao)'])
name = self.parent.name
PdE = exp(p['log('+name+':dE)'])
PE = [sum(PdE[:i+1]) for i in range(nexp)]
b = exp(p['log('+name+':a)'])
if self.name != 'pimom0':
PdEo = exp(p['log('+name+':dEo)'])
PEo = [sum(PdEo[:i+1]) for i in range(nexp)]
bo = exp(p['log('+name+':ao)'])
# calculating f_0
# DOESN"T WORK FOR D TO K YET!!!!!!!!!
if self.child.name == 'pimom0':
mpi = CE[0]
else:
mpi = gvar(par.pi0,par.pi0_err)
if self.child.name == 'pimom0' or self.child.name == 'pimom2':
m_q = par.m_l
else:
m_q = par.m_s
Epi = CE[0]
mD = PE[0]
v = p['Vnn'][0][0]
self.f_0 = v*sqrt(Epi*mD)*(par.m_c-m_q)/(mD**2-mpi**2)
self.qsq = mpi**2+mD**2-2*mD*Epi
ofile = open(outfile,'a')
if self.dof != 0:
chi2dof = self.chi2/self.dof
else:
chi2dof = 99.9
if chi2dof > 99:
chi2dof = 99.9
pars = "{:s} & {:2d}-{:2d} & {:2d}-{:2d} & {:d}+{:d} & {:4.1f} & {:3d} & {:4.2f} & "
energies = "{:s} & {:<11s} & {:<11s} & "
form = "{:<12s} & {:<12s} \\\\ \n"
ofile.write( pars.format( self.name,self.tmin,self.child.tmax,self.tmax,self.parent.tmax,
nexp,nexp,chi2dof,self.dof,self.Q )
+energies.format( self.child.name,CE[0].fmt(ndecimal=4),a[0].fmt(ndecimal=4) )
+energies.format( self.parent.name,PE[0].fmt(ndecimal=4),b[0].fmt(ndecimal=4) )
+form.format( self.f_0.fmt(ndecimal=4), self.qsq.fmt(ndecimal=4) ) )
def fcn_all_twostate_theta(x, p):
ans = {}
Zc1 = p["Zc1"]
Zc2 = p["Zc2"]
Zcg = p["Zcg"]
Mc1 = p["Mc1"]
Mc2 = p["Mc2"]
Zg1 = p["Zg1"]
Zg2 = p["Zg2"]
Mg1 = p["Mg1"]
Mg2 = p["Mg2"]
theta_1 = p["theta_1"]
theta_2 = p["theta_2"]
corr_cc_1 = gv.exp(-Mc1 * x["tc"]) + gv.exp(-Mc1 * (NT - x["tc"]))
corr_cc_2 = gv.exp(-Mc2 * x["tc"]) + gv.exp(-Mc2 * (NT - x["tc"]))
corr_gg_1 = gv.exp(-Mg1 * x["tc"]) + gv.exp(-Mg1 * (NT - x["tc"]))
corr_gg_2 = gv.exp(-Mg2 * x["tc"]) + gv.exp(-Mg2 * (NT - x["tc"]))
ans["CC"] = Zc1 * (gv.cos(theta_1)**2 * corr_cc_1 + gv.sin(theta_1)**2 *
corr_gg_1) + Zc2 * (gv.cos(theta_2)**2 * corr_cc_2 +
gv.sin(theta_2)**2 * corr_gg_2)
corr_cc_1 = gv.exp(-Mc1 * x["tg"]) + gv.exp(-Mc1 * (NT - x["tg"]))
corr_cc_2 = gv.exp(-Mc2 * x["tg"]) + gv.exp(-Mc2 * (NT - x["tg"]))
corr_gg_1 = gv.exp(-Mg1 * x["tg"]) + gv.exp(-Mg1 * (NT - x["tg"]))
corr_gg_2 = gv.exp(-Mg2 * x["tg"]) + gv.exp(-Mg2 * (NT - x["tg"]))
ans["GG"] = Zg1 * (gv.cos(theta_1)**2 * corr_gg_1 + gv.sin(theta_1)**2 *
corr_cc_1) + Zg2 * (gv.cos(theta_2)**2 * corr_gg_2 +
gv.sin(theta_2)**2 * corr_cc_2)
ans["GC"] = -(
np.sqrt(gv.abs(Zg1 * Zc1)) * gv.cos(theta_1) * gv.sin(theta_1) *
(gv.exp(-Mg1 * x["tgc"]) - gv.exp(-Mg1 * (NT - x["tgc"])) -
gv.exp(-Mc1 * x["tgc"]) + gv.exp(-Mc1 * (NT - x["tgc"]))) +
np.sqrt(gv.abs(Zg2 * Zc2)) * gv.cos(theta_2) * gv.sin(theta_2) *
(gv.exp(-Mg2 * x["tgc"]) - gv.exp(-Mg2 * (NT - x["tgc"])) -
gv.exp(-Mc2 * x["tgc"]) + gv.exp(-Mc2 * (NT - x["tgc"]))))
return ans
def gaussian_pdf(x, f=1.):
xmean = gv.mean(x)
xvar = gv.var(x) * f ** 2
return gv.exp(-xmean ** 2 / 2. /xvar) / gv.sqrt(2 * np.pi * xvar)
def f(p):
return p['a'] * gv.exp(-p['b'] * x)
def test_extension_mapping(self):
" BufferDict extension and mapping properties "
p = BufferDict()
p['a'] = 1.
p['b'] = [2., 3.]
p['log(c)'] = 0.
p['sqrt(d)'] = [5., 6.]
p['erfinv(e)'] = [[33.]]
newp = BufferDict(p)
for i in range(2):
for k in p:
assert np.all(p[k] == newp[k])
assert newp['c'] == np.exp(newp['log(c)'])
assert np.all(newp['d'] == np.square(newp['sqrt(d)']))
assert np.all(newp['e'] == gv.erf(newp['erfinv(e)']))
assert np.all(p.buf == newp.buf)
p.buf[:] = [10., 20., 30., 1., 2., 3., 4.]
newp.buf = np.array(p.buf.tolist())
self.assertEqual(gv.get_dictkeys(p, ['c', 'a', 'log(c)', 'e', 'd']),
['log(c)', 'a', 'log(c)', 'erfinv(e)', 'sqrt(d)'])
self.assertEqual(
[gv.dictkey(p, k) for k in ['c', 'a', 'log(c)', 'e', 'd']],
['log(c)', 'a', 'log(c)', 'erfinv(e)', 'sqrt(d)'])
self.assertTrue(gv.BufferDict.has_dictkey(p, 'a'))
self.assertTrue(gv.BufferDict.has_dictkey(p, 'b'))
self.assertTrue(gv.BufferDict.has_dictkey(p, 'c'))
self.assertTrue(gv.BufferDict.has_dictkey(p, 'd'))
self.assertTrue(gv.BufferDict.has_dictkey(p, 'e'))
self.assertTrue(gv.BufferDict.has_dictkey(p, 'log(c)'))
self.assertTrue(gv.BufferDict.has_dictkey(p, 'sqrt(d)'))
self.assertTrue(gv.BufferDict.has_dictkey(p, 'erfinv(e)'))
self.assertTrue(not gv.BufferDict.has_dictkey(p, 'log(a)'))
self.assertTrue(not gv.BufferDict.has_dictkey(p, 'sqrt(b)'))
self.assertEqual(list(p), ['a', 'b', 'log(c)', 'sqrt(d)', 'erfinv(e)'])
np.testing.assert_equal(list(p.values()),
[10.0, [20., 30.], 1.0, [2., 3.], [[4.]]])
self.assertEqual(p.get('c'), p['c'])
# tracking?
self.assertAlmostEqual(p['c'], np.exp(1))
self.assertAlmostEqual(p['log(c)'], 1.)
p['log(c)'] = 2.
self.assertAlmostEqual(p['c'], np.exp(2))
self.assertAlmostEqual(p['log(c)'], 2.)
p['a'] = 12.
self.assertAlmostEqual(p['c'], np.exp(2))
self.assertAlmostEqual(p['log(c)'], 2.)
self.assertEqual(
list(p),
['a', 'b', 'log(c)', 'sqrt(d)', 'erfinv(e)'],
)
# the rest is not so important
# trim redundant keys
oldp = trim_redundant_keys(newp)
assert 'c' not in oldp
assert 'd' not in oldp
assert np.all(oldp.buf == newp.buf)
# nonredundant keys
assert set(nonredundant_keys(newp.keys())) == set(p.keys())
# stripkey
for ks, f, k in [
('aa', np.exp, 'log(aa)'),
('aa', np.square, 'sqrt(aa)'),
]:
assert (ks, f) == gv._bufferdict._stripkey(k)
# addparentheses
pvar = BufferDict()
pvar['a'] = p['a']
pvar['b'] = p['b']
pvar['logc'] = p['log(c)']
pvar['sqrtd'] = p['sqrt(d)']
pvar['erfinv(e)'] = p['erfinv(e)']
pvar = add_parameter_parentheses(pvar)
for k in p:
assert k in pvar
assert np.all(p[k] == pvar[k])
for k in pvar:
assert k in p
pvar = add_parameter_parentheses(pvar)
for k in p:
assert k in pvar
assert np.all(p[k] == pvar[k])
for k in pvar:
assert k in p
pvar['log(c(23))'] = 1.2
pvar = BufferDict(pvar)
assert 'c(23)' not in pvar
assert 'log(c(23))' in pvar
self.assertAlmostEqual(gv.exp(pvar['log(c(23))']), pvar['c(23)'])
def f(E, t):
return gv.exp(-E * t)
def g(E, t):
return gv.exp(-E * t) + gv.exp(-E * (tp - t))
def f(E, t, tp=tp):
return gv.exp(-E * t) - gv.exp(-E * (-tp - t))
def fcn(x,p): # fit function of x and parameters p
ans = {}
for k in ["data1","data2"]:
ans[k] = gv.exp(p['a'] + x[k]*p['b'])
ans['b/a'] = p['b']/p['a']
return ans
def test_multiseries(self):
def layout_test(m):
ndim = 0
c = m.c[0]
while isinstance(c, PowerSeries):
ndim += 1
c = c.c[0]
shape = ndim * (m.order + 1, )
for idx in np.ndindex(shape):
try:
m[idx]
if sum(idx) > m.order:
raise AssertionError('sum(idx) > m.order')
except:
self.assertGreater(sum(idx), m.order)
# begin
c = np.arange(2 * 3 * 4, dtype=float)
c.shape = (2, 3, 4)
# check order
m = multiseries(c.tolist(), order=3)
assert m.order == 3
layout_test(m)
for ijk in np.ndindex(7, 7, 7):
try:
assert m[ijk] == (c[ijk] if np.all(
np.array(c.shape) > ijk) else 0.)
if sum(ijk) > m.order:
raise AssertionError('sum(ijk) > m.order')
except:
self.assertGreater(sum(ijk), 3)
# now without order; arithmetic; function evaluation
m = multiseries(c)
# check linear arithmetic
c = 2 * c + c / 2
m = 2 * m + m / 2
c[0, 0, 0] = 13.
m[0, 0, 0] = 13.
assert m.order == 6
for ijk in np.ndindex(7, 7, 7):
try:
assert m[ijk] == (c[ijk] if np.all(
np.array(c.shape) > ijk) else 0.)
if sum(ijk) > m.order:
raise AssertionError('sum(ijk) > m.order')
except:
self.assertGreater(sum(ijk), m.order)
def f(x, y, z):
return sum(m[ijk] * x**ijk[0] * y**ijk[1] * z**ijk[2]
for ijk in np.ndindex(c.shape))
self.assertEqual(f(1, 2, 3), m(1, 2, 3))
# derivatives
def Df(x, y, z):
return [
sum(ijk[0] * m[ijk] * x**(ijk[0] - 1) * y**ijk[1] * z**ijk[2]
for ijk in np.ndindex(c.shape)),
sum(ijk[1] * m[ijk] * x**ijk[0] * y**(ijk[1] - 1) * z**ijk[2]
for ijk in np.ndindex(c.shape)),
sum(ijk[2] * m[ijk] * x**ijk[0] * y**ijk[1] * z**(ijk[2] - 1)
for ijk in np.ndindex(c.shape)),
]
self.assertEqual(Df(1, 2, 3), [
m.deriv(1, 0, 0)(1, 2, 3),
m.deriv(0, 1, 0)(1, 2, 3),
m.deriv(0, 0, 1)(1, 2, 3)
])
self.assertEqual(Df(1, 2, 3), [
m.deriv(1)(1, 2, 3),
m.deriv(0, 1)(1, 2, 3),
m.deriv(0, 0, 1)(1, 2, 3)
])
layout_test(m.deriv(1))
self.assertEqual(m.deriv(1).order, m.order - 1)
layout_test(m.deriv(1, 1))
layout_test(m.deriv(1, 2, 3))
self.assertEqual(m.deriv(1, 2, 3).order, m.order - 6)
self.assertEqual(m.deriv(1, 1)(1, 2, 3), m.deriv(1, 1, 0)(1, 2, 3))
def DDf(x, y, z):
return [
sum(ijk[0] * ijk[1] * m[ijk] * x**(ijk[0] - 1) *
y**(ijk[1] - 1) * z**ijk[2]
for ijk in np.ndindex(c.shape)),
sum(ijk[1] * ijk[2] * m[ijk] * x**ijk[0] * y**(ijk[1] - 1) *
z**(ijk[2] - 1) for ijk in np.ndindex(c.shape)),
sum(ijk[2] * ijk[0] * m[ijk] * x**(ijk[0] - 1) * y**ijk[1] *
z**(ijk[2] - 1) for ijk in np.ndindex(c.shape)),
]
self.assertEqual(DDf(1, 2, 3), [
m.deriv(1, 1, 0)(1, 2, 3),
m.deriv(0, 1, 1)(1, 2, 3),
m.deriv(1, 0, 1)(1, 2, 3)
])
def D2f(x, y, z):
return [
sum(ijk[0] * (ijk[0] - 1) * m[ijk] * x**(ijk[0] - 2) *
y**ijk[1] * z**ijk[2] for ijk in np.ndindex(c.shape)),
sum(ijk[1] * (ijk[1] - 1) * m[ijk] * x**ijk[0] *
y**(ijk[1] - 2) * z**ijk[2]
for ijk in np.ndindex(c.shape)),
sum(ijk[2] * (ijk[2] - 1) * m[ijk] * x**ijk[0] * y**ijk[1] *
z**(ijk[2] - 2) for ijk in np.ndindex(c.shape)),
]
self.assertEqual(D2f(1, 2, 3), [
m.deriv(2, 0, 0)(1, 2, 3),
m.deriv(0, 2, 0)(1, 2, 3),
m.deriv(0, 0, 2)(1, 2, 3)
])
self.assertEqual(D2f(1, 2, 3), [
m.deriv(2)(1, 2, 3),
m.deriv(0, 2)(1, 2, 3),
m.deriv(0, 0, 2)(1, 2, 3)
])
self.assertEqual([0., 0., 0.], [
m.deriv(m.order + 1),
m.deriv(0, m.order + 1),
m.deriv(0, 0, m.order + 1)
])
# derivatives undo integrals (not true of reverse)
self.assertEqual(m(1, 2, 3), m.integ(1, 2, 3).deriv(1, 2, 3)(1, 2, 3))
self.assertEqual(
m(1, 2, 3),
m.integ(1, 2, 3, x0=[3, 2, 1]).deriv(1, 2, 3)(1, 2, 3))
self.assertEqual(m(1, 2, 3), m.integ(0, 0, 3).deriv(0, 0, 3)(1, 2, 3))
self.assertEqual(m(1, 2, 3), m.integ(3).deriv(3, 0, 0)(1, 2, 3))
# integrate from x0=[0,0,0]
mm = m.integ(1, 2, 3)
self.assertNotEqual(mm(1, 2, 3), 0)
assert np.allclose(
0,
[
mm(0, 2, 3),
mm(1, 0, 3),
mm(1, 2, 0),
mm(1, 0, 0),
mm(0, 2, 0),
mm(0, 0, 3),
mm(0, 0, 0)
],
)
# integrate from x0=[1,2,3]
mm = m.integ(1, 2, 3, x0=[1, 2, 3])
assert np.allclose(
0,
[
mm(1, 2, 3),
mm(0, 2, 3),
mm(1, 0, 3),
mm(1, 2, 0),
mm(1, 0, 0),
mm(0, 2, 0),
mm(0, 0, 3)
],
)
assert not np.allclose(m(0, 0, 0), 0)
assert not np.allclose(m(2, 0, 0), 0)
assert not np.allclose(m(0, 3, 0), 0)
assert not np.allclose(m(0, 0, 1), 0)
# multivar
c = np.arange(1 * 2 * 3, dtype=float)
c.shape = (1, 2, 3)
m = multiseries(c)
x, y, z = multivar(3, order=m.order)
newm = sum(c[ijk] * x**ijk[0] * y**ijk[1] * z**ijk[2]
for ijk in np.ndindex(c.shape))
self.assertEqual(newm.order, m.order)
for ijk in np.ndindex(3 * (m.order, )):
if sum(ijk) <= m.order:
self.assertEqual(newm[ijk], m[ijk])
exp1 = gv.exp(x + 2 * y + z)
exp2 = gv.exp(x + 2 * y) * gv.exp(z)
assert np.allclose(exp1(0, 0).c, [1., 1., 0.5, 1 / 6.])
assert exp1.order == 3 and exp2.order == 3
assert np.allclose(exp1(0, 0).c, [1., 1., 0.5, 1 / 6.])
for ijk in np.ndindex(3 * (exp1.order, )):
if sum(ijk) <= m.order:
self.assertEqual(exp1[ijk], exp2[ijk])
def gaussian_pdf(x, f=1.):
xmean = gv.mean(x)
xvar = gv.var(x) * f**2
return gv.exp(-xmean**2 / 2. / xvar) / gv.sqrt(2 * np.pi * xvar)
def fcn(p):
b0, b1, b2, b3 = p['b']
x = p['x']
return b0 / ((1 + gv.exp(b1 - b2 * x))**(1. / b3))
def dirtyfit(correlator,
nexp,
key,
tcut=None,
loosener=default_loosener,
zero_buffer=default_zerobuffer,
verbose=False):
"""
Takes in single correlator and associated key,
returns dictionary of best guesses for correlator parameters.
Requires data keys of the format "meson.ss", where "meson" labels the meson,
and the "s"'s labels the source/sink combination,
e.g. etac.ll is a local-local eta_c correlator.
"""
if verbose: print('Performing dirty fit on correlator', key)
Tlat = len(correlator)
if not tcut:
tcut = int(Tlat / 10.)
if verbose: print('tcut set to ', tcut)
if not loosener: loosener = default_loosener
if not zero_buffer: zero_buffer = defalt_zerobuffer
result = gv.BufferDict()
# finding ground state energy
mass = avg_data(
effective_mass(superav2(correlator))[tcut:int(Tlat / 2) -
tcut]) * gv.gvar(1, loosener)
if verbose: print('mass = ', mass)
# finding ground state amplitude
amp = avg_data(amp_superav2(correlator)[tcut:int(Tlat / 2) -
tcut]) * gv.gvar(1, loosener)
if verbose: print('amplitude = ', amp)
# 'excited_correlator' = correlators with ground state term removed
excited_correlator = [
correlator[t] - amp * exp(-mass * t) for t in range(Tlat)
]
# finding first excited energy
spectrum = np.mean(
effective_mass(superav2(excited_correlator))[tcut:int(Tlat / 2) -
tcut]) * gv.gvar(
1, loosener)
spectrum = gv.gvar(zero_buffer / (1 - spectrum.sdev / spectrum.mean),
zero_buffer / (spectrum.mean / spectrum.sdev - 1))
# this transforms spectrum to a gvar that is 1 sigma
# away from zero_buffer with the same fractional sdev
# finding first excited state amplitude
spectrum_amps = np.mean(
amp_superav2(excited_correlator)[tcut:int(Tlat / 2) - tcut]) * gv.gvar(
1, loosener)
spectrum_amps = gv.gvar(
zero_buffer / (1 - spectrum_amps.sdev / spectrum_amps.mean),
zero_buffer / (spectrum_amps.mean / spectrum_amps.sdev - 1))
# this transforms spectrum_amps to a gvar that is 1 sigma
# away from zero_buffer with the same fractional sdev
# building key
try:
meson = re.findall('^(.*)\.[a-zA-Z][a-zA-Z]$', key)[0] # M.ll -> M
source = key.split('.')[-1][0] # M.ll -> l
except IndexError:
meson = key
source = ''
if verbose:
print('found meson label = ', meson, ', source label = ', source)
# building dictionary of results
result.add('log' + meson + ':a' + source,
[safelog(spectrum_amps) for i in range(nexp)])
result.add('logdE:' + meson, [safelog(spectrum) for i in range(nexp)])
result['log' + meson + ':a' + source][0] = safelog(amp)
result['logdE:' + meson][0] = safelog(mass)
# making guesses for oscillating states -
# ground state amplitudes smaller and ground state energies larger than non-oscillating
result.add('logo' + meson + ':a' + source,
[safelog(gv.gvar(amp.mean / 2, amp.mean)) for i in range(nexp)])
result.add('logdE:o' + meson, [safelog(spectrum) for i in range(nexp)])
result['logdE:o' + meson][0] = safelog(gv.gvar(mass.mean * 1.5, mass.mean))
if verbose: print('result = ', result)
return gv.add_parameter_parentheses(result)
