Esempio n. 1
0
def fit_proton(pr, p_avg, T):
    # priors
    priors = c51.dict_of_tuple_to_gvar(pr.priors['proton'])
    # trange
    trange = pr.trange['proton']
    # make data
    # ss + ps
    p_data = np.concatenate((p_avg[:,:,0,0], p_avg[:,:,3,0]), axis=1)
    # ss
    #p_data = p_avg[:,:,0,0]
    # ps
    #p_data = p_avg[:,:,3,0]
    p_data = c51.make_gvars(p_data)
    # fit
    grandfit = dict()
    for n in range(2,3):
        fitfcn = c51.fit_function(T, nstates=n)
        # ss + ps
        fit = c51.fitscript_v2(trange, T, p_data, priors, fitfcn.twopt_fitfcn_ss_ps, pr.print_fit_flag)
        # ss
        #fit = c51.fitscript_v2(trange, T, p_data, priors, fitfcn.twopt_fitfcn_ss, pr.print_fit_flag)
        # ps
        #fit = c51.fitscript_v2(trange, T, p_data, priors, fitfcn.twopt_fitfcn_ps, pr.print_fit_flag)
        for k in fit.keys():
            try:
                grandfit[k] = np.concatenate((grandfit[k], fit[k]), axis=0)
            except:
                grandfit[k] = fit[k]
        try:
            grandfit['nstates'] = np.concatenate((grandfit['nstates'], n*np.ones(len(fit[k]))), axis=0)
        except:
            grandfit['nstates'] = n*np.ones(len(fit[k]))
    return np.array([[0, grandfit]])
Esempio n. 2
0
def fit_proton(pr, p_avg, T):
    # priors
    priors = c51.dict_of_tuple_to_gvar(pr.priors['proton'])
    # trange
    trange = pr.trange['proton']
    # make data
    # ss + ps
    p_data = np.concatenate((p_avg[:, :, 0, 0], p_avg[:, :, 3, 0]), axis=1)
    # ss
    #p_data = p_avg[:,:,0,0]
    # ps
    #p_data = p_avg[:,:,3,0]
    p_data = c51.make_gvars(p_data)
    # fit
    grandfit = dict()
    for n in range(2, 3):
        fitfcn = c51.fit_function(T, nstates=n)
        # ss + ps
        fit = c51.fitscript_v2(trange, T, p_data, priors,
                               fitfcn.twopt_fitfcn_ss_ps, pr.print_fit_flag)
        # ss
        #fit = c51.fitscript_v2(trange, T, p_data, priors, fitfcn.twopt_fitfcn_ss, pr.print_fit_flag)
        # ps
        #fit = c51.fitscript_v2(trange, T, p_data, priors, fitfcn.twopt_fitfcn_ps, pr.print_fit_flag)
        for k in fit.keys():
            try:
                grandfit[k] = np.concatenate((grandfit[k], fit[k]), axis=0)
            except:
                grandfit[k] = fit[k]
        try:
            grandfit['nstates'] = np.concatenate(
                (grandfit['nstates'], n * np.ones(len(fit[k]))), axis=0)
        except:
            grandfit['nstates'] = n * np.ones(len(fit[k]))
    return np.array([[0, grandfit]])
