Ejemplo n.º 1
0
    def log_likelihood(cube, ndim, nparams):
        i = np.random.choice(nL)
        #j = np.random.choice(nF)

        L = Lpost[i]
        d = dpost[i]
        #F = Fpost[j]

        # L = 0.380173301412519577E+05
        # d = 0.883628502371783142E+00
        F = 21.0
        vals = forward_model(r,
                             L,
                             d,
                             F,
                             w0,
                             mu,
                             cube[2],
                             cube[0],
                             cube[1],
                             sm_ang=False,
                             nlambda=1024)
        chisq = np.sum((vals - sig)**2 / sig_error**2)

        return -chisq / 2.0
Ejemplo n.º 2
0
def _forward_model(r,
                   Lpost,
                   dpost,
                   Fpost,
                   Apost,
                   Tipost,
                   Vpost,
                   w0,
                   mu,
                   out=None,
                   label=None):
    n = len(Lpost)
    sig = np.zeros((len(r), n))
    for i in range(n):
        sig[:, i] = forward_model(r,
                                  Lpost[i],
                                  dpost[i],
                                  Fpost[i],
                                  w0,
                                  mu,
                                  Apost[i],
                                  Tipost[i],
                                  Vpost[i],
                                  sm_ang=False,
                                  nlambda=1024)

    if out and label:
        out.put((label, sig))
    else:
        return sig
Ejemplo n.º 3
0
    def log_likelihood(cube, ndim, nparams):
        # forward_model(r, L, d, F, w0, mu, amp, temp, v, nlambda=1024, sm_ang=True)
        i = np.random.choice(npost)
        L = Lpost[i]
        d = dpost[i]

        w = w0 + extra_w
        mus = mu + extra_mu
        extra_amp = [cube[1] * x for x in extra_A]
        amp = [cube[2] * cube[1], cube[1]] + extra_amp

        Ti = [0.025 * 1000.0 / 300.0, cube[3]] + extra_Ti
        V = [0.0, 0.0] + extra_V
        vals = forward_model(r,
                             L,
                             d,
                             cube[0],
                             w,
                             mus,
                             amp,
                             Ti,
                             V,
                             sm_ang=False,
                             nlambda=1024)

        #vals = forward_model(r, L, d, cube[0], w0, mu,
        #        [cube[2]*cube[1], cube[1]], [0.025*1000.0/300.0, cube[3]],
        #        [0.0, 0.0], sm_ang=False, nlambda=1024)
        #vals += cube[4]
        chisq = np.sum((vals - sig)**2 / sig_error**2)
        return -chisq / 2.0
Ejemplo n.º 4
0
 def _calculate_model_spectrum(r,
                               L,
                               d,
                               F,
                               w0,
                               mu,
                               amp,
                               temp,
                               v,
                               nlambda=1000):
     signal = forward_model(r,
                            L,
                            d,
                            F,
                            w0,
                            mu,
                            amp,
                            temp,
                            v,
                            nlambda=nlambda)
     return r, signal
Ejemplo n.º 5
0
def _forward_model(r,
                   Lpost,
                   dpost,
                   Fpost,
                   Apost,
                   Arelpost,
                   Tipost,
                   w0,
                   mu,
                   out=None,
                   label=None):
    n = len(Lpost)
    sig = np.zeros((len(r), n))
    w = w0 + extra_w
    mus = mu + extra_mu
    V = [0.0, 0.0] + extra_V
    #vals = forward_model(r, L, d, cube[0], w, mus,
    #        amp, Ti, V, sm_ang=False, nlambda=1024)

    for i in range(n):
        extra_amp = [Apost[i] * x for x in extra_A]
        amp = [Arelpost[i] * Apost[i], Apost[i]] + extra_amp
        Ti = [0.025 * 1000.0 / 300.0, Tipost[i]] + extra_Ti
        sig[:, i] = forward_model(r,
                                  Lpost[i],
                                  dpost[i],
                                  Fpost[i],
                                  w,
                                  mus,
                                  amp,
                                  Ti,
                                  V,
                                  sm_ang=False,
                                  nlambda=1024)
        #sig[:, i] += offsetpost[i]
    if out and label:
        out.put((label, sig))
    else:
        return sig
Ejemplo n.º 6
0
    temps = [1000.0 * 0.025 / 300.0 for x in range(len(amps))]
    vs = [0.0 for x in range(len(amps))]

    w = w0 + extra_w
    mus = mu + extra_mu
    extra_amp = [Amean * x for x in extra_A]
    amp = [Amean * Arelmean, Amean] + extra_amp
    Ti = [0.025 * 1000.0 / 300.0, Timean] + extra_Ti
    V = [0.0, 0.0] + extra_V
    rr = np.linspace(0.0, 900.0, 1001)
    vals = forward_model(rr,
                         Lmean,
                         dmean,
                         Fmean,
                         w,
                         mus,
                         amp,
                         Ti,
                         V,
                         sm_ang=False,
                         nlambda=1024)
    #ax.plot(rr**2, vals, 'k')
    #ax.plot(new_r**2, sig_mean, 'C7')

    #w += [487.873302, 487.98634]
    #amps += [Amean * Arelmean, Amean]
    #mus += [232.0, 40.0]
    #temps += [temps[0], Timean]
    #vs += [0.0, 0.0]
    #rr = np.linspace(0.0, 1000.0, 1001)
    #newoffset = forward_model(rr, Lmean, dmean, Fmean, w, mus, amps, temps, vs, sm_ang=False)