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 make_an_BsEtas(n,Nijk,addrho,p,tag,Fit,alat,mass,amh,fpf0same,newdata=False): # tag is 0,p,T in this way, we can set fp(0)=f0(0) by just putting 0 for n=0 alat is lattice spacing (mean) so we can use this to evaluate at different lattice spacings p is dict containing all values (prior or posterior or anything)
fit = Fit['conf']
an = 0
for i in range(Nijk):
for j in range(Nijk):
for k in range(Nijk):
tagsamed = tag
tagsamerho = tag
if tag == '0' or fpf0same == False:
pass
elif n == 0: # this means only works for t_0 = 0
tagsamerho = '0'
if j == 0 and k == 0 :
tagsamed = '0'
if addrho:
if newdata:
#print('Added external data in a{0}'.format(n))
an += (1 + p['{0}rho'.format(tagsamerho)][n]*gv.log(p['MBsphys']/p['MDsphys'])) * p['{0}d'.format(tagsamed)][i][j][k][n] * (LQCD/p['MBsphys'])**int(i) * (amh/np.pi)**int(2*j) * (LQCD*alat/np.pi)**int(2*k)
elif newdata == False:
an += (1 + p['{0}rho'.format(tagsamerho)][n]*gv.log(p['MHs_{0}_m{1}'.format(fit,mass)]/p['MDs_{0}'.format(fit)])) * (1 + (p['{0}csval'.format(tag)][n]*p['deltasval_{0}'.format(fit)] + p['{0}cs'.format(tag)][n]*p['deltas_{0}'.format(fit)] + 2*p['{0}cl'.format(tag)][n]*p['deltal_{0}'.format(fit)])/(10*p['mstuned_{0}'.format(fit)]) + p['{0}cc'.format(tag)][n]*((p['Metac_{0}'.format(fit)] - p['Metacphys'])/p['Metacphys'])) * p['{0}d'.format(tagsamed)][i][j][k][n] * (p['LQCD_{0}'.format(fit)]/p['MHs_{0}_m{1}'.format(fit,mass)])**int(i) * (amh/np.pi)**int(2*j) * (LQCD*alat/np.pi)**int(2*k)
else:
print('Error in make_an_BsEtas(): newdata = {0}'.format(newdata))
else:
if newdata:
#print('Added external data in a{0}'.format(n))
an += p['{0}d'.format(tagsamed)][i][j][k][n] * (LQCD/p['MBsphys'])**int(i) * (amh/np.pi)**int(2*j) * (LQCD*alat/np.pi)**int(2*k)
elif newdata == False:
an += (1 + (p['{0}csval'.format(tag)][n]*p['deltasval_{0}'.format(fit)] + p['{0}cs'.format(tag)][n]*p['deltas_{0}'.format(fit)] + 2*p['{0}cl'.format(tag)][n]*p['deltal_{0}'.format(fit)])/(10*p['mstuned_{0}'.format(fit)]) + p['{0}cc'.format(tag)][n]*((p['Metac_{0}'.format(fit)] - p['Metacphys'])/p['Metacphys'])) * p['{0}d'.format(tagsamed)][i][j][k][n] * (p['LQCD_{0}'.format(fit)]/p['MHs_{0}_m{1}'.format(fit,mass)])**int(i) * (amh/np.pi)**int(2*j) * (LQCD*alat/np.pi)**int(2*k)
else:
print('Error in make_an_BsEtas(): newdata = {0}'.format(newdata))
return(an)
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 make_prior(models,prior_dict=None,nst=-1,ost=-1,do_amp_prior=True):
prior = gv.BufferDict()
for model in models:
skey=model.all_datatags[0]
if prior_dict is None: ## -- take default from defines
if (nst > -1 and ost > -1):
dprior = utf.get_prior_dict(df.define_prior,
df.define_prior['nkey'],df.define_prior['okey'],nst,ost,do_amp_prior=do_amp_prior)
else:
dprior = utf.get_prior_dict(df.define_prior,
df.define_prior['nkey'],df.define_prior['okey'],df.num_nst,df.num_ost,
do_amp_prior=do_amp_prior)
for pkey in dprior[skey]:
prior[pkey]=dprior[skey][pkey]
## -- logarithmize the logarithmic coefficients
for pkey in prior:
## -- don't do logs unless they are in the current model, else double counting
bkey = utf.get_basekey(pkey)
#if not(pkey[3:] in model.a+model.b+model.dE) and\
# not(pkey[4:] in model.a+model.b+model.dE):
if not(bkey[1] in model.a+model.b+model.dE):
continue
if bkey[0] == 'log':
negcheck = filter(lambda x: x[1].mean < 0,enumerate(prior[pkey]))
if len(negcheck) > 0:
raise ValueError("Prior indices ",list(np.array(negcheck)[:,0]),
" have negative values, key ",pkey)
prior[pkey] = gv.log(prior[pkey])
elif bkey[0] == 'sqrt':
negcheck = filter(lambda x: x[1].mean < 0,enumerate(prior[pkey]))
if len(negcheck) > 0:
raise ValueError("Prior indices ",list(np.array(negcheck)[:,0]),
" have negative values, key ",pkey)
prior[pkey] = gv.sqrt(prior[pkey])
else: ## -- allow passing of new prior, for chained operations
if (nst > -1 and ost > -1):
dprior = utf.get_prior_dict(prior_dict,
prior_dict['nkey'],prior_dict['okey'],nst,ost)
else:
dprior = utf.get_prior_dict(prior_dict,
prior_dict['nkey'],prior_dict['okey'],df.num_nst,df.num_ost)
for pkey in dprior[skey]:
prior[pkey]=dprior[skey][pkey]
for pkey in prior:
bkey = utf.get_basekey(pkey)
#if not(pkey[3:] in model.a+model.b+model.dE) and\
# not(pkey[4:] in model.a+model.b+model.dE):
if not(bkey[1] in model.a+model.b+model.dE):
continue
if bkey[0] == 'log':
prior[pkey] = gv.log(prior[pkey])
elif bkey[0] == 'sqrt':
prior[pkey] = gv.sqrt(prior[pkey])
return prior
def make_prior_all_twostate():
prior = gv.BufferDict()
prior["log(Mg1)"] = gv.log(gv.gvar(0.24, 0.2))
prior["log(Mg2)"] = gv.log(gv.gvar(0.4, 0.2))
prior["Zg1"] = gv.gvar(1, 1)
prior["Zg2"] = gv.gvar(1, 1)
return prior
def make_prior_3pt(models,prior_dict=None,nst=-1,ost=-1,n3st=-1,o3st=-1,do_amp_prior=True):
prior = gv.BufferDict()
for model in models:
skey=model.all_datatags[0]
if prior_dict is None: ## -- take default from defines
if (nst > -1 and ost > -1):
dprior = utf.get_prior_dict(df.define_prior_3pt,
df.define_prior_3pt['nkey'],df.define_prior_3pt['okey'],nst,ost,
df.define_prior_3pt['vkey'],n3st,o3st,
do_v_symm=df.do_v_symmetric,do_amp_prior=df.do_amp_prior)
else:
dprior = utf.get_prior_dict(df.define_prior_3pt,
df.define_prior_3pt['nkey'],df.define_prior_3pt['okey'],df.num_nst,df.num_ost,
df.define_prior_3pt['vkey'],df.num_nst_3pt,df.num_ost_3pt,
do_v_symm=df.do_v_symmetric,do_amp_prior=df.do_amp_prior)
for pkey in dprior[skey]:
prior[pkey]=dprior[skey][pkey]
## -- logarithmize the logarithmic coefficients
for pkey in prior:
## -- don't do logs unless they are in the current model, else double counting
bkey = utf.get_basekey(pkey)
if not(bkey[1] in model.a+model.b+model.dEa+model.dEb):
continue
if bkey[0] == 'log':
#print pkey,prior[pkey]
prior[pkey] = gv.log(prior[pkey])
elif bkey[0] == 'sqrt':
prior[pkey] = gv.sqrt(prior[pkey])
else: ## -- allow passing of new prior, for chained operations
if (nst > -1 and ost > -1):
dprior = utf.get_prior_dict(prior_dict,
prior_dict['nkey'],prior_dict['okey'],nst,ost,prior_dict['vkey'],n3st,o3st,df.do_v_symmetric)
else:
dprior = utf.get_prior_dict(prior_dict,
prior_dict['nkey'],prior_dict['okey'],df.num_nst,df.num_ost,
prior_dict['vkey'],df.num_nst_3pt,df.num_ost_3pt,df.do_v_symmetric)
for pkey in dprior[skey]:
prior[pkey]=dprior[skey][pkey]
for pkey in prior:
bkey = utf.get_basekey(pkey)
if not(bkey[1] in model.a+model.b+model.dEa+model.dEb):
continue
if bkey[0] == 'log':
prior[pkey] = gv.log(prior[pkey])
elif bkey[0] == 'sqrt':
prior[pkey] = gv.sqrt(prior[pkey])
return prior
def safelog(x, verbose=False):
"""
Takes in gvar x, returns log(x). If x not suitable for log, returns log(1.0(9)).
"""
logx = log(x)
if isnan(gv.mean(logx)):
if verbose:
print(
'CorrBayes.safelog WARNING: invalid argument for log - replacing with log(1.0(9))'
)
return log(gv.gvar(1.0, 0.9))
else:
return logx
def make_prior(N):
""" Create prior for N-state fit. """
prior = collections.OrderedDict()
prior['log(a)'] = gv.log(gv.gvar(['1.00(0.99)'] +
(N - 1) * ['0.01(0.99)']))
prior['log(dE)'] = gv.log(gv.gvar(['1.5(5)'] + (N - 1) * ['0.3(2)']))
#----------OSC PARAMS-------------#
if OSC:
prior['log(ao)'] = gv.log(
gv.gvar(['1.00(0.99)'] + (N - 1) * ['0.01(0.99)']))
prior['log(dEo)'] = gv.log(gv.gvar(['1.5(5)'] + (N - 1) * ['0.3(2)']))
return prior
def build_prior(self,params):
"""build prior from file"""
prior = BufferDict()
name = self.name
nexp = self.nexp
noxp = self.noxp
prior_file = open(self.priorfile,'r')
pp = yaml.load(prior_file)
prior['log('+name+':dE)'] = [ gvar(0,0) for i in range(nexp) ]
prior['log('+name+':a)'] = [ gvar(0,0) for i in range(nexp) ]
# non-osc. state priors
prior['log('+name+':dE)'][0] = log(gvar(pp['e0'][0],pp['e0'][1]))
prior['log('+name+':a)'][0] = log(gvar(pp['a0'][0],pp['a0'][1]))
for i in range(1,nexp):
prior['log('+name+':dE)'][i] = log(gvar(pp['e1'][0],pp['e1'][1]))
prior['log('+name+':a)'][i] = log(gvar(pp['a1'][0],pp['a1'][1]))
# osc. state priors
if self.name != 'pimom0':
prior['log('+name+':dEo)'] = [ 0 for i in range(noxp) ]
prior['log('+name+':ao)'] = [ 0 for i in range(noxp) ]
prior['log('+name+':dEo)'][0] = log(gvar(pp['o0'][0],pp['o0'][1]))
prior['log('+name+':ao)'][0] = log(gvar(pp['b0'][0],pp['b0'][1]))
for i in range(1,noxp):
prior['log('+name+':dEo)'][i] = log(gvar(pp['o1'][0],pp['o1'][1]))
prior['log('+name+':ao)'][i] = log(gvar(pp['b1'][0],pp['b1'][1]))
#print(prior)
return prior
def make_prior_all_twostate_theta():
prior = gv.BufferDict()
prior["log(Mc1)"] = gv.log(gv.gvar(0.28, 0.2))
prior["log(Mc2)"] = gv.log(gv.gvar(0.4, 0.2))
prior["log(Mg1)"] = gv.log(gv.gvar(0.24, 0.2))
prior["log(Mg2)"] = gv.log(gv.gvar(0.4, 0.2))
prior["Zc1"] = gv.gvar(50, 50)
prior["Zc2"] = gv.gvar(10, 10)
prior["Zcg"] = gv.gvar(0.02, 0.05)
prior["Zg1"] = gv.gvar(1, 5)
prior["Zg2"] = gv.gvar(0, 1)
prior["theta_1"] = gv.gvar(0.1, 0.2)
prior["theta_2"] = gv.gvar(-0.3, 0.2)
return prior
def test_chained_lsqfit(self):
" MultiFitter.chained_lsqfit(models=[m1, m2, m3], ...) "
# sequential fit
fitter = MultiFitter(models=self.make_models(ncg=1))
fit1 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertEqual(str(fit1.p), "{'a': 0.99929(48),'b': 0.50004(81)}")
self.assertEqual(list(fit1.chained_fits.keys()), ['l', 'c1', 'c2'])
# with coarse grain, marginalization and extend, and with fast=False
prior = gv.BufferDict([
('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b']),
])
prior['log(aa)'] = prior['log(a)'] + gv.gvar('0(1)') * 1e-6
fitter = MultiFitter(models=self.make_models(ncg=2), fast=False)
fit2 = fitter.chained_lsqfit(data=self.data,
prior=prior,
mopt=True,
extend=True)
self.assertEqual(
str(fit2.p),
"{'log(a)': -0.00073(48),'b': 0.50015(82),"
"'log(aa)': -0.00073(48),'a': 0.99927(48),"
"'aa': 0.99927(48)}",
)
def test_flat():
hp = gvar.BufferDict({'log(sdev)': gvar.log(gvar.gvar(1, 1))})
x = np.linspace(0, 5, 10)
def gpfactory1(hp):
gp = lgp.GP(lgp.ExpQuad() * hp['sdev']**2)
gp.addx(x, 'x')
return gp
def gpfactory2(hp):
gp = lgp.GP(lgp.ExpQuad() * jnp.exp(hp[0])**2)
gp.addx(x, 'x')
return gp
def gpfactory3(hp):
gp = lgp.GP(lgp.ExpQuad() * jnp.exp(hp)**2)
gp.addx(x, 'x')
return gp
truehp = gvar.sample(hp)
truegp = gpfactory1(truehp)
trueprior = truegp.prior()
data = gvar.sample(trueprior)
fit1 = lgp.empbayes_fit(hp, gpfactory1, data)
fit2 = lgp.empbayes_fit(hp.buf, gpfactory2, data)
fit3 = lgp.empbayes_fit(hp.buf[0], gpfactory3, data)
util.assert_similar_gvars(fit1.p.buf[0], fit2.p[0], fit3.p)
def test_extend(self):
" MultiFitter.lsqfit(..., extend=True) "
fitter = MultiFitter(models=self.make_models(ncg=1))
prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b'])])
fit5 = fitter.lsqfit(data=self.data, prior=prior, extend=True)
self.assertEqual(str(fit5.p['a']), str(self.ref_fit.p['a']))
self.assertEqual(gv.fmt_chi2(fit5), gv.fmt_chi2(self.ref_fit))
self.assertTrue('log(a)' in fit5.p)
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(dE)"] = gv.log(gv.gvar(nt * ["0.50(1)"]))
self.prior["log(dEo)"] = gv.log(gv.gvar(nt * ["0.60(1)"]))
## actual parameters, time ranges, corr counter
self.p = gv.ExtendedDict(next(gv.raniter(self.prior)))
self.tp = 10.0
self.tdata = np.arange(self.tp)
self.tfit = self.tdata[1:]
self.ncorr = 0
self.ran = gv.gvar(0, 1)
def test_extend(self):
" MultiFitter.lsqfit(...) "
fitter = MultiFitter(models=self.make_models(ncg=1))
prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b'])])
fit5 = fitter.lsqfit(data=self.data, prior=prior)
self.assertTrue(self.agree_ref(fit5.p))
self.assertTrue(
abs(fit5.chi2 - self.ref_fit.chi2) / 0.1 / self.ref_fit.chi2)
self.assertTrue('log(a)' in fit5.p)
def make_prior(N, basis):
prior = basis.make_prior(nterm=N, keyfmt=tag + '{s1}') #, eig_srcs=True)
if OSC:
prior1 = collections.OrderedDict()
for i in SRCs:
prior1[otag + i] = gv.gvar(['1(0.9)'] + (N - 1) * ['0.5(5)'])
prior1['log(' + otag + 'dE)'] = gv.log(
gv.gvar(['1.7(4)'] + (N - 1) * ['0.5(4)']))
prior.update(prior1)
return prior
def apply_fn_op(key,val):
bkey = get_basekey(key)
if bkey[0] is None:
return val
else:
if bkey[0] == 'log':
return gv.log(val)
elif bkey[0] == 'sqrt':
return gv.sqrt(val)
else:
raise KeyError("Unknown function operation:",bkey[0])
def test_scale():
hp = {'log(scale)': gvar.log(gvar.gvar(3, 0.2))}
x = np.linspace(0, 2 * np.pi * 5, 20)
def gpfactory(hp):
gp = lgp.GP(lgp.ExpQuad(scale=hp['scale']))
gp.addx(x, 'x')
return gp
for _ in range(10):
check_fit(hp, gpfactory, alpha=1e-7)
def test_sdev():
hp = {'log(sdev)': gvar.log(gvar.gvar(1, 1))}
x = np.linspace(0, 5, 10)
def gpfactory(hp):
gp = lgp.GP(lgp.ExpQuad() * hp['sdev']**2)
gp.addx(x, 'x')
return gp
for _ in range(10):
check_fit(hp, gpfactory, alpha=1e-8)
def test_period():
hp = {'log(scale)': gvar.log(gvar.gvar(1, 0.1))}
x = np.linspace(0, 6, 10)
def gpfactory(hp):
gp = lgp.GP(lgp.Periodic(scale=hp['scale']))
gp.addx(x, 'x')
return gp
for _ in range(10):
check_fit(hp, gpfactory)
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)
def test_data():
hp = gvar.BufferDict({'log(sdev)': gvar.log(gvar.gvar(1, 1))})
x = np.linspace(0, 5, 10)
def gpfactory(hp):
gp = lgp.GP(lgp.ExpQuad() * hp['sdev']**2)
gp.addx(x, 'x')
return gp
truehp = gvar.sample(hp)
truegp = gpfactory(truehp)
trueprior = truegp.prior()
def makeerr(bd, err):
return gvar.BufferDict(bd, buf=np.full_like(bd.buf, err))
data_noerr = gvar.sample(trueprior)
error = makeerr(data_noerr, 0.1)
zeroerror = makeerr(data_noerr, 0)
zerocov = gvar.evalcov(gvar.gvar(data_noerr, zeroerror))
data_err = gvar.make_fake_data(gvar.gvar(data_noerr, error))
datas = [
[
data_noerr,
gvar.gvar(data_noerr),
(data_noerr, ),
(data_noerr, zerocov),
lambda _: data_noerr,
lambda _: gvar.gvar(data_noerr),
lambda _: (data_noerr, ),
lambda _: (data_noerr, zerocov),
],
[
data_err,
(data_err, ),
(gvar.mean(data_err), gvar.evalcov(data_err)),
lambda _: data_err,
lambda _: (data_err, ),
lambda _: (gvar.mean(data_err), gvar.evalcov(data_err)),
],
]
for datasets in datas:
fits = []
for data in datasets:
fit = lgp.empbayes_fit(hp, gpfactory, data)
fits.append(fit)
p = fits[0].minresult.x
for fit in fits[1:]:
np.testing.assert_allclose(fit.minresult.x, p, atol=1e-6)
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 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 sincgauss1d_complex(x, h, a, dx, fwhm, sigma):
"""The "complex" version of the sincgauss (dawson definition).
This is the real sinc*gauss function when ones wants to fit both the real
part and the imaginary part of the spectrum.
:param x: 1D array of float64 giving the positions where the
function is evaluated
:param h: Height
:param a: Amplitude
:param dx: Position of the center
:param fwhm: FWHM of the sinc
:param sigma: Sigma of the gaussian.
"""
if np.size(sigma) > 1:
if np.any(sigma != sigma[0]):
raise Exception('Only one value of sigma can be passed')
else:
sigma = sigma[0]
sigma = np.fabs(sigma)
fwhm = np.fabs(fwhm)
broadening_ratio = np.fabs(sigma / fwhm)
max_broadening_ratio = gvar.mean(broadening_ratio) + gvar.sdev(
broadening_ratio)
if broadening_ratio < 1e-2:
return sinc1d_complex(x, h, a, dx, fwhm)
if np.isclose(gvar.mean(sigma), 0.):
return sinc1d_complex(x, h, a, dx, fwhm)
if max_broadening_ratio > 7:
return gaussian1d_complex(x, h, a, dx,
sigma * (2. * gvar.sqrt(2. * gvar.log(2.))))
width = gvar.fabs(fwhm) / orb.constants.FWHM_SINC_COEFF
width /= np.pi ###
a_ = sigma / np.sqrt(2) / width
b_ = ((x - dx) / np.sqrt(2) / sigma)
if b_.dtype == np.float128: b_ = b_.astype(float)
sg1c = orb.cgvar.sincgauss1d_complex(a_, b_)
return (h + a * sg1c[0], h + a * sg1c[1])
def test_chained_lsqfit(self):
" MultiFitter.chained_lsqfit(...) "
# sequential fit
fitter = MultiFitter(models=self.make_models(ncg=1))
fit1 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertTrue(self.agree_ref(fit1.p))
self.assertEqual(list(fit1.chained_fits.keys()), ['l', 'c1', 'c2'])
# with coarse grain, marginalization and extend, and with fast=False
prior = gv.BufferDict([
('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b']),
])
prior['log(aa)'] = prior['log(a)'] + gv.gvar('0(1)') * 1e-6
fitter = MultiFitter(models=self.make_models(ncg=2), fast=False)
fit2 = fitter.chained_lsqfit(data=self.data, prior=prior, mopt=True)
self.assertTrue(self.agree_ref(fit2.p))
def test_chained_fit_simul(self):
" MultiFitter(models=[m1, (m2,m3)], ...) "
models = self.make_models(ncg=1)
models = [models[0], tuple(models[1:])]
fitter = MultiFitter(models=models)
fit3 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertTrue(self.agree_ref(fit3.p))
self.assertEqual(list(fit3.chained_fits.keys()), ['l', '(c1,c2)'])
# with coarse grain, marginalization and extend
models = self.make_models(ncg=2)
models = [models[0], tuple(models[1:])]
prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b'])])
fitter = MultiFitter(models=self.make_models(ncg=2))
fit4 = fitter.chained_lsqfit(data=self.data, prior=prior, mopt=True)
self.assertTrue(self.agree_ref(fit4.p))
def sincgauss1d(x, h, a, dx, fwhm, sigma):
"""Return a 1D sinc convoluted with a gaussian of parameter sigma.
If sigma == 0 returns a pure sinc.
:param x: 1D array of float64 giving the positions where the
sinc is evaluated
:param h: Height
:param a: Amplitude
:param dx: Position of the center
:param fwhm: FWHM of the sinc
:param sigma: Sigma of the gaussian.
"""
if np.size(sigma) > 1:
if np.any(sigma != sigma[0]):
raise Exception('Only one value of sigma can be passed')
else:
sigma = sigma[0]
sigma = np.fabs(sigma)
fwhm = np.fabs(fwhm)
broadening_ratio = np.fabs(sigma / fwhm)
max_broadening_ratio = gvar.mean(broadening_ratio) + gvar.sdev(
broadening_ratio)
if broadening_ratio < 1e-2:
return sinc1d(x, h, a, dx, fwhm)
if np.isclose(gvar.mean(sigma), 0.):
return sinc1d(x, h, a, dx, fwhm)
if max_broadening_ratio > 7:
return gaussian1d(x, h, a, dx,
sigma * (2. * gvar.sqrt(2. * gvar.log(2.))))
width = gvar.fabs(fwhm) / orb.constants.FWHM_SINC_COEFF
width /= np.pi ###
a_ = sigma / math.sqrt(2) / width
b_ = (x - dx) / math.sqrt(2) / sigma
return h + a * orb.cgvar.sincgauss1d(a_, b_)
def make_prior(N):
""" Create priors for fit parameters. """
prior = gv.BufferDict()
# etas
metas = gv.gvar('0.4(2)')
prior['log(etas:a)'] = gv.log(gv.gvar(N * ['0.3(3)']))
prior['log(etas:dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(etas:dE)'][0] = gv.log(metas)
# Ds
mDs = gv.gvar('1.2(2)')
prior['log(Ds:a)'] = gv.log(gv.gvar(N * ['0.3(3)']))
prior['log(Ds:dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(Ds:dE)'][0] = gv.log(mDs)
# Ds -- oscillating part
prior['log(Dso:a)'] = gv.log(gv.gvar(N * ['0.1(1)']))
prior['log(Dso:dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(Dso:dE)'][0] = gv.log(mDs + gv.gvar('0.3(3)'))
# V
prior['Vnn'] = gv.gvar(N * [N * ['0(1)']])
prior['Vno'] = gv.gvar(N * [N * ['0(1)']])
return prior
def make_prior(N):
""" Create priors for fit parameters. """
prior = gv.BufferDict()
# etas
metas = gv.gvar('0.4(2)')
prior['log(etas:a)'] = gv.log(gv.gvar(N * ['0.3(3)']))
prior['log(etas:dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(etas:dE)'][0] = gv.log(metas)
# Ds
mDs = gv.gvar('1.2(2)')
prior['log(Ds:a)'] = gv.log(gv.gvar(N * ['0.3(3)']))
prior['log(Ds:dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(Ds:dE)'][0] = gv.log(mDs)
# Ds -- oscillating part
prior['log(Dso:a)'] = gv.log(gv.gvar(N * ['0.1(1)']))
prior['log(Dso:dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(Dso:dE)'][0] = gv.log(mDs + gv.gvar('0.3(3)'))
# V
prior['Vnn'] = gv.gvar(N * [N * ['0(1)']])
prior['Vno'] = gv.gvar(N * [N * ['0(1)']])
return prior
def test_chained_fit_seq_simul(self):
" MultiFitter.chained_lsqfit(models=[m1, (m2,m3)], ...) "
models = self.make_models(ncg=1)
models = [models[0], tuple(models[1:])]
fitter = MultiFitter(models=models)
fit3 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertEqual(str(fit3.p), "{'a': 0.99931(48),'b': 0.50000(81)}")
self.assertEqual(list(fit3.chained_fits.keys()), ['l', '(c1,c2)'])
# with coarse grain, marginalization and extend
models = self.make_models(ncg=2)
models = [models[0], tuple(models[1:])]
prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b'])])
fitter = MultiFitter(models=self.make_models(ncg=2))
fit4 = fitter.chained_lsqfit(data=self.data,
prior=prior,
mopt=True,
extend=True)
self.assertEqual(str(fit4.p),
"{'log(a)': -0.00073(48),'a': 0.99927(48)}")
def test_chained_fit_seq_parallel(self):
" MultiFitter.chained_lsqfit(models=[m1, [m2,m3]], ...) "
models = self.make_models(ncg=1)
models = [models[0], models[1:]]
fitter = MultiFitter(models=models)
fit5 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertEqual(str(fit5.p), "{'a': 0.99932(48),'b': 0.49998(81)}")
self.assertEqual(list(fit5.chained_fits.keys()), ['l', '[c1,c2]'])
self.assertEqual(list(fit5.chained_fits['[c1,c2]'].sub_fits.keys()),
['c1', 'c2'])
# with coarse grain, marginalization and extend
models = self.make_models(ncg=2)
models = [models[0], models[1:]]
prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b'])])
fitter = MultiFitter(models=self.make_models(ncg=2))
fit6 = fitter.chained_lsqfit(data=self.data,
prior=prior,
mopt=True,
extend=True)
self.assertEqual(str(fit6.p),
"{'log(a)': -0.00073(48),'a': 0.99927(48)}")
def test_chained_fit_parallel(self):
" MultiFitter(models=[m1, [m2,m3]], ...) "
models = self.make_models(ncg=1)
models = [models[0], models[1:]]
fitter = MultiFitter(models=models)
fit5 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertTrue(self.agree_ref(fit5.p))
self.assertEqual(list(fit5.chained_fits.keys()),
['l', 'c1', 'c2', 'wavg(c1,c2)'])
# degenerate parallel fit (nfit=1)
models = self.make_models(ncg=1)
models = [[models[0]], models[1:]]
fitter = MultiFitter(models=models)
fit5 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertTrue(self.agree_ref(fit5.p))
self.assertEqual(list(fit5.chained_fits.keys()),
['l', 'c1', 'c2', 'wavg(c1,c2)'])
# dictionaries in parallel fits
models = self.make_models(ncg=1)
models = [[dict(svdcut=1e-12), models[0]],
[dict(svdcut=1e-12)] + models[1:]]
fitter = MultiFitter(models=models)
fit5 = fitter.chained_lsqfit(data=self.data, prior=self.prior)
self.assertTrue(self.agree_ref(fit5.p))
self.assertEqual(list(fit5.chained_fits.keys()),
['l', 'c1', 'c2', 'wavg(c1,c2)'])
# with coarse grain, marginalization
models = self.make_models(ncg=2)
models = [models[0], models[1:]]
prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])),
('b', self.prior['b'])])
fitter = MultiFitter(models=self.make_models(ncg=2))
fit6 = fitter.chained_lsqfit(data=self.data, prior=prior, mopt=True)
self.assertTrue(self.agree_ref(fit6.p))
def test_method():
hp = gvar.BufferDict({'log(sdev)': gvar.log(gvar.gvar(1, 1))})
x = np.linspace(0, 5, 10)
def gpfactory(hp):
gp = lgp.GP(lgp.ExpQuad() * hp['sdev']**2)
gp.addx(x, 'x')
return gp
truehp = gvar.sample(hp)
truegp = gpfactory(truehp)
trueprior = truegp.prior()
data_fixed = gvar.sample(trueprior)
def data_variable(hp):
return {k: v + hp['log(sdev)'] for k, v in data_fixed.items()}
for data in [data_fixed, data_variable]:
fits = []
kws = [
dict(method='nograd', minkw=dict(options=dict(xatol=1e-6))),
dict(method='gradient'),
dict(method='hessian'),
dict(method='fisher'),
dict(method='fisher'),
dict(method='hessmod'),
]
for kw in kws:
kwargs = dict(data=data)
kwargs.update(kw)
kwargs.setdefault('minkw', {}).update(x0=truehp.buf)
fit = lgp.empbayes_fit(hp, gpfactory, **kwargs)
fits.append(fit)
p = fits[0].minresult.x
for fit in fits[1:]:
np.testing.assert_allclose(fit.minresult.x, p, atol=1e-5)
def get_sigma_str(key,fit,prior,j,do_unicode=True):
## -- list the sigma away from prior
#
try:
## -- requesting log, log prior
## or requesting linear, linear prior
sig=int(np.abs(np.trunc(\
(fit.p[key][j].mean-prior[key][j].mean)\
/(prior[key][j]).sdev)))
except KeyError:
## -- requested linear, have log or sqrt prior
try:
sig=int(np.abs(np.trunc(\
(gv.log(fit.p[key][j].mean)-prior['log('+key+')'][j].mean)\
/(prior['log('+key+')'][j]).sdev)))
except KeyError:
sig=int(np.abs(np.trunc(\
(gv.sqrt(fit.p[key][j].mean)-prior['sqrt('+key+')'][j].mean)\
/(prior['sqrt('+key+')'][j]).sdev)))
except TypeError:
## -- Vnn, Vno, etc...
#print key,j
sig=int(np.abs(np.trunc(\
(fit.p[key][j[0]][j[1]].mean-prior[key][j[0]][j[1]].mean)\
/(prior[key][j[0]][j[1]]).sdev)))
if do_unicode:
if sig > 0:
sigstr=str(sig)+u'\u03C3' # unicode for sigma (cannot be saved to string)
else:
sigstr=' '
else:
if sig > 0:
sigstr=str(sig)+'sig'
else:
sigstr=' '
return sigstr
def make_prior(N):
""" Create priors for fit parameters. """
prior = gv.BufferDict()
# Ds
mDs = gv.gvar('1.2(2)')
prior['log(a)'] = gv.log(gv.gvar(N * ['0.3(3)']))
prior['log(dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(dE)'][0] = gv.log(mDs)
# Ds -- oscillating part
prior['log(ao)'] = gv.log(gv.gvar(N * ['0.1(1)']))
prior['log(dEo)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(dEo)'][0] = gv.log(mDs + gv.gvar('0.3(3)'))
# V
nV = int((N * (N + 1)) / 2)
prior['Vnn'] = gv.gvar(nV * ['0(1)'])
prior['Voo'] = gv.gvar(nV * ['0(1)'])
prior['Vno'] = gv.gvar(N * [N * ['0(1)']])
return prior
def make_prior(N):
""" Create priors for fit parameters. """
prior = gv.BufferDict()
# Ds
mDs = gv.gvar('1.2(2)')
prior['log(a)'] = gv.log(gv.gvar(N * ['0.3(3)']))
prior['log(dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(dE)'][0] = gv.log(mDs)
# Ds -- oscillating part
prior['log(ao)'] = gv.log(gv.gvar(N * ['0.1(1)']))
prior['log(dEo)'] = gv.log(gv.gvar(N * ['0.5(5)']))
prior['log(dEo)'][0] = gv.log(mDs + gv.gvar('0.3(3)'))
# V
nV = int((N * (N + 1)) / 2)
prior['Vnn'] = gv.gvar(nV * ['0.0(5)'])
prior['Voo'] = gv.gvar(nV * ['0.0(5)'])
prior['Vno'] = gv.gvar(N * [N * ['0.0(5)']])
return prior
def build_prior(nexp, dErho=gv.gvar('0.476(100)')):
""" build prior """
prior = gv.BufferDict()
prior.add(
'a:rho',
[gv.gvar(0, 0.1),
gv.gvar(0, 0.1),
gv.gvar(0, 0.1),
gv.gvar(0, 0.1)])
# fix it so that the rho terms are opposite sign to the omega
prior.add('b:rho', [
-prior['a:rho'][0], prior['a:rho'][1], prior['a:rho'][2],
-prior['a:rho'][3]
])
prior.add('log(dE:rho)', [log(gv.gvar(0.5, 0.4)) for i in range(nexp)])
prior['log(dE:rho)'][0] = log(dErho) # rho
prior['log(dE:rho)'][1] = log(gv.gvar('0.09(18)')) # omega
prior['log(dE:rho)'][2] = log(gv.gvar('0.90(32)')) # excited omega
prior['log(dE:rho)'][3] = log(gv.gvar('0.023(30)')) #excited rho
prior.add(
'a:rhoo',
[gv.gvar(0, 0.1),
gv.gvar(0, 0.1),
gv.gvar(0, 0.1),
gv.gvar(0, 0.1)])
prior.add('b:rhoo', [
-prior['a:rhoo'][0], prior['a:rhoo'][1], prior['a:rhoo'][2],
-prior['a:rhoo'][3]
])
prior.add('log(dE:rhoo)', [log(gv.gvar(1, 1)) for i in range(nexp)])
prior['log(dE:rhoo)'][0] = log(gv.gvar(2, 2))
##
return prior
def make_prior(N):
""" Create prior for N-state fit. """
prior = collections.OrderedDict()
prior['a'] = gv.gvar(N * ['0(1)'])
prior['log(dE)'] = gv.log(gv.gvar(N * ['0.5(5)']))
return prior
def plot_corr_effective_mass(models,data,fit=None,req=[list(),list()],**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_emNMod = len(models)
_emIdx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Central/Error are the central value and errors
_emLogRatio = []
_emLogRatioCentral = []
_emLogRatioError = []
_emLogRatioFit = []
_emFoldRatio = []
_emFoldRatioCentral= []
_emFoldRatioError = []
_emFoldRatioFit = []
_emRatioFit = []
_emRatioFitNonZero = []
_emFitCentral = []
_emFitError = []
## -- timeslice objects
_emTPosRatio = []
_emTPosFit = []
_emTPosFold = []
_emTPosFoldFit = []
#
## -- fitting options
_emFitMin = 0
_emFitMax = 0
_emSep = 0
fig,ax = plt.subplots(1,figsize=(10,8))
#
## -- setup plot function
def do_plot_corr_effective_mass(idx,fig=fig):
fig.clear()
#fig.set_size_inches(10,10) #doesn't work
ax = fig.add_subplot(111)
if print_quality:
plt.subplots_adjust(bottom=0.15,left=0.18,right=0.97,top=0.95)
else:
#plt.subplots_adjust(bottom=0.15,left=0.15,right=0.97,top=0.95)
pass
#fig.set_figheight(20) #doesn't work
#fig.set_figwidth(20)
key = models[idx[0]].datatag
ax.set_xlim([-1,df.cor_len/2])
ax.set_ylim(utp.get_option("y_limit",[0.0,1.4],**kwargs[key]))
#
# -- plot correlator data
if utp.get_option("meff_do_fold",False,**kwargs[key]):
## -- plot fit
ax.plot([t for t in _emTPosFit[idx[0]] if t < len(_emTData)/2],_emFitCentral[idx[0]],
color=utp.get_option("color3",'b',**kwargs[key]))
ax.plot([t for t in _emTPosFit[idx[0]] if t < len(_emTData)/2],_emFitError[idx[0]][0],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
ax.plot([t for t in _emTPosFit[idx[0]] if t < len(_emTData)/2],_emFitError[idx[0]][1],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- _emTPosRatio not necessarily symmetric, get times correct
ax.errorbar(_emTPosFold[idx[0]],_emFoldRatioCentral[idx[0]],yerr=_emFoldRatioError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",10,**kwargs[key]))
ax.scatter(_emTPosFoldFit[idx[0]],gv.mean(_emFoldRatioFit[idx[0]]),
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",100,**kwargs[key]))
else:
## -- plot fit
ax.plot(_emTPosFit[idx[0]],_emFitCentral[idx[0]],
color=utp.get_option("color3",'b',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][0],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][1],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## --
ax.errorbar(_emTPosRatio[idx[0]],_emLogRatioCentral[idx[0]],yerr=_emLogRatioError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",8,**kwargs[key]))
ax.scatter(_emTPosFit[idx[0]],gv.mean(_emLogRatioFit[idx[0]]),
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",64,**kwargs[key]))
fig.suptitle(utp.get_option("plottitleem",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
# -- modify some options
if print_quality:
ax.set_xlabel(r'$t$',fontsize=40)
if sn_ratio:
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}v_{i}^{T}\,log\frac{C_{ij}(t+"+str(_emSep)+r")}{C_{ij}(t)}w_{j}$",
**kwargs[key]),fontsize=40)
else:
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}\,log\frac{C_{ij}(t+"+str(_emSep)+r")}{C_{ij}(t)}$",
**kwargs[key]),fontsize=40)
plt.xticks(plt.xticks()[0],fontsize=24)
plt.yticks(plt.yticks()[0],fontsize=24)
else:
ax.set_xlabel(r'$t$')
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}\,log\frac{C(t+"+str(_emSep)+r")}{C(t)}$",**kwargs[key]))
for item in ([ax.xaxis.label,ax.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",20,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
save_dir = utp.get_option("em_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("em_save_name","emplot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_effective_mass(event,idx=_emIdx):
#print('press_effective_mass', event.key)
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _emNMod
do_plot_corr_effective_mass(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _emNMod
do_plot_corr_effective_mass(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _emNMod
do_plot_corr_effective_mass(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("em_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("em_save_name","emplot-"+key+".png",**kwargs[key])
do_plot_corr_effective_mass([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_corr_effective_mass(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_effective_mass)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
## -- parameters used in fitting
## default = 2
_emSep = utp.get_option("meff_sep",2,**kwargs[key])
## default = smallest t not included in fit
_emFitMin = utp.get_option("meff_fit_min",model.tfit[-1]+1,**kwargs[key])
## default = midpoint - sep
_emFitMax = utp.get_option("meff_fit_max",
model.tdata[-1]/2-_emSep-int(model.tdata[-1]/12),**kwargs[key])
_emTData = model.tdata
_emTFit = range(_emFitMin,_emFitMax)
_emTFit = np.append(_emTFit,list(sorted([len(_emTData) - t for t in _emTFit])))
if not(fit is None) and (len(req[0]) > 0 or len(req[1]) > 0):
_emSubFcn = utp.mask_fit_fcn(model,fit,req,invert=False)
_emSub = np.array(_emSubFcn(np.array(_emTData)))
else:
_emSub = 0
_emDataFold = utf.fold_data(data[key]-_emSub,(model.tp < 0))
#_emTDataNonZero = [t for t in _emTData if np.abs(gv.mean(data[key])[t]) > 1e-20]
#_emTDataNonZero = [t for t in range(len(_emDataFold)) if np.mean(_emDataFold[t]) > 1e-20]
#
## -- data
_emRatio = np.array(_emDataFold[_emSep:])/np.array(_emDataFold[:-_emSep])
_emTDataRatio = np.array(range(len(_emRatio)))
_emTDataNonZero = np.array([t for t in range(len(_emRatio)) if _emRatio[t] > 1e-20])
#_emRatio = np.array([-gv.log(x)/_emSep for x in _emRatio if x > 1e-20])
#_emTDataRatio =\
# [t for t in _emTData
# if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
#_emTDataRatio = np.append(_emTDataRatio,
# [t for t in _emTData
# if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
#_emRatio =\
# [data[key][t+_emSep]/data[key][t] for t in _emTData
# if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
#_emRatio = np.append(_emRatio,
# [data[key][t-_emSep]/data[key][t] for t in _emTData
# if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
## -- times
_emTPosRatio.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emTPosFit.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio))
if _emRatio[t] > 0 and _emTDataRatio[t] in _emTFit] )
## -- ratios
_emLogRatio.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emLogRatioFit.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio))
if (gv.mean(_emRatio[t]) > 0) and (_emTDataRatio[t] in _emTPosFit[-1])] )
_emFoldRatio.append(_emLogRatio[-1])
_emFoldRatioFit.append(_emLogRatioFit[-1])
_emTPosFold.append(_emTPosRatio[-1])
_emTPosFoldFit.append(_emTPosFit[-1])
## -- folding
#_emFoldRatio.append(list())
#_emFoldRatioFit.append(list())
#_emTPosFold.append(list())
#_emTPosFoldFit.append(list())
#for t in range(1,len(_emTData)/2):
# if not(t in _emTPosRatio[-1]) or not(len(_emTData)-t in _emTPosRatio[-1]):
# continue
# _emFoldRatio[-1].append((_emLogRatio[-1][list(_emTPosRatio[-1]).index(t)]
# +_emLogRatio[-1][list(_emTPosRatio[-1]).index(len(_emTData)-t)])/2)
# _emTPosFold[-1].append(t)
# if not(t in _emTPosFit[-1]) or not(len(_emTData)-t in _emTPosFit[-1]):
# continue
# _emFoldRatioFit[-1].append((_emLogRatio[-1][list(_emTPosRatio[-1]).index(t)]
# +_emLogRatio[-1][list(_emTPosRatio[-1]).index(len(_emTData)-t)])/2)
# _emTPosFoldFit[-1].append(t)
#for t in range(len(_emTPosFold[-1])):
# print t,_emTPosFold[-1][t],_emFoldRatio[-1][t]
#for t in range(len(_emTPosFoldFit[-1])):
# print t,_emTPosFoldFit[-1][t],_emFoldRatioFit[-1][t]
_emLogRatioCentral.append(gv.mean(_emLogRatio[-1]))
_emLogRatioError.append([ list(gv.sdev(_emLogRatio[-1])), list(gv.sdev(_emLogRatio[-1])) ])
_emFoldRatioCentral.append(gv.mean(_emFoldRatio[-1]))
_emFoldRatioError.append([ list(gv.sdev(_emFoldRatio[-1])), list(gv.sdev(_emFoldRatio[-1])) ])
## -- fit
_emRatioFit.append(lsq.wavg(_emLogRatioFit[-1]))
if utp.get_option("meff_do_fold",False,**kwargs[key]):
_emFitCentral.append([gv.mean(_emRatioFit[-1]) for t in _emTPosFit[-1] if t < len(_emTData)/2])
_emFitError.append(
[list(np.array(_emFitCentral[-1])-np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1] if t < len(_emTData)/2])),
list(np.array(_emFitCentral[-1])+np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1] if t < len(_emTData)/2]))])
else:
_emFitCentral.append([gv.mean(_emRatioFit[-1]) for t in _emTPosFit[-1]])
_emFitError.append(
[list(np.array(_emFitCentral[-1])-np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1]])),
list(np.array(_emFitCentral[-1])+np.array([gv.sdev(_emRatioFit[-1])
for t in _emTPosFit[-1]]))])
print "Best plateau fits: "
for key,rfit in zip([model.datatag for model in models],_emRatioFit):
print " ",key," : ",rfit
print " ----------------- "
_emRatioFitNonZero = [x for x in _emRatioFit if not(x is None)]
print " avg : ",lsq.wavg(_emRatioFitNonZero)
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_corr_effective_mass([ix])
else:
do_plot_corr_effective_mass(_emIdx)
if df.do_sn_minimize:
defm = {}
for key in dall:
if 't' in key:
continue
tlen = len(dall[key])
#if dall[key][2]/dall[key][0] > 0.\
#and dall[key][tlen-2]/dall[key][0] > 0.:
# defm[key] = [-gv.log(dall[key][2]/dall[key][0])/2.+gv.log(dall[key][tlen-2]/dall[key][0])/2.]
#else:
# defm[key] = [gv.gvar(1e-8,1e-6)]
defm[key] = [] ## -- skip the first
for t in range(1,tlen/2-2):
if dall[key][t+2]/dall[key][t] > 0.\
and dall[key][tlen-t-2]/dall[key][tlen-t] > 0.:
defm[key].append(-gv.log(dall[key][t+2]/dall[key][t])/4.
-gv.log(dall[key][tlen-t-2]/dall[key][tlen-t])/4.)
else:
defm[key].append(gv.gvar(1e-8,1e-8)) ## -- add garbage value, > 0
#defm[key].append(-gv.log(dall[key][tlen/2]/dall[key][tlen/2-2])/2.
# -gv.log(dall[key][tlen/2]/dall[key][tlen/2+2])/2.)
#print defm[key]
#raise ValueError("test")
cvec,kvec,_ = sn_minimize_postload(defm,df.rangeMax)
clist = list()
klist = list()
for key in dall:
if 't' in key:
continue
## -- deconstruct key based on current conventions
k = int(key[-1])
def build_prior(nexp):
prior = gv.BufferDict()
prior.add('log(a1:vec:s)', [log(gv.gvar(1, 1)) for i in range(nexp)])
prior['log(a1:vec:s)'][0] = log(gv.gvar(0.5, 1))
prior.add('log(ao:vec:s)', [log(gv.gvar(1, 1)) for i in range(nexp)])
prior['log(ao:vec:s)'][0] = log(gv.gvar(0.5, 1))
#prior.add('as1:etac',[gv.gvar(0.001,0.01) for i in range(nexp)])
prior.add('log(dE:vec:s)', [log(gv.gvar(2, 2)) for i in range(nexp)])
prior['log(dE:vec:s)'][0] = log(gv.gvar(1, 1))
prior.add('log(dEo:vec:s)', [log(gv.gvar(1, 1)) for i in range(nexp)])
prior['log(dEo:vec:s)'][0] = log(gv.gvar(1, 1))
#prior['logdE:etac'][0] = log(gv.gvar(0.1,0.05))
prior.add('log(a1:vec:qed:s)', [log(gv.gvar(1, 1)) for i in range(nexp)])
prior['log(a1:vec:qed:s)'][0] = log(gv.gvar(0.5, 1))
prior.add('log(ao:vec:qed:s)', [log(gv.gvar(1, 1)) for i in range(nexp)])
prior['log(ao:vec:qed:s)'][0] = log(gv.gvar(0.5, 1))
#prior.add('as1:etac',[gv.gvar(0.001,0.01) for i in range(nexp)])
prior.add('log(dE:vec:qed:s)', [log(gv.gvar(2, 2)) for i in range(nexp)])
prior['log(dE:vec:qed:s)'][0] = log(gv.gvar(1, 1))
prior.add('log(dEo:vec:qed:s)', [log(gv.gvar(1, 1)) for i in range(nexp)])
prior['log(dEo:vec:qed:s)'][0] = log(gv.gvar(1, 1))
return prior
def make_prior(N):
""" Create prior for N-state fit. """
prior = collections.OrderedDict()
prior['a'] = gv.gvar(N * ['0(1)'])
prior['logdE'] = gv.log(gv.gvar(N * ['0.5(5)']))
return prior
def plot_corr_effective_mass_check(models,data,fit=None,**kwargs):
"""
Get all data ready so that it can be plotted on command
Allows for dynamic cycling through plots
"""
_emNMod = len(models)
_emIdx = [0] ## -- index of plotted function, in array so it can be modified in functions
## -- objects to hold all plot data
## - Dat/Fit refers to the correlator data or the fit function
## - Central/Error are the central value and errors
_emLogRatio = []
_emLogRatioCentral = []
_emLogRatioError = []
_emLogRatioFit = []
_emRatioFit = []
_emRatioFitNonZero = []
_emFitCentral = []
_emFitError = []
## -- timeslice objects
_emTPosRatio = []
_emTPosFit = []
#
## -- fitting options
_emFitMin = 0
_emFitMax = 0
_emSep = 0
fig,ax = plt.subplots(1)
#
## -- setup plot function
def do_plot_corr_effective_mass_check(idx,fig=fig):
fig.clear()
ax = fig.add_subplot(111)
key = models[idx[0]].datatag
ax.set_ylim(utp.get_option("y_limit",[0.0,1.2],**kwargs[key]))
#
## -- plot fit
ax.plot(_emTPosFit[idx[0]],_emFitCentral[idx[0]],
color=utp.get_option("color3",'b',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][0],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
ax.plot(_emTPosFit[idx[0]],_emFitError[idx[0]][1],
color=utp.get_option("color3",'b',**kwargs[key]),
ls=utp.get_option("linestyle2",'--',**kwargs[key]))
## -- plot reference
for val in df.ec_reference_lines:
vt = [val for t in _emTPosFit[idx[0]]]
ax.plot(_emTPosFit[idx[0]],vt,
color=utp.get_option("color2",'g',**kwargs[key]))
# -- plot correlator data
ax.errorbar(_emTPosRatio[idx[0]],_emLogRatioCentral[idx[0]],yerr=_emLogRatioError[idx[0]],
mfc=utp.get_option("markerfacecolor1",'None',**kwargs[key]),
mec=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
color=utp.get_option("markeredgecolor1",'k',**kwargs[key]),
ls=utp.get_option("linestyle1",'None',**kwargs[key]),
marker=utp.get_option("marker1",'o',**kwargs[key]),
ms=utp.get_option("markersize",6,**kwargs[key]))
ax.scatter(_emTPosFit[idx[0]],gv.mean(_emLogRatioFit[idx[0]]),
color=utp.get_option("color1",'r',**kwargs[key]),
marker=utp.get_option("marker",'o',**kwargs[key]),
s=utp.get_option("markersize",36,**kwargs[key]))
fig.suptitle(utp.get_option("plottitle",str(idx[0])+" default title "+str(key),**kwargs[key]),
fontsize=utp.get_option("titlesize",20,**kwargs[key]))
# -- modify some options
ax.set_xlabel(r'$t$ slice')
ax.set_ylabel(utp.get_option("yaxistitle",
r"$-\frac{1}{"+str(_emSep)+r"}\,log\frac{C(t+"+str(_emSep)+r")}{C(t)}$",**kwargs[key]))
for item in ([ax.xaxis.label,ax.yaxis.label]):
# must be after setting label content (LaTeX ruins it)
item.set_fontsize(fontsize=utp.get_option("fontsize",20,**kwargs[key]))
rect =fig.patch
rect.set_facecolor('white')
if utp.get_option("to_file",False,**kwargs[key]):
save_dir = utp.get_option("ec_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("ec_save_name","ecplot-"+key+".pdf",**kwargs[key])
plt.savefig(save_dir+'/'+save_name)
if utp.get_option("to_terminal",True,**kwargs[key]):
plt.draw()
pass
#
## -- setup button press action function
def press_effective_mass(event,idx=_emIdx):
#print('press_effective_mass', event.key)
try:
## -- manually indicate index
idx[0] = int(event.key) + (idx[0])*10
except ValueError:
if event.key==' ': ## -- space
## -- allows for replotting when changing index by typing number keys
idx[0] = idx[0] % _emNMod
do_plot_corr_effective_mass_check(idx)
elif event.key=='left':
idx[0] = (idx[0] - 1) % _emNMod
do_plot_corr_effective_mass_check(idx)
elif event.key=='right':
idx[0] = (idx[0] + 1) % _emNMod
do_plot_corr_effective_mass_check(idx)
elif event.key=='backspace':
## -- reset index so can manually flip through using number keys
idx[0] = 0
elif event.key=='d':
## -- dump plots into ./plotdump directory
for ix,model in zip(range(len(models)),models):
key = model.datatag
save_dir = utp.get_option("ec_save_dir","./plotdump",**kwargs[key])
save_name = utp.get_option("ec_save_name","ecplot-"+key+".png",**kwargs[key])
do_plot_corr_effective_mass_check([ix])
plt.savefig(save_dir+'/'+save_name)
do_plot_corr_effective_mass_check(idx)
#
## --
fig.canvas.mpl_connect('key_press_event',press_effective_mass)
## -- save plot data
for idx,model in zip(range(len(models)),models):
key = model.datatag
## -- parameters used in fitting
## default = 2
_emSep = utp.get_option("meff_sep",2,**kwargs[key])
## default = smallest t not included in fit
_emFitMin = utp.get_option("meff_fit_min",model.tfit[-1]+1,**kwargs[key])
## default = midpoint - sep
_emFitMax = utp.get_option("meff_fit_max",
model.tdata[-1]/2-_emSep-int(model.tdata[-1]/12),**kwargs[key])
_emTData = model.tdata
_emTFit = range(_emFitMin,_emFitMax)
_emTFit = np.append(_emTFit,list(sorted([len(_emTData) - t for t in _emTFit])))
_emTDataNonZero = [t for t in _emTData if np.abs(gv.mean(data[key])[t]) > 1e-20]
#
## -- data
_emTDataRatio =\
[t for t in _emTData
if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
_emTDataRatio = np.append(_emTDataRatio,
[t for t in _emTData
if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
_emRatio =\
[data[key][t+_emSep]/data[key][t] for t in _emTData
if (t in _emTDataNonZero) and (t <= _emTData[-1]/2 +1 - _emSep) ] # first half
_emRatio = np.append(_emRatio,
[data[key][t-_emSep]/data[key][t] for t in _emTData
if (t in _emTDataNonZero) and (t >= _emTData[-1]/2 +1 + _emSep) ] ) # second half
_emTPosRatio.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emTPosFit.append(
[_emTDataRatio[t] for t in range(len(_emTDataRatio))
if _emRatio[t] > 0 and _emTDataRatio[t] in _emTFit] )
_emLogRatio.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio)) if _emRatio[t] > 0] )
_emLogRatioFit.append(
[-gv.log(_emRatio[t])/_emSep for t in range(len(_emTDataRatio))
if (gv.mean(_emRatio[t]) > 0) and (_emTDataRatio[t] in _emTPosFit[-1])] )
_emLogRatioCentral.append(gv.mean(_emLogRatio[-1]))
_emLogRatioError.append([ list(gv.sdev(_emLogRatio[-1])), list(gv.sdev(_emLogRatio[-1])) ])
## -- fit
_emRatioFit.append(lsq.wavg(_emLogRatioFit[-1]))
_emFitCentral.append([gv.mean(_emRatioFit[-1]) for t in _emTPosFit[-1]])
_emFitError.append(
[list(np.array(_emFitCentral[-1])-np.array([gv.sdev(_emRatioFit[-1]) for t in _emTPosFit[-1]])),
list(np.array(_emFitCentral[-1])+np.array([gv.sdev(_emRatioFit[-1]) for t in _emTPosFit[-1]]))]
)
print "Best plateau fits: "
for key,rfit in zip([model.datatag for model in models],_emRatioFit):
print " ",key," : ",rfit
print " ----------------- "
_emRatioFitNonZero = [x for x in _emRatioFit if not(x is None)]
print " avg : ",lsq.wavg(_emRatioFitNonZero)
## -- done saving data
if not(utp.get_option("to_terminal",True,**kwargs[key])) and\
utp.get_option("to_file",False,**kwargs[key]):
for ix in range(len(models)):
## -- loops and saves all without creating window
do_plot_corr_effective_mass_check([ix])
else:
do_plot_corr_effective_mass_check(_emIdx)
# linestyle='none',
# color='black',
# )
#plt.plot(*exact, linestyle='none', marker='.')
#plt.title("Exact ellipse and data points")
#plt.xlim(6.5, 13.5)
#plt.ylim(10.5, 13.5)
#print("Looking at that figure, we come up with...")
banner("PRIORS")
priors = {
'x0': gv.gvar('10(3)'),
'y0': gv.gvar('12(2)'),
'phi': gv.gvar('0(0.78)'),
'log(a-b)': gv.log(gv.gvar('2(2)')),
'b': gv.gvar('2(2)'),
}
for p in priors:
print(f"{p} = {priors[p]}")
banner("METHOD")
print("\nWe're hoping to find the best-fit ellipse. We should think of both the X and Y points as input and demand that they satisfy the constraint")
print("\n [ (x-x0) * cos phi + (y-y0)* sin phi ]^2 / a^2 + [ (x-x0) * sin phi - (y-y0) * cos phi ]^2 / b^2 == 1\n")
print("So... what do we take as the 'data' to fit? We should rewrite the constraint as a level curve,")
print("\n g(x, y) = [ (x-x0) * cos phi + (y-y0)* sin phi ]^2 / a^2 + [ (x-x0) * sin phi - (y-y0) * cos phi ]^2 / b^2 - 1\n")
print("and the ellipse is when g(x,y) = 0.")