Esempio n. 3
0
def decay_bs(params, meson, draws):
    print 'decay ', meson
    ens = params.ens
    ml = params.ml
    ms = params.ms
    loc = params.data_loc
    # read data
    decay_dat = c51.fold(c51.open_data(loc['file_loc'], loc['spec_'+meson]))
    decay_ss = np.squeeze(decay_dat[:,:,0,:])
    decay_ps = np.squeeze(decay_dat[:,:,1,:])
    T = 2*len(decay_ss[0])
    if params.plot_data_flag == 'on':
        # unfolded correlator data
        c51.scatter_plot(np.arange(len(decay_ss[0])), c51.make_gvars(decay_ss), meson+' ss folded')
        c51.scatter_plot(np.arange(len(decay_ps[0])), c51.make_gvars(decay_ps), meson+' ps folded')
        # effective mass
        eff = c51.effective_plots(T)
        meff_ss = eff.effective_mass(c51.make_gvars(decay_ss), 1, 'cosh')
        meff_ps = eff.effective_mass(c51.make_gvars(decay_ps), 1, 'cosh')
        xlim = [3, len(meff_ss)-2]
        ylim = c51.find_yrange(meff_ss, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(meff_ss)), meff_ss, meson+' ss effective mass', xlim = xlim, ylim = ylim)
        ylim = c51.find_yrange(meff_ps, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(meff_ps)), meff_ps, meson+' ps effective mass', xlim = xlim, ylim = ylim)
        # scaled correlator
        E0 = params.priors[meson]['E0'][0]
        scaled_ss = eff.scaled_correlator(c51.make_gvars(decay_ss), E0, phase=1.0)
        scaled_ps = eff.scaled_correlator(c51.make_gvars(decay_ps), E0, phase=1.0)
        ylim = c51.find_yrange(scaled_ss, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(scaled_ss)), scaled_ss, meson+' ss scaled correlator (take sqrt to get Z0_s)', xlim = xlim, ylim = ylim)
        ylim = c51.find_yrange(scaled_ps, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(scaled_ps)), scaled_ps, meson+' ps scaled correlator (divide by Z0_s to get Z0_p)', xlim = xlim, ylim = ylim)
        plt.show()
    # concatenate data
    decay_ss_ps = np.concatenate((decay_ss, decay_ps), axis=1)
    # priors
    priors = params.priors[meson]
    # read trange
    trange = params.trange['twopt']
    #Fit
    #args = ((g, trange, T, decay_ss_ps, priors, draws) for g in range(len(draws)))
    #pool = multi.Pool()
    #p = pool.map_async(decay_fit, args)
    ## sort via bootstrap number
    #output = np.sort(np.array(p.get()), axis=0)
    result = []
    for g in range(len(draws)):
        # resample decay data
        decay_bs = decay_ss_ps[draws[g]]
        decay_bs = c51.make_gvars(decay_bs)
        # priors
        bsp = c51.dict_of_tuple_to_gvar(priors)
        #Fit
        fitfcn = c51.fit_function(T, nstates=2)
        fit = c51.fitscript_v2(trange, T, decay_bs, bsp, fitfcn.twopt_fitfcn_ss_ps, result_flag='off')
        fit = [g, fit]
        result.append(fit)
    output = np.sort(np.array(result), axis=0)
    return output
Esempio n. 4
0
def decay_axial_fit(args):
    g, trange, T, decay_axial_ss, priors, draws = args
    # resample
    decay_axial_ss = c51.make_gvars(decay_axial_ss[draws[g]])
    # make priors
    bsp = c51.dict_of_tuple_to_gvar(priors)
    # fit
    fitfcn = c51.fit_function(T, nstates=2)
    fit = c51.fitscript_v2(trange, T, decay_axial_ss, bsp, fitfcn.axial_twoptss_fitfcn, result_flag='off')
    # record nbs
    fit = [g, fit]
    return fit 
Esempio n. 5
0
def decay_fit(args):
    g, trange, T, decay_ss_sp_dat, priors, draws = args
    # resample decay data
    decay_bs = decay_ss_sp_dat[draws[g]]
    decay_bs = c51.make_gvars(decay_bs)
    # priors
    bsp = c51.dict_of_tuple_to_gvar(priors)
    #Fit
    fitfcn = c51.fit_function(T, nstates=2)
    fit = c51.fitscript_v2(trange, T, decay_bs, bsp, fitfcn.twopt_fitfcn_ss_ps, result_flag='off')
    fit = [g, fit]
    return fit
Esempio n. 6
0
def fittwo_pt(params, twopt_dat, T):
    # make data
    twopt_gv = c51.make_gvars(twopt_dat)
    # priors
    priors = params.priors[params.hadron]
    priors_gv = c51.dict_of_tuple_to_gvar(priors)
    # read trange
    trange = params.trange['twopt']
    # fit
    fitfcn = c51.fit_function(T, nstates=1)
    fit = c51.fitscript_v2(trange, T, twopt_gv, priors_gv, fitfcn.twopt_fitfcn_phiqq, params.print_fit_flag)
    return np.array([[0, fit]])
