def modelrho(r0, logrho, nr0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, nrinf):
# direct n(r) measures: traf(...)
vec = np.array([logrho,nr0,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15,v16,v17,v18,nrinf])
vec = traf(vec)
vec = gcc.map_nr_data(vec, 1, gp)
rh = phys.rho(r0, vec, 0, gp)
return np.log(rh)
def modelrho(r0, rhohalf, nr00, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, nrinf):
# direct n(r) measures: traf(...)
vec = np.array([nr00,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15,v16,v17,v18, nrinf])
#print('vec=',vec)
#pdb.set_trace()
vec = traf(vec)
vec = gcc.map_nr(np.hstack([rhohalf, vec]), 'rho', 0, gp)
#rhoparam = np.hstack([rhohalf,vec[0],vec,vec[-1]])
rh = phys.rho(r0, vec, 0, gp)
return np.log(rh)
def modelrho(r0, logrho, nr0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
v12, v13, v14, v15, v16, v17, v18, nrinf):
# direct n(r) measures: traf(...)
vec = np.array([
logrho, nr0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
v14, v15, v16, v17, v18, nrinf
])
vec = traf(vec)
vec = gcc.map_nr_data(vec, 1, gp)
rh = phys.rho(r0, vec, 0, gp)
return np.log(rh)
def modelrho(r0, rhohalf, nr00, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
v12, v13, v14, v15, v16, v17, v18, nrinf):
# direct n(r) measures: traf(...)
vec = np.array([
nr00, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
v16, v17, v18, nrinf
])
#print('vec=',vec)
#pdb.set_trace()
vec = traf(vec)
vec = gcc.map_nr(np.hstack([rhohalf, vec]), 'rho', 0, gp)
#rhoparam = np.hstack([rhohalf,vec[0],vec,vec[-1]])
rh = phys.rho(r0, vec, 0, gp)
return np.log(rh)
def rho_param_INT_Sig_disc(z0, rhopar, pop, gp):
# use splines on variable transformed integral
# \Sigma(R) = \int_{r=0}^{R} \rho(r) dr
xmin = z0[0]/30. # tweaked. z0[0]/1e4 gives error in quad()
z0left = np.array([xmin, z0[0]*0.25, z0[0]*0.50, z0[0]*0.75])
z0nu = np.hstack([z0left, z0])
rhonu = phys.rho(z0nu, rhopar, pop, gp) # rho takes rho(rhalf) and n(r) parameters
Sig = np.zeros(len(z0nu)-gp.nexp)
for i in range(len(z0nu)-gp.nexp):
Sig[i] = gh.quadinflog(z0nu, rhonu, xmin, z0nu[i])
gh.checkpositive(Sig, 'Sig in rho_param_INT_Sig_disc')
return Sig[len(z0left):] # @z0 (z0nu without z0left, and without 3 extension bins)
def rho_param_INT_Sig_disc(z0, rhopar, pop, gp):
# use splines on variable transformed integral
# \Sigma(R) = \int_{r=0}^{R} \rho(r) dr
xmin = z0[0] / 30. # tweaked. z0[0]/1e4 gives error in quad()
z0left = np.array([xmin, z0[0] * 0.25, z0[0] * 0.50, z0[0] * 0.75])
z0nu = np.hstack([z0left, z0])
rhonu = phys.rho(z0nu, rhopar, pop,
gp) # rho takes rho(rhalf) and n(r) parameters
Sig = np.zeros(len(z0nu) - gp.nexp)
for i in range(len(z0nu) - gp.nexp):
Sig[i] = gh.quadinflog(z0nu, rhonu, xmin, z0nu[i])
gh.checkpositive(Sig, 'Sig in rho_param_INT_Sig_disc')
return Sig[len(
z0left):] # @z0 (z0nu without z0left, and without 3 extension bins)
def rho_param_INT_Sig(r0, rhodmpar, pop, gp):
# use splines on variable transformed integral
# \Sigma(R) = \int_{r=R}^{R=\infty} \rho(r) d \sqrt(r^2-R^2)
xmin = gp.xfine[0]/15. # needed, if not: loose on first 4 bins
r0nu = gp.xfine
rhonu = phys.rho(r0nu, rhodmpar, pop, gp)
Sig = np.zeros(len(r0nu)-gp.nexp)
for i in range(len(r0nu)-gp.nexp):
xnew = np.sqrt(r0nu[i:]**2-r0nu[i]**2) # [lunit]
ynew = 2.*rhonu[i:]
# power-law extension to infinity
C = gh.quadinflog(xnew[-gp.nexp:], ynew[-gp.nexp:], xnew[-1], gp.rinfty*xnew[-1])
Sig[i] = gh.quadinflog(xnew[1:], ynew[1:], xmin, xnew[-1]) + C # np.inf)
gh.checkpositive(Sig, 'Sig in rho_param_INT_Sig')
# interpolation onto r0
tck1 = splrep(np.log(gp.xfine[:-gp.nexp]), np.log(Sig))
Sigout = np.exp(splev(np.log(r0), tck1))
return Sigout
def rho_param_INT_Sig_theta(Rproj, rhodmpar, pop, gp):
# use splines on variable transformed integral
# \Sigma(R) = \int_{r=R}^{R=\infty} \rho(r) d \sqrt(r^2-R^2)
bit = 1.e-6
theta = np.linspace(0, np.pi/2-bit, gp.nfine)
cth = np.cos(theta)
cth2 = cth*cth
rhonu = phys.rho(Rproj, rhodmpar, pop, gp)
Sig = np.zeros(len(Rproj))
for i in range(len(Rproj)):
rq = Rproj[i]/cth
rhoq = np.interp(rq, Rproj, rhonu, left=0, right=0)
#right=rhonu[-1]/1e10) # best for hern
#rhoq = phys.rho(rq, rhodmpar, pop, gp)
Sig[i] = 2.*Rproj[i]*simps(rhoq/cth2, theta)
gh.checkpositive(Sig, 'Sig in rho_param_INT_Sig')
# interpolation onto r0
#tck1 = splrep(np.log(gp.xfine), np.log(Sig))
#Sigout = np.exp(splev(np.log(r0), tck1))
return Sig
def rho_param_INT_Sig_theta(Rproj, rhodmpar, pop, gp):
# use splines on variable transformed integral
# \Sigma(R) = \int_{r=R}^{R=\infty} \rho(r) d \sqrt(r^2-R^2)
bit = 1.e-6
theta = np.linspace(0, np.pi / 2 - bit, gp.nfine)
cth = np.cos(theta)
cth2 = cth * cth
rhonu = phys.rho(Rproj, rhodmpar, pop, gp)
Sig = np.zeros(len(Rproj))
for i in range(len(Rproj)):
rq = Rproj[i] / cth
rhoq = np.interp(rq, Rproj, rhonu, left=0, right=0)
#right=rhonu[-1]/1e10) # best for hern
#rhoq = phys.rho(rq, rhodmpar, pop, gp)
Sig[i] = 2. * Rproj[i] * simps(rhoq / cth2, theta)
gh.checkpositive(Sig, 'Sig in rho_param_INT_Sig')
# interpolation onto r0
#tck1 = splrep(np.log(gp.xfine), np.log(Sig))
#Sigout = np.exp(splev(np.log(r0), tck1))
return Sig
def rho_param_INT_Sig(r0, rhodmpar, pop, gp):
# use splines on variable transformed integral
# \Sigma(R) = \int_{r=R}^{R=\infty} \rho(r) d \sqrt(r^2-R^2)
xmin = gp.xfine[0] / 15. # needed, if not: loose on first 4 bins
r0nu = gp.xfine
rhonu = phys.rho(r0nu, rhodmpar, pop, gp)
Sig = np.zeros(len(r0nu) - gp.nexp)
for i in range(len(r0nu) - gp.nexp):
xnew = np.sqrt(r0nu[i:]**2 - r0nu[i]**2) # [lunit]
ynew = 2. * rhonu[i:]
# power-law extension to infinity
C = gh.quadinflog(xnew[-gp.nexp:], ynew[-gp.nexp:], xnew[-1],
gp.rinfty * xnew[-1])
Sig[i] = gh.quadinflog(xnew[1:], ynew[1:], xmin,
xnew[-1]) + C # np.inf)
gh.checkpositive(Sig, 'Sig in rho_param_INT_Sig')
# interpolation onto r0
tck1 = splrep(np.log(gp.xfine[:-gp.nexp]), np.log(Sig))
Sigout = np.exp(splev(np.log(r0), tck1))
return Sigout
y = np.log(analytic_rho(x))
popt3, pcov3 = curve_fit(modelrho, x, y, p0=npr.rand(gp.nrho), maxfev=10000)
nr01opt = traf(popt3[1:])
nropt = gcc.map_nr(np.hstack([popt3[0], nr01opt]), 'rho', 0, gp)
print('nr01opt = ', nr01opt)
print('nropt = ', nropt)
fig = plt.figure(facecolor='white')
left, width = 0.25, 0.7
rect1 = [left, 0.4, width, 0.55]
rect2 = [left, 0.2, width, 0.2]
ax1 = fig.add_axes(rect1) #left, bottom, width, height
ax2 = fig.add_axes(rect2, sharex=ax1)
ax1.plot(x, y, 'b', lw=2, label='analytic')
ax1.plot(x, modelrho(x, *popt3), 'r--', lw=2, label='fit on data')
ax1.plot(x, np.log(phys.rho(x, nropt, 0, gp)), 'g--', lw=1, label='phys.rho')
ax1.set_xscale('log')
plt.setp(ax1.get_xticklabels(), visible=False)
ax1.set_ylabel('$\\rho$')
legend = ax1.legend(loc='lower left', shadow=False, borderpad=0.2, labelspacing=0.1, handletextpad=0.1, borderaxespad=0.3)
frame = legend.get_frame()
frame.set_facecolor('1.0')
for label in legend.get_texts():
label.set_fontsize(8)
for label in legend.get_lines():
label.set_linewidth(2) # the legend line width
ax2.set_xscale('log')
ax2.plot(x, y-modelrho(x, *popt3), 'r.-', alpha=0.8)
ax2.set_xlabel('$r\\,[{\\rm pc}]$')
plt.savefig('rho_fit_all.pdf')
def geom_loglike(cube, ndim, nparams, gp):
tmp_profs = Profiles(gp.pops, gp.nepol)
off = 0
offstep = gp.nrho
if gp.chi2_Sig_converged <= 0:
rhodmpar = np.array(cube[off : off + offstep])
tmp_rho0 = phys.rho(gp.xepol, rhodmpar, 0, gp)
# for J factor calculation (has been deferred to output routine)
# tmp_rhofine = phys.rho(gp.xfine, rhodmpar, 0, gp)
# tmp_Jfine = gip.Jpar(gp.xfine, tmp_rhofine, gp) #tmp_rhofine
# tck = splrep(gp.xfine[:-3], tmp_Jfine)
# tmp_J = splev(gp.xepol, tck)
# rhodmpar hold [rho(rhalf), nr to be used for integration
# from halflight radius, defined on gp.xepol]
# (only calculate) M, check
tmp_M0 = gip.rho_SUM_Mr(gp.xepol, tmp_rho0)
# store profiles
tmp_profs.set_prof("nr", 1.0 * rhodmpar[1 + 1 : -1], 0, gp)
tmp_profs.set_prof("rho", tmp_rho0, 0, gp)
# tmp_profs.set_prof('J', tmp_J, 0, gp)
tmp_profs.set_prof("M", tmp_M0, 0, gp)
off += offstep # anyhow, even if Sig not yet converged
# get profile for rho*
if gp.investigate == "obs":
offstep = gp.nrho
lbaryonpar = np.array(cube[off : off + offstep])
rhostar = phys.rho(gp.xepol, lbaryonpar, 0, gp)
off += offstep
Signu = gip.rho_param_INT_Sig(gp.xepol, lbaryonpar, 0, gp) # [Munit/pc^2]
MtoL = cube[off]
off += 1
# store these profiles every time
tmp_profs.set_prof("nu", rhostar, 0, gp)
tmp_profs.set_prof("Sig", Signu, 0, gp)
tmp_profs.set_MtoL(MtoL)
else:
lbaryonpar = np.zeros(gp.nrho)
MtoL = 0.0
for pop in np.arange(1, gp.pops + 1): # [1, 2, ..., gp.pops]
offstep = gp.nrho
nupar = np.array(cube[off : off + offstep])
tmp_nrnu = 1.0 * nupar[1 + 1 : -1]
tmp_nu = phys.rho(gp.xepol, nupar, pop, gp)
tmp_Signu = gip.rho_param_INT_Sig(gp.xepol, nupar, pop, gp)
# tmp_nu = pool.apply_async(phys.rho, [gp.xepol, nupar, pop, gp])
# tmp_Signu = pool.apply_async(gip.rho_param_INT_Sig, [gp.xepol, nupar, pop, gp])
off += offstep
offstep = 1
tmp_hyperSig = cube[off : off + offstep]
off += offstep
offstep = 1
tmp_hypersig = cube[off : off + offstep]
off += offstep
offstep = gp.nbeta
if gp.chi2_Sig_converged <= 0:
betapar = np.array(cube[off : off + offstep])
tmp_beta, tmp_betastar = phys.beta(gp.xepol, betapar, gp)
if check_beta(tmp_beta, gp):
gh.LOG(2, "beta error")
tmp_profs.chi2 = gh.err(1.0, gp)
return tmp_profs
try:
# if True:
if gp.checksig and gp.investigate == "hern":
import gi_analytic as ga
anrho = ga.rho(gp.xepol, gp)[0]
rhodmpar_half = np.exp(splev(gp.dat.rhalf[0], splrep(gp.xepol, np.log(anrho))))
nr = -gh.derivipol(np.log(anrho), np.log(gp.xepol))
dlr = np.hstack([nr[0], nr, nr[-1]])
if gp.investigate == "gaia":
dlr[-1] = 4
rhodmpar = np.hstack([rhodmpar_half, dlr])
lbaryonpar = 0.0 * rhodmpar
MtoL = 0.0
betapar = np.array([0, 0, 2, max(gp.xipol) / 2]) # for hern
annu = ga.rho(gp.xepol, gp)[1]
nupar_half = np.exp(splev(gp.dat.rhalf[1], splrep(gp.xepol, np.log(annu))))
nrnu = -gh.derivipol(np.log(annu), np.log(gp.xepol))
dlrnu = np.hstack([nrnu[0], nrnu, nrnu[-1]])
if gp.investigate == "gaia":
dlrnu[-1] = 6
nupar = np.hstack([nupar_half, dlrnu])
elif gp.checkbeta and gp.investigate == "gaia":
# rhodmpar = np.array([ 0.41586608, 0.38655515, 0.60898657, 0.50936769, 0.52601378, 0.54526758, 0.5755599, 0.57900806, 0.60252357, 0.60668445, 0.62252721, 0.63173754, 0.64555439, 0.65777175, 0.67083556, 0.68506606, 0.69139872, 0.66304763, 0.61462276, 0.70916575, 0.53287872])
rhodmpar = np.array(
[
0.18235821,
0.4719348,
0.0,
0.0,
0.10029569,
0.11309553,
0.25637863,
0.31815175,
0.40621336,
0.46247927,
0.53545415,
0.60874961,
0.68978141,
0.79781574,
0.91218048,
1.08482356,
1.36074895,
1.88041885,
2.31792908,
2.62089078,
3.001,
]
)
betapar = np.array([1.23555034e-03, 9.89999994e-01, 2.03722518e00, 5.85640906e00])
nupar = np.array(
[
0.15649498,
6.65618254,
0.10293663,
0.1087109,
0.13849277,
0.24371261,
0.62633345,
1.05913181,
1.43774113,
1.82346043,
2.20091446,
2.60007997,
2.98745825,
3.423104,
3.80766658,
4.2089698,
4.62950843,
4.91166037,
4.97380638,
4.99718073,
5.2277589,
]
)
gp.dat.nrnu = [
np.array(
[
0.15476906,
0.85086798,
0.9342867,
0.88161169,
0.83254241,
0.85086798,
0.99930431,
1.22211638,
1.47184763,
1.78910057,
2.1987677,
2.51961046,
2.80345393,
3.10336133,
3.88504346,
4.52442727,
4.88817769,
5.07880404,
4.83455511,
6.32165657,
4.88817769,
]
),
np.array(
[
0.15476906,
0.85086798,
0.9342867,
0.88161169,
0.83254241,
0.85086798,
0.99930431,
1.22211638,
1.47184763,
1.78910057,
2.1987677,
2.51961046,
2.80345393,
3.10336133,
3.88504346,
4.52442727,
4.88817769,
5.07880404,
4.83455511,
6.32165657,
4.88817769,
]
),
np.array(
[
0.15476906,
0.85086798,
0.9342867,
0.88161169,
0.83254241,
0.85086798,
0.99930431,
1.22211638,
1.47184763,
1.78910057,
2.1987677,
2.51961046,
2.80345393,
3.10336133,
3.88504346,
4.52442727,
4.88817769,
5.07880404,
4.83455511,
6.32165657,
4.88817769,
]
),
np.array(
[
0.15476906,
0.85086798,
0.9342867,
0.88161169,
0.83254241,
0.85086798,
0.99930431,
1.22211638,
1.47184763,
1.78910057,
2.1987677,
2.51961046,
2.80345393,
3.10336133,
3.88504346,
4.52442727,
4.88817769,
5.07880404,
4.83455511,
6.32165657,
4.88817769,
]
),
]
gp.dat.nrnuerr = [
np.array(
[
0.05158969,
12.22044422,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
]
),
np.array(
[
0.05158969,
12.22044422,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
]
),
np.array(
[
0.05158969,
12.22044422,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
]
),
np.array(
[
0.05158969,
12.22044422,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
0.48881777,
2.44408884,
2.44408884,
2.44408884,
2.44408884,
]
),
]
lbaryonpar = 0.0 * rhodmpar
MtoL = 0.0
sig, kap, zetaa, zetab = phys.sig_kap_zet(gp.xepol, rhodmpar, lbaryonpar, MtoL, nupar, betapar, pop, gp)
# fill_between(gp.xipol, gp.dat.sig[1]-gp.dat.sigerr[1], gp.dat.sig[1]+gp.dat.sigerr[1])
# plot(gp.xepol, sig, 'r')
# xscale('log')
# ylim([0, 30])
# xlabel('$r$ [pc]')
# ylabel('$\sigma_{LOS}$ [km/s]')
# savefig('siglos_gaia_2.pdf')
# pdb.set_trace()
except Exception:
gh.LOG(1, "sigma error")
tmp_profs.chi2 = gh.err(2.0, gp)
return tmp_profs
# now store the profiles
gh.sanitize_vector(tmp_beta, len(tmp_profs.x0), -200, 1, gp.debug)
tmp_profs.set_prof("beta", tmp_beta, pop, gp)
gh.sanitize_vector(tmp_betastar, len(tmp_profs.x0), -1, 1, gp.debug)
tmp_profs.set_prof("betastar", tmp_betastar, pop, gp)
tmp_profs.set_prof("sig", sig, pop, gp)
tmp_profs.hypersig = tmp_hypersig
tmp_profs.set_prof("kap", kap, pop, gp)
tmp_profs.set_zeta(zetaa, zetab, pop)
tmp_profs.set_prof("nrnu", tmp_nrnu, pop, gp)
tmp_profs.set_prof("nu", tmp_nu, pop, gp) # pool: tmp_nu.get()
# following profile needs to be stored at all times, to calculate chi
tmp_profs.set_prof("Sig", tmp_Signu, pop, gp)
tmp_profs.hyperSig = tmp_hyperSig
off += offstep # still do this even if gp.chi2_Sig_converged is False
if off != gp.ndim:
gh.LOG(1, "wrong subscripts in gi_loglike")
pdb.set_trace()
# determine log likelihood
chi2 = calc_chi2(tmp_profs, gp)
gh.LOG(-1, gp.investigate + "/" + str(gp.case) + "/" + gp.files.timestamp + ": ln L = ", gh.pretty(-chi2 / 2.0))
# x=gp.dat.rbin
# linedat,=ax.loglog(x, gp.dat.Sig[1], 'b')
# line,=ax.loglog(x, tmp_profs.get_prof("Sig", 1), 'r', alpha=0.1)
# plt.draw()
# plt.show()
tmp_profs.chi2 = chi2
# after some predefined wallclock time and Sig convergence, plot all profiles
# if time.time() - gp.last_plot >= gp.plot_after and gp.chi2_Sig_converged <= 0:
# gp.last_plot = time.time()
# try:
# import plotting.plot_profiles
# plotting.plot_profiles.run(gp.files.timestamp, gp.files.outdir, gp)
# except:
# print('plotting error in gi_loglike!')
# close pool automatically after with clause
return tmp_profs
popt3, pcov3 = curve_fit(modelrho, x, y, p0=npr.rand(gp.nrho), maxfev=10000)
nr01opt = traf(popt3[:])
nropt = gcc.map_nr_data(nr01opt, 1, gp)
print('nr01opt = ', nr01opt)
print('nropt = ', nropt)
fig = plt.figure(facecolor='white')
left, width = 0.25, 0.7
rect1 = [left, 0.4, width, 0.55]
rect2 = [left, 0.2, width, 0.2]
ax1 = fig.add_axes(rect1) #left, bottom, width, height
ax2 = fig.add_axes(rect2, sharex=ax1)
ax1.plot(gp.xipol, np.log(gp.dat.nu[1]), 'k', lw=3, label='data')
ax1.plot(x, y, 'b', lw=2, label='analytic')
ax1.plot(x, modelrho(x, *popt3), 'r--', lw=2, label='fit on data')
ax1.plot(x, np.log(phys.rho(x, nropt, 1, gp)), 'g--', lw=1, label='phys.rho')
ax1.set_xscale('log')
plt.setp(ax1.get_xticklabels(), visible=False)
ax1.set_ylabel('$\\rho$')
legend = ax1.legend(loc='lower left',
shadow=False,
borderpad=0.2,
labelspacing=0.1,
handletextpad=0.1,
borderaxespad=0.3)
frame = legend.get_frame()
frame.set_facecolor('1.0')
for label in legend.get_texts():
label.set_fontsize(8)
for label in legend.get_lines():
label.set_linewidth(2) # the legend line width
def ant_sigkaplos(r0, rhodmpar, lbaryonpar, MtoL, nupar, betapar, pop, gp):
rmin = np.log10(min(r0))
rmax = np.log10(max(r0)*gp.rinfty)
r0fine = np.logspace(rmin, rmax, gp.nfine)
# rho
# --------------------------------------------------------------------------
rhofine = phys.rho(r0fine, rhodmpar, 0, gp) # DM mass profile (first)
if gp.checksig and gp.stopstep <= 1:
clf()
loglog(r0fine, rhofine, 'r.-', label='rederived from dn/dlogr params')
loglog(r0fine, ga.rho(r0fine, gp)[0], 'b--', label='analytic')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.dat.rhalf[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$\\rho(r)$')
legend(loc='lower left')
savefig('fit_rho_'+gp.investigate+'.pdf')
pdb.set_trace()
# add up tracer densities to get overall density profile
# add rho* to take into account the baryonic addition
# (*not* Sigma from nu_i, could miss populations, have
# varying selection function as fct of radius
# need a M/L parameter)
# only if we work on real data, add up total baryonic contribution
if gp.investigate == 'obs':
nu_baryons = MtoL*phys.rho(r0fine, lbaryonpar, pop, gp)
rhofine += nu_baryons
# beta
# ------------------------------------------------------------------------
betafine = phys.beta(r0fine, betapar, gp)[0]
if gp.checksig and gp.stopstep <= 2:
clf()
anbeta = ga.beta(r0fine, gp)[1]
plot(r0fine, betafine, 'r.-', label='model')
plot(r0fine, anbeta, 'b--', label='analytic')
xscale('log')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.dat.rhalf[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$\\beta$')
ylim([-0.5, 1.0])
legend(loc='lower right')
savefig('fit_beta_'+gp.investigate+'.pdf')
pdb.set_trace()
# nu
# ------------------------------------------------------------------------
nufine = phys.rho(r0fine, nupar, pop, gp)
if gp.checksig:
annu = ga.rho(r0fine, gp)[pop]
if gp.checksig and gp.stopstep <= 3:
clf()
loglog(gp.xipol, gp.dat.nu[pop], 'g.-', label='data')
fill_between(gp.xipol, gp.dat.nu[pop]-gp.dat.nuerr[pop], \
gp.dat.nu[pop]+gp.dat.nuerr[pop],\
color='g', alpha=0.6)
loglog(r0fine, nufine, 'r.-', label='model')
loglog(r0fine, annu, 'b--', label='analytic')
legend(loc='lower left')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.dat.rhalf[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$\\nu$')
savefig('fit_nu_'+gp.investigate+'.pdf')
pdb.set_trace()
# \Sigma
# ---------------------------------------------------------------
Sigfine = gip.rho_param_INT_Sig_theta(r0fine, nupar, pop, gp)
if gp.checksig and gp.stopstep <= 4:
clf()
anSig = ga.Sigma(r0fine, gp)[pop]
loglog(gp.xipol, gp.dat.Sig[pop], 'g--', label='data')
loglog(r0fine, Sigfine, 'r.-', label='model')
loglog(r0fine, anSig, 'b--', label='analytic')
fill_between(gp.xipol, gp.dat.Sig[pop]-gp.dat.Sigerr[pop], \
gp.dat.Sig[pop]+gp.dat.Sigerr[pop],\
color='g', alpha=0.6)
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.Xscale[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$\\Sigma$')
legend(loc='lower left')
savefig('fit_Sig_'+gp.investigate+'.pdf')
pdb.set_trace()
# int beta(s)/s ds
# ------------------------------------------------------
# test for constant \beta
if gp.checksig:
if gp.investigate == 'gaia':
beta_star1, r_DM, gamma_star1, r_star1, r_a1, gamma_DM, rho0 = gp.files.params
anintbetasfine = 0.5*(np.log(r0fine**2+r_a1**2)-np.log(r_a1**2))
elif gp.investigate == 'hern':
anintbetasfine = 0.0*r0fine
#betapar[0] = 1
#betapar[1] = 1
anintbetasfine = np.log(r0fine)-np.log(r0fine[0])
intbetasfine = ant_intbeta(r0fine, betapar, gp)
if gp.checksig and gp.stopstep <= 5 :
clf()
plot(r0fine, intbetasfine, 'r.-', label='model')
plot(r0fine, anintbetasfine, 'b--', label='analytic')
ylim([-5, 5])
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.dat.rhalf[0], lw=2)
xscale('log')
xlabel('$r/\\rm{pc}$')
ylabel('$\\int ds \\beta(s)/s$')
legend(loc='lower right')
savefig('fit_intbeta_'+gp.investigate+'.pdf')
pdb.set_trace()
# M(r)
# -------------------------------------------------------
#rhofine = ga.rho_hern(r0fine, gp)[0]
rhoint = 4.*np.pi*r0fine**2*rhofine
# add point to avoid 0.0 in Mrfine(r0fine[0])
r0tmp = np.hstack([0.,r0fine])
rhotmp = np.hstack([0.,rhoint])
splpar_rho = splrep(r0tmp, rhotmp, k=1, s=0.) # not necessarily monotonic
Mrfine = np.zeros(len(r0fine)) # work in refined model
for i in range(len(r0fine)):
Mrfine[i] = splint(0., r0fine[i], splpar_rho)
gh.checkpositive(Mrfine, 'Mrfine')
if gp.checksig:
anMr = ga.Mr(r0fine, gp)[0] # earlier: pop
anMr = Mrfine
#anMr = ga.M_hern(r0fine, gp)[0]
if gp.checksig and gp.stopstep <= 6:
#loglog(gp.xipol, gp.dat.Mr[pop], 'g.-', label='data')
#s = r0fine/r_DM # [1]
clf()
loglog(r0fine, Mrfine, 'r.-', label='model')
#loglog(r0fine, anMr, 'b--', label='analytic')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.dat.rhalf[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$M(r)$')
legend(loc='lower right')
savefig('fit_M_'+gp.investigate+'.pdf')
pdb.set_trace()
# nu(r)\cdot\sigma_r^2(r) integrand
# -------------------------------------------------------
# (sigr2, 3D) * nu/exp(-intbetasfine)
xint = r0fine # [pc]
yint = gu.G1__pcMsun_1km2s_2 * Mrfine / r0fine**2 # [1/pc (km/s)^2]
yint *= nufine # [Munit/pc^4 (km/s)^2]
yint *= np.exp(2*(intbetasfine)) # [Munit/pc^4 (km/s)^2]
gh.checkpositive(yint, 'yint sigr2')
if gp.checksig and gp.stopstep <= 7:
clf()
loglog(xint, yint, 'r.-', label='model')
loglog(xint, gu.G1__pcMsun_1km2s_2 * anMr / r0fine**2 * annu * np.exp(2*anintbetasfine), 'b--', label='from analytic')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.dat.rhalf[0], lw=2)
xlabel('$xint/\\rm{pc}$')
ylabel('$yint$')
legend(loc='lower left')
savefig('fit_nu_sigmar2_'+gp.investigate+'.pdf')
pdb.set_trace()
# actual integration, gives \sigma_r^2 \nu
sigr2nu_model = np.zeros(len(r0fine))
for k in range(len(r0fine)):
#theta_old = np.linspace(0, np.arccos(r0fine[k]/(gp.rinfty*max(gp.xepol))), gp.nfine)
theta = np.arccos(r0fine[k]/r0fine[k:])
rq = r0fine[k]/np.cos(theta)
#Mrq = np.interp(rq, r0fine, Mrfine, left=0, right=0)
#nuq = np.interp(rq, r0fine, nufine, left=0, right=0)
#intbetaq = np.interp(rq, r0fine, intbetasfine, left=0, right=0)
#func_interp_before = Mrq*nuq*np.exp(2*intbetaq)
func_base = Mrfine*nufine*np.exp(2*intbetasfine)
#func_interp_after = np.interp(rq, r0fine, func_base, left=0, right=0)
func_interp_after = func_base[k:]
#print('median(func_interp_after / func_interp_before = ',\
# np.median(func_interp_after / func_interp_before))
#sigr2nu_model[k] = np.exp(-2*intbetasfine[k])/r0fine[k] * \
# gu.G1__pcMsun_1km2s_2*simps(func_interp_before*np.sin(theta), theta)
sigr2nu_model[k] = np.exp(-2*intbetasfine[k])/r0fine[k] * \
gu.G1__pcMsun_1km2s_2*simps(func_interp_after*np.sin(theta), theta)
# clean last value (which is always 0 by construction)
sigr2nu_model[-1] = sigr2nu_model[-2]/10.
gh.checkpositive(sigr2nu_model, 'sigr2nu_model in sigl2s')
#gh.checkpositive(sigr2nu_model_new, 'sigr2nu_model_new in sigl2s')
if gp.checksig and gp.stopstep <= 8:
clf()
ansigr2nu = ga.sigr2(r0fine, gp)*annu
loglog(r0fine, sigr2nu_model, 'r.-', label='model')
loglog(r0fine, ansigr2nu, 'b--', label='analytic')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.dat.rhalf[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$\\sigma_r^2(r)\\nu(r)$')
legend(loc='lower right')
savefig('fit_sigr2_'+gp.investigate+'.pdf')
# project back to LOS values, \sigma_{LOS}^2 * \Sigma(R)
# -------------------------------------------------------
sigl2s = np.zeros(len(r0fine))
for k in range(len(r0fine)):
bit = 1.e-6
theta = np.linspace(0, np.pi/2-bit, gp.nfine)
# work on same radii as data are given
theta = np.arccos(r0fine[k]/r0fine[k:])
cth = np.cos(theta)
cth2 = cth*cth
ynew = (1-betafine[k:]*cth2)*sigr2nu_model[k:]
rq = r0fine[k]/cth
ynewq = np.interp(rq, r0fine[k:], ynew, left=0, right=0)
sigl2s[k] = 2.*r0fine[k]*simps(ynewq/cth2, theta)
sigl2s[-1] = sigl2s[-2]/10.
gh.checkpositive(sigl2s, 'sigl2s')
if gp.checksig and gp.stopstep <= 9:
clf()
anSigsiglos2_hern = ga.Sig_sig_los_2(r0fine, gp)
loglog(r0fine, sigl2s, 'r.-', label='model')
loglog(r0fine, anSigsiglos2_hern, 'b--', label='analytic')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.Xscale[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$\\sigma_{\\rm{LOS}}^2 \Sigma$')
legend(loc='lower left')
savefig('fit_Sig_siglos2_'+gp.investigate+'.pdf')
pdb.set_trace()
# sigma_LOS^2
# -------------------------------------------------------
siglos2 = sigl2s/Sigfine
if gp.checksig and gp.stopstep <= 10:
clf()
#ansiglos = ga.sig_los(r0fine, gp)
plot(r0fine, siglos2, 'r.-', label='model')
#plot(r0fine, ansiglos**2, 'b--', label='analytic')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.Xscale[0], lw=2)
xscale('log')
xlabel('$r/\\rm{pc}$')
ylabel('$\\sigma_{\\rm{LOS}}^2$')
legend(loc='upper right')
savefig('fit_siglos2_'+gp.investigate+'.pdf')
pdb.set_trace()
# derefine on radii of the input vector
splpar_sig = splrep(r0fine, np.log(siglos2), k=3, s=0.)
siglos2_out = np.exp(splev(r0, splpar_sig))
# gh.checkpositive(siglos2_out, 'siglos2_out')
if gp.checksig and gp.stopstep <= 11:
clf()
#ansiglos = ga.sig_los(r0, gp)
plot(r0, np.sqrt(siglos2_out), 'r.-', label='model')
#plot(r0, ansiglos, 'b--', label='analytic')
plot(gp.xipol, gp.dat.sig[pop], 'g.-', label='data')
fill_between(gp.xipol, gp.dat.sig[pop]-gp.dat.sigerr[pop], gp.dat.sig[pop]+gp.dat.sigerr[pop], color='g', alpha=0.6)
xscale('log')
axvline(max(gp.xipol))
axvline(min(gp.xipol))
axvline(gp.Xscale[0], lw=2)
xlabel('$r/\\rm{pc}$')
ylabel('$\\sigma_{\\rm{LOS}}$')
ylim([0,25])
legend(loc='upper right')
savefig('fit_siglos_out_'+gp.investigate+'.pdf')
pdb.set_trace()
if not gp.usekappa:
kapl4s_out = np.ones(len(siglos2_out))
if gp.usekappa:
kapl4s_out = kappa(r0fine, Mrfine, nufine, sigr2nu_model, intbetasfine, gp)
zetaa = -1; zetab = -1
if gp.usezeta:
zetaa, zetab = zeta(r0fine, nufine, \
Sigfine,\
Mrfine, betafine,\
sigr2nu_model, gp)
gh.sanitize_vector(siglos2_out, len(r0), 0, 1e30, gp.debug)
return siglos2_out, kapl4s_out, zetaa, zetab
def geom_loglike(cube, ndim, nparams, gp):
tmp_profs = Profiles(gp.pops, gp.nepol)
off = 0
offstep = gp.nrho
if gp.chi2_Sig_converged <= 0:
rhodmpar = np.array(cube[off:off + offstep])
tmp_rho0 = phys.rho(gp.xepol, rhodmpar, 0, gp)
# for J factor calculation (has been deferred to output routine)
#tmp_rhofine = phys.rho(gp.xfine, rhodmpar, 0, gp)
#tmp_Jfine = gip.Jpar(gp.xfine, tmp_rhofine, gp) #tmp_rhofine
#tck = splrep(gp.xfine[:-3], tmp_Jfine)
#tmp_J = splev(gp.xepol, tck)
# rhodmpar hold [rho(rhalf), nr to be used for integration
# from halflight radius, defined on gp.xepol]
# (only calculate) M, check
tmp_M0 = gip.rho_SUM_Mr(gp.xepol, tmp_rho0)
# store profiles
tmp_profs.set_prof('nr', 1. * rhodmpar[1 + 1:-1], 0, gp)
tmp_profs.set_prof('rho', tmp_rho0, 0, gp)
#tmp_profs.set_prof('J', tmp_J, 0, gp)
tmp_profs.set_prof('M', tmp_M0, 0, gp)
off += offstep # anyhow, even if Sig not yet converged
# get profile for rho*
if gp.investigate == 'obs':
offstep = gp.nrho
lbaryonpar = np.array(cube[off:off + offstep])
rhostar = phys.rho(gp.xepol, lbaryonpar, 0, gp)
off += offstep
Signu = gip.rho_param_INT_Sig(gp.xepol, lbaryonpar, 0,
gp) # [Munit/pc^2]
MtoL = cube[off]
off += 1
# store these profiles every time
tmp_profs.set_prof('nu', rhostar, 0, gp)
tmp_profs.set_prof('Sig', Signu, 0, gp)
tmp_profs.set_MtoL(MtoL)
else:
lbaryonpar = np.zeros(gp.nrho)
MtoL = 0.
for pop in np.arange(1, gp.pops + 1): # [1, 2, ..., gp.pops]
offstep = gp.nrho
nupar = np.array(cube[off:off + offstep])
tmp_nrnu = 1. * nupar[1 + 1:-1]
tmp_nu = phys.rho(gp.xepol, nupar, pop, gp)
tmp_Signu = gip.rho_param_INT_Sig(gp.xepol, nupar, pop, gp)
#tmp_nu = pool.apply_async(phys.rho, [gp.xepol, nupar, pop, gp])
#tmp_Signu = pool.apply_async(gip.rho_param_INT_Sig, [gp.xepol, nupar, pop, gp])
off += offstep
offstep = 1
tmp_hyperSig = cube[off:off + offstep]
off += offstep
offstep = 1
tmp_hypersig = cube[off:off + offstep]
off += offstep
offstep = gp.nbeta
if gp.chi2_Sig_converged <= 0:
betapar = np.array(cube[off:off + offstep])
tmp_beta, tmp_betastar = phys.beta(gp.xepol, betapar, gp)
if check_beta(tmp_beta, gp):
gh.LOG(2, 'beta error')
tmp_profs.chi2 = gh.err(1., gp)
return tmp_profs
try:
#if True:
if gp.checksig and gp.investigate == 'hern':
import gi_analytic as ga
anrho = ga.rho(gp.xepol, gp)[0]
rhodmpar_half = np.exp(
splev(gp.dat.rhalf[0], splrep(gp.xepol,
np.log(anrho))))
nr = -gh.derivipol(np.log(anrho), np.log(gp.xepol))
dlr = np.hstack([nr[0], nr, nr[-1]])
if gp.investigate == 'gaia':
dlr[-1] = 4
rhodmpar = np.hstack([rhodmpar_half, dlr])
lbaryonpar = 0.0 * rhodmpar
MtoL = 0.0
betapar = np.array([0, 0, 2,
max(gp.xipol) / 2]) # for hern
annu = ga.rho(gp.xepol, gp)[1]
nupar_half = np.exp(
splev(gp.dat.rhalf[1], splrep(gp.xepol, np.log(annu))))
nrnu = -gh.derivipol(np.log(annu), np.log(gp.xepol))
dlrnu = np.hstack([nrnu[0], nrnu, nrnu[-1]])
if gp.investigate == 'gaia':
dlrnu[-1] = 6
nupar = np.hstack([nupar_half, dlrnu])
elif gp.checkbeta and gp.investigate == 'gaia':
# rhodmpar = np.array([ 0.41586608, 0.38655515, 0.60898657, 0.50936769, 0.52601378, 0.54526758, 0.5755599, 0.57900806, 0.60252357, 0.60668445, 0.62252721, 0.63173754, 0.64555439, 0.65777175, 0.67083556, 0.68506606, 0.69139872, 0.66304763, 0.61462276, 0.70916575, 0.53287872])
rhodmpar = np.array([
0.18235821, 0.4719348, 0., 0., 0.10029569, 0.11309553,
0.25637863, 0.31815175, 0.40621336, 0.46247927,
0.53545415, 0.60874961, 0.68978141, 0.79781574,
0.91218048, 1.08482356, 1.36074895, 1.88041885,
2.31792908, 2.62089078, 3.001
])
betapar = np.array([
1.23555034e-03, 9.89999994e-01, 2.03722518e+00,
5.85640906e+00
])
nupar = np.array([
0.15649498, 6.65618254, 0.10293663, 0.1087109,
0.13849277, 0.24371261, 0.62633345, 1.05913181,
1.43774113, 1.82346043, 2.20091446, 2.60007997,
2.98745825, 3.423104, 3.80766658, 4.2089698,
4.62950843, 4.91166037, 4.97380638, 4.99718073,
5.2277589
])
gp.dat.nrnu = [
np.array([
0.15476906, 0.85086798, 0.9342867, 0.88161169,
0.83254241, 0.85086798, 0.99930431, 1.22211638,
1.47184763, 1.78910057, 2.1987677, 2.51961046,
2.80345393, 3.10336133, 3.88504346, 4.52442727,
4.88817769, 5.07880404, 4.83455511, 6.32165657,
4.88817769
]),
np.array([
0.15476906, 0.85086798, 0.9342867, 0.88161169,
0.83254241, 0.85086798, 0.99930431, 1.22211638,
1.47184763, 1.78910057, 2.1987677, 2.51961046,
2.80345393, 3.10336133, 3.88504346, 4.52442727,
4.88817769, 5.07880404, 4.83455511, 6.32165657,
4.88817769
]),
np.array([
0.15476906, 0.85086798, 0.9342867, 0.88161169,
0.83254241, 0.85086798, 0.99930431, 1.22211638,
1.47184763, 1.78910057, 2.1987677, 2.51961046,
2.80345393, 3.10336133, 3.88504346, 4.52442727,
4.88817769, 5.07880404, 4.83455511, 6.32165657,
4.88817769
]),
np.array([
0.15476906, 0.85086798, 0.9342867, 0.88161169,
0.83254241, 0.85086798, 0.99930431, 1.22211638,
1.47184763, 1.78910057, 2.1987677, 2.51961046,
2.80345393, 3.10336133, 3.88504346, 4.52442727,
4.88817769, 5.07880404, 4.83455511, 6.32165657,
4.88817769
])
]
gp.dat.nrnuerr = [
np.array([
0.05158969, 12.22044422, 2.44408884, 2.44408884,
2.44408884, 2.44408884, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 2.44408884, 2.44408884, 2.44408884,
2.44408884
]),
np.array([
0.05158969, 12.22044422, 2.44408884, 2.44408884,
2.44408884, 2.44408884, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 2.44408884, 2.44408884, 2.44408884,
2.44408884
]),
np.array([
0.05158969, 12.22044422, 2.44408884, 2.44408884,
2.44408884, 2.44408884, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 2.44408884, 2.44408884, 2.44408884,
2.44408884
]),
np.array([
0.05158969, 12.22044422, 2.44408884, 2.44408884,
2.44408884, 2.44408884, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 0.48881777, 0.48881777, 0.48881777,
0.48881777, 2.44408884, 2.44408884, 2.44408884,
2.44408884
])
]
lbaryonpar = 0.0 * rhodmpar
MtoL = 0.0
sig, kap, zetaa, zetab = phys.sig_kap_zet(
gp.xepol, rhodmpar, lbaryonpar, MtoL, nupar, betapar, pop,
gp)
#fill_between(gp.xipol, gp.dat.sig[1]-gp.dat.sigerr[1], gp.dat.sig[1]+gp.dat.sigerr[1])
#plot(gp.xepol, sig, 'r')
#xscale('log')
#ylim([0, 30])
#xlabel('$r$ [pc]')
#ylabel('$\sigma_{LOS}$ [km/s]')
#savefig('siglos_gaia_2.pdf')
#pdb.set_trace()
except Exception:
gh.LOG(1, 'sigma error')
tmp_profs.chi2 = gh.err(2., gp)
return tmp_profs
# now store the profiles
gh.sanitize_vector(tmp_beta, len(tmp_profs.x0), -200, 1, gp.debug)
tmp_profs.set_prof('beta', tmp_beta, pop, gp)
gh.sanitize_vector(tmp_betastar, len(tmp_profs.x0), -1, 1,
gp.debug)
tmp_profs.set_prof('betastar', tmp_betastar, pop, gp)
tmp_profs.set_prof('sig', sig, pop, gp)
tmp_profs.hypersig = tmp_hypersig
tmp_profs.set_prof('kap', kap, pop, gp)
tmp_profs.set_zeta(zetaa, zetab, pop)
tmp_profs.set_prof('nrnu', tmp_nrnu, pop, gp)
tmp_profs.set_prof('nu', tmp_nu, pop, gp) # pool: tmp_nu.get()
# following profile needs to be stored at all times, to calculate chi
tmp_profs.set_prof('Sig', tmp_Signu, pop, gp)
tmp_profs.hyperSig = tmp_hyperSig
off += offstep # still do this even if gp.chi2_Sig_converged is False
if off != gp.ndim:
gh.LOG(1, 'wrong subscripts in gi_loglike')
pdb.set_trace()
# determine log likelihood
chi2 = calc_chi2(tmp_profs, gp)
gh.LOG(
-1, gp.investigate + '/' + str(gp.case) + '/' + gp.files.timestamp +
': ln L = ', gh.pretty(-chi2 / 2.))
# x=gp.dat.rbin
# linedat,=ax.loglog(x, gp.dat.Sig[1], 'b')
# line,=ax.loglog(x, tmp_profs.get_prof("Sig", 1), 'r', alpha=0.1)
# plt.draw()
# plt.show()
tmp_profs.chi2 = chi2
# after some predefined wallclock time and Sig convergence, plot all profiles
#if time.time() - gp.last_plot >= gp.plot_after and gp.chi2_Sig_converged <= 0:
# gp.last_plot = time.time()
# try:
# import plotting.plot_profiles
# plotting.plot_profiles.run(gp.files.timestamp, gp.files.outdir, gp)
# except:
# print('plotting error in gi_loglike!')
# close pool automatically after with clause
return tmp_profs
def geom_loglike(cube, ndim, nparams, gp):
tmp_profs = Profiles(gp.pops, gp.nipol)
off = 0
offstep = 1
norm = cube[off]
off += offstep
offstep = gp.nrho
rhodmpar = np.array(cube[off:off+offstep]) #SS cube[1:1+nrho]
tmp_rho = phys.rho(gp.xepol, rhodmpar, 0, gp)
tmp_profs.set_prof('rho', tmp_rho[gp.nexp:-gp.nexp], 0, gp)
off += offstep
offstep = gp.nrho
lbaryonpar = np.array(cube[off:off+offstep]) #SS cube[1+nrho:1+2*nrho]
tmp_rhostar = phys.rho(gp.xepol, lbaryonpar, 0, gp)[gp.nexp:-gp.nexp]
tmp_profs.set_prof('nu', tmp_rhostar, 0, gp) # [Munit/pc^3]
Sigstar = phys.nu_SUM_Sig(gp.dat.binmin, gp.dat.binmax, tmp_rhostar) # [Munit/pc^2]
tmp_profs.set_prof('Sig', Sigstar, 0, gp)
off += offstep
MtoL = cube[off] #SS cube[1+2*nrho]
off += 1
for pop in np.arange(1, gp.pops+1):
offstep = gp.nrho
nupar = np.array(cube[off:off+offstep]) #SS 1 cube[2+2*nrho:2+3*nrho]
tmp_nu = phys.rho(gp.xepol, nupar, pop, gp)[gp.nexp:-gp.nexp]
tmp_profs.set_prof('nu', tmp_nu, pop, gp) # [Munit/pc^3]
tmp_Sig = phys.nu_SUM_Sig(gp.dat.binmin, gp.dat.binmax, tmp_nu) # [Munit/pc^2]
tmp_profs.set_prof('Sig', tmp_Sig, pop, gp)
off += offstep
if gp.checksig:
pdb.set_trace()
offstep = gp.nbeta
if gp.chi2_nu_converged:
tiltpar = np.array(cube[off:off+offstep])#SS cube[2+3*nrho:..+nbeta]
tmp_tilt = phys.tilt(gp.xipol, tiltpar, gp)
if check_tilt(tmp_tilt, gp):
gh.LOG(1, 'tilt error')
tmp_profs.chi2 = gh.err(2., gp)
return tmp_profs
tmp_profs.set_prof('tilt', tmp_tilt, pop, gp)
sig = phys.sigz(gp.xepol, rhodmpar, lbaryonpar, MtoL, nupar, norm, tiltpar, pop, gp)
tmp_profs.set_prof('sig', sig, pop, gp)
# tmp_profs.set_prof('kap', kap, pop, gp)
off += offstep # add also in case Sig has not yet converged
# to get the right variables
if off != gp.ndim:
gh.LOG(1,'wrong subscripts in gi_class_cube')
raise Exception('wrong subscripts in gi_class_cube')
# determine log likelihood
chi2 = calc_chi2(tmp_profs, gp)
gh.LOG(1, ' log L = ', -chi2/2.)
tmp_profs.chi2 = chi2
return tmp_profs # from likelihood L = exp(-\chi^2/2), want log of that