Esempio n. 7
0
def fit_proton(pr, p_avg, T):
    # priors
    priors = c51.dict_of_tuple_to_gvar(pr.priors['proton'])
    # trange
    trange = pr.trange['proton']
    # make data
    p_data = np.concatenate((p_avg[:,:,0,0], p_avg[:,:,3,0]), axis=1)
    p_data = c51.make_gvars(p_data)
    # fit
    fitfcn = c51.fit_function(T, nstates=6)
    fit = c51.fitscript_v2(trange, T, p_data, priors, fitfcn.twopt_fitfcn_ss_ps, pr.print_fit_flag)
    return np.array([[0, fit]])
Esempio n. 8
0
def mres_fit(args):
    g, trange, T, mres_dat, prior, draws = args
    print g
    #Resample mres data
    mres_dat_bs = mres_dat[draws[g]]
    mres_dat_bs = c51.make_gvars(mres_dat_bs)
    print 'bs'
    #Randomize priors
    bsp = c51.dict_of_tuple_to_gvar(prior) #{'mres': gv.gvar(prior[0]+prior[1]*np.random.randn(), prior[1])}
    #Fit
    fitfcn = c51.fit_function(T)
    fit = c51.fitscript_v2(trange, T, mres_dat_bs, bsp, fitfcn.mres_fitfcn, result_flag='off')
    result = [g, fit]
    return result
Esempio n. 9
0
def mres_fit(args):
    g, trange, T, mres_dat, prior, draws = args
    #Resample mres data
    mres_dat_bs = mres_dat[draws[g]]
    #mres_dat_bs = c51.make_gvars(mres_dat_bs)
    mres_mean = np.average(mres_dat_bs, axis=0)
    mres_sdev = np.std(mres_dat_bs, axis=0)
    mres_dat_bs = gv.gvar(mres_mean, mres_sdev)
    #Randomize priors
    bsp = c51.dict_of_tuple_to_gvar(prior) #{'mres': gv.gvar(prior[0]+prior[1]*np.random.randn(), prior[1])}
    #Fit
    fitfcn = c51.fit_function(T)
    fit = c51.fitscript_v2(trange, T, mres_dat_bs, bsp, fitfcn.mres_fitfcn, result_flag='off')
    result = [g, fit]
    return result
Esempio n. 10
0
def decay_axial_fit(args):
    g, trange, T, decay_axial_ss, priors, draws = args
    # resample
    decay_axial_ss = c51.make_gvars(decay_axial_ss[draws[g]])
    # make priors
    bsp = c51.dict_of_tuple_to_gvar(priors)
    # fit
    fitfcn = c51.fit_function(T, nstates=2)
    fit = c51.fitscript_v2(trange,
                           T,
                           decay_axial_ss,
                           bsp,
                           fitfcn.axial_twoptss_fitfcn,
                           result_flag='off')
    # record nbs
    fit = [g, fit]
    return fit
Esempio n. 11
0
def decay_fit(args):
    g, trange, T, decay_ss_sp_dat, priors, draws = args
    # resample decay data
    decay_bs = decay_ss_sp_dat[draws[g]]
    decay_bs = c51.make_gvars(decay_bs)
    # priors
    bsp = c51.dict_of_tuple_to_gvar(priors)
    #Fit
    fitfcn = c51.fit_function(T, nstates=2)
    fit = c51.fitscript_v2(trange,
                           T,
                           decay_bs,
                           bsp,
                           fitfcn.twopt_fitfcn_ss_ps,
                           result_flag='off')
    fit = [g, fit]
    return fit
Esempio n. 12
0
def mres_bs(params, meson, draws):
    print 'mres', meson
    ens = params.ens
    ml = params.ml
    ms = params.ms
    loc = params.data_loc
    #Read data
    mp = c51.open_data(loc['file_loc'], loc['mres_' + meson + '_mp'])
    pp = c51.open_data(loc['file_loc'], loc['mres_' + meson + '_pp'])
    T = len(pp[0])
    mres_dat = mp / pp
    # plot mres
    if params.plot_data_flag == 'on':
        c51.scatter_plot(np.arange(len(mres_dat[0])), c51.make_gvars(mres_dat),
                         meson + ' mres')
        plt.show()
    #Read priors
    prior = params.priors[meson]
    #Read trange
    trange = params.trange['mres']
    #Fit
    #args = ((g, trange, T, mres_dat, prior, draws) for g in range(len(draws)))
    #pool = multi.Pool()
    #p = pool.map_async(mres_fit, args)
    # sort by bootstrap number
    #output = np.sort(np.array(p.get()), axis=0)
    result = []
    for g in range(len(draws)):
        mres_dat_bs = mres_dat[draws[g]]
        mres_dat_bs = c51.make_gvars(mres_dat_bs)
        #Randomize priors
        bsp = c51.dict_of_tuple_to_gvar(
            prior
        )  #{'mres': gv.gvar(prior[0]+prior[1]*np.random.randn(), prior[1])}
        #Fit
        fitfcn = c51.fit_function(T)
        fit = c51.fitscript_v2(trange,
                               T,
                               mres_dat_bs,
                               bsp,
                               fitfcn.mres_fitfcn,
                               result_flag='off')
        result.append([g, fit])
    output = np.sort(np.array(result), axis=0)
    return output
Esempio n. 13
0
def mres_fit(args):
    g, trange, T, mres_dat, prior, draws = args
    print g
    #Resample mres data
    mres_dat_bs = mres_dat[draws[g]]
    mres_dat_bs = c51.make_gvars(mres_dat_bs)
    print 'bs'
    #Randomize priors
    bsp = c51.dict_of_tuple_to_gvar(
        prior
    )  #{'mres': gv.gvar(prior[0]+prior[1]*np.random.randn(), prior[1])}
    #Fit
    fitfcn = c51.fit_function(T)
    fit = c51.fitscript_v2(trange,
                           T,
                           mres_dat_bs,
                           bsp,
                           fitfcn.mres_fitfcn,
                           result_flag='off')
    result = [g, fit]
    return result
Esempio n. 14
0
def mres_fit(args):
    g, trange, T, mres_dat, prior, draws = args
    #Resample mres data
    mres_dat_bs = mres_dat[draws[g]]
    #mres_dat_bs = c51.make_gvars(mres_dat_bs)
    mres_mean = np.average(mres_dat_bs, axis=0)
    mres_sdev = np.std(mres_dat_bs, axis=0)
    mres_dat_bs = gv.gvar(mres_mean, mres_sdev)
    #Randomize priors
    bsp = c51.dict_of_tuple_to_gvar(
        prior
    )  #{'mres': gv.gvar(prior[0]+prior[1]*np.random.randn(), prior[1])}
    #Fit
    fitfcn = c51.fit_function(T)
    fit = c51.fitscript_v2(trange,
                           T,
                           mres_dat_bs,
                           bsp,
                           fitfcn.mres_fitfcn,
                           result_flag='off')
    result = [g, fit]
    return result
Esempio n. 15
0
def mres_bs(params, meson, draws):
    print 'mres', meson
    ens = params.ens
    ml = params.ml
    ms = params.ms
    loc = params.data_loc
    #Read data
    mp = c51.open_data(loc['file_loc'], loc['mres_'+meson+'_mp'])
    pp = c51.open_data(loc['file_loc'], loc['mres_'+meson+'_pp'])
    T = len(pp[0])
    mres_dat = mp/pp
    # plot mres
    if params.plot_data_flag == 'on':
        c51.scatter_plot(np.arange(len(mres_dat[0])), c51.make_gvars(mres_dat), meson+' mres')
        plt.show()
    #Read priors
    prior = params.priors[meson]
    #Read trange
    trange = params.trange['mres']
    #Fit
    #args = ((g, trange, T, mres_dat, prior, draws) for g in range(len(draws)))
    #pool = multi.Pool()
    #p = pool.map_async(mres_fit, args)
    # sort by bootstrap number
    #output = np.sort(np.array(p.get()), axis=0)
    result = []
    for g in range(len(draws)):
        mres_dat_bs = mres_dat[draws[g]]
        mres_dat_bs = c51.make_gvars(mres_dat_bs)
        #Randomize priors
        bsp = c51.dict_of_tuple_to_gvar(prior) #{'mres': gv.gvar(prior[0]+prior[1]*np.random.randn(), prior[1])}
        #Fit
        fitfcn = c51.fit_function(T)
        fit = c51.fitscript_v2(trange, T, mres_dat_bs, bsp, fitfcn.mres_fitfcn, result_flag='off')
        result.append([g, fit])
    output = np.sort(np.array(result), axis=0)
    return output
Esempio n. 16
0
def decay_bs(params, meson, draws):
    print 'decay ', meson
    ens = params.ens
    ml = params.ml
    ms = params.ms
    loc = params.data_loc
    # read data
    decay_dat = c51.fold(c51.open_data(loc['file_loc'], loc['spec_' + meson]))
    decay_ss = np.squeeze(decay_dat[:, :, 0, :])
    decay_ps = np.squeeze(decay_dat[:, :, 1, :])
    T = 2 * len(decay_ss[0])
    if params.plot_data_flag == 'on':
        # unfolded correlator data
        c51.scatter_plot(np.arange(len(decay_ss[0])), c51.make_gvars(decay_ss),
                         meson + ' ss folded')
        c51.scatter_plot(np.arange(len(decay_ps[0])), c51.make_gvars(decay_ps),
                         meson + ' ps folded')
        # effective mass
        eff = c51.effective_plots(T)
        meff_ss = eff.effective_mass(c51.make_gvars(decay_ss), 1, 'cosh')
        meff_ps = eff.effective_mass(c51.make_gvars(decay_ps), 1, 'cosh')
        xlim = [3, len(meff_ss) - 2]
        ylim = c51.find_yrange(meff_ss, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(meff_ss)),
                         meff_ss,
                         meson + ' ss effective mass',
                         xlim=xlim,
                         ylim=ylim)
        ylim = c51.find_yrange(meff_ps, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(meff_ps)),
                         meff_ps,
                         meson + ' ps effective mass',
                         xlim=xlim,
                         ylim=ylim)
        # scaled correlator
        E0 = params.priors[meson]['E0'][0]
        scaled_ss = eff.scaled_correlator(c51.make_gvars(decay_ss),
                                          E0,
                                          phase=1.0)
        scaled_ps = eff.scaled_correlator(c51.make_gvars(decay_ps),
                                          E0,
                                          phase=1.0)
        ylim = c51.find_yrange(scaled_ss, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(scaled_ss)),
                         scaled_ss,
                         meson +
                         ' ss scaled correlator (take sqrt to get Z0_s)',
                         xlim=xlim,
                         ylim=ylim)
        ylim = c51.find_yrange(scaled_ps, xlim[0], xlim[1])
        c51.scatter_plot(np.arange(len(scaled_ps)),
                         scaled_ps,
                         meson +
                         ' ps scaled correlator (divide by Z0_s to get Z0_p)',
                         xlim=xlim,
                         ylim=ylim)
        plt.show()
    # concatenate data
    decay_ss_ps = np.concatenate((decay_ss, decay_ps), axis=1)
    # priors
    priors = params.priors[meson]
    # read trange
    trange = params.trange['twopt']
    #Fit
    #args = ((g, trange, T, decay_ss_ps, priors, draws) for g in range(len(draws)))
    #pool = multi.Pool()
    #p = pool.map_async(decay_fit, args)
    ## sort via bootstrap number
    #output = np.sort(np.array(p.get()), axis=0)
    result = []
    for g in range(len(draws)):
        # resample decay data
        decay_bs = decay_ss_ps[draws[g]]
        decay_bs = c51.make_gvars(decay_bs)
        # priors
        bsp = c51.dict_of_tuple_to_gvar(priors)
        #Fit
        fitfcn = c51.fit_function(T, nstates=2)
        fit = c51.fitscript_v2(trange,
                               T,
                               decay_bs,
                               bsp,
                               fitfcn.twopt_fitfcn_ss_ps,
                               result_flag='off')
        fit = [g, fit]
        result.append(fit)
    output = np.sort(np.array(result), axis=0)
    return output