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
def __init__(self, pops, nepol): self.chis = [] self.goodchi = [] # will contain all chi^2 for models in self.subset self.goodprof = [] # will contain the corresponding profiles self.profs = [] self.subset = [0., np.inf] self.x0 = np.array([]) self.binmin = np.array([]) self.binmax = np.array([]) self.Mmin = Profiles(pops, nepol) self.M99lo = Profiles(pops, nepol) self.M95lo = Profiles(pops, nepol) self.M68lo = Profiles(pops, nepol) self.Mmedi = Profiles(pops, nepol) self.M68hi = Profiles(pops, nepol) self.M95hi = Profiles(pops, nepol) self.M99hi = Profiles(pops, nepol) self.Mmax = Profiles(pops, nepol) self.analytic = Profiles(pops, 100) initrange = [1e30, -1e30] self.ranges = {'rho0': initrange, 'nr0': initrange, 'M0': initrange, 'nu0': initrange, 'nu1': initrange, 'nu2': initrange, 'Sig0': initrange, 'Sig1': initrange, 'Sig2': initrange, 'sig1': initrange, 'sig2': initrange, 'nrnu0': initrange, 'nrnu1': initrange, 'nrnu2': initrange, 'beta1': initrange, 'beta2': initrange, 'betastar1': initrange, 'betastar2': initrange}
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
class ProfileCollection(): def __init__(self, pops, nepol): self.chis = [] self.goodchi = [] # will contain all chi^2 for models in self.subset self.goodprof = [] # will contain the corresponding profiles self.profs = [] self.subset = [0., np.inf] self.x0 = np.array([]) self.binmin = np.array([]) self.binmax = np.array([]) self.Mmin = Profiles(pops, nepol) self.M99lo = Profiles(pops, nepol) self.M95lo = Profiles(pops, nepol) self.M68lo = Profiles(pops, nepol) self.Mmedi = Profiles(pops, nepol) self.M68hi = Profiles(pops, nepol) self.M95hi = Profiles(pops, nepol) self.M99hi = Profiles(pops, nepol) self.Mmax = Profiles(pops, nepol) self.analytic = Profiles(pops, 100) initrange = [1e30, -1e30] self.ranges = {'rho0': initrange, 'nr0': initrange, 'M0': initrange, 'nu0': initrange, 'nu1': initrange, 'nu2': initrange, 'Sig0': initrange, 'Sig1': initrange, 'Sig2': initrange, 'sig1': initrange, 'sig2': initrange, 'nrnu0': initrange, 'nrnu1': initrange, 'nrnu2': initrange, 'beta1': initrange, 'beta2': initrange, 'betastar1': initrange, 'betastar2': initrange} ## \fn __init__(self, pops, nepol) # constructor # @param pops number of populations # @param nepol number of bins def broaden_lim(self, prof, pop, mini, maxi): dmin, dmax = self.ranges[prof+str(pop)] dmin = min(dmin, mini) dmax = max(dmax, maxi) self.ranges[prof+str(pop)] = [dmin, dmax] # overrule settings for n(r) plot if prof == 'nr': self.ranges[prof+str(pop)] = [-0.5, 4.0] return ## \fn broaden_lim(self, prof, pop, mini, maxi) # broaden the plotting range # @param prof string # @param pop int # @param mini new minimum # @param maxi new maximum def add(self, prof): if np.isnan(prof.chi2): return self.chis.append(prof.chi2) self.profs.append(prof) return ## \fn add(self, prof) # add a profile # @param prof Profile to add def merge(self, pc): self.chis = np.hstack([self.chis, pc.chis]) self.profs = np.hstack([self.profs, pc.profs]) ## \fn merge(self, pc) # merge another profile collection into this one def cut_subset(self): self.chis = np.array(self.chis) # better to work with numpy arrays for subsections minchi = min(self.chis) if USE_ALL: maxchi = max(self.chis) else: counts, bins = np.histogram(np.log10(self.chis), bins=np.sqrt(len(self.chis))) posmax = np.argmin(np.abs(counts-max(counts))) for k in range(posmax, len(counts)-1): if counts[k+1] > counts[k] or counts[k+1]==0 or counts[k+1]<=max(counts)/10: break maxchi = min(30*min(self.chis),10**(bins[k+1])) self.subset = [minchi, maxchi] print('chi^2 subset: ',minchi, maxchi) ## \fn cut_subset(self) # set subset to [0, 10*min(chi)] (or 30* minchi, or any value wished) def set_x0(self, x0, Binmin, Binmax): self.binmin = Binmin self.binmax = Binmax self.x0 = x0 self.Mmin.x0 = x0 self.M99lo.x0 = x0 self.M95lo.x0 = x0 self.M68lo.x0 = x0 self.Mmedi.x0 = x0 self.M68hi.x0 = x0 self.M95hi.x0 = x0 self.M99hi.x0 = x0 self.Mmax.x0 = x0 ## \fn set_x0(self, x0) # set radii for 1sigma, 2sigma profiles # @param x0 radii in pc # @param Binmin minimal radii of bins in [pc] # @param Binmax maximal radii of bins in [pc] def sort_prof(self, prof, pop, gp): self.goodprof = [] self.goodchi = [] for k in range(len(self.profs)): if self.subset[0] <= self.chis[k] <= self.subset[1]: self.goodprof.append(self.profs[k].get_prof(prof, pop)) self.goodchi.append(self.chis[k]) tmp = gh.sort_profiles_binwise(np.array(self.goodprof).transpose()).transpose() ll = len(tmp) #norm = 1 #if prof == 'Sig': # norm = gh.ipol_rhalf_log(gp.xepol, tmp[ll/2], gp.Xscale[0]) self.Mmin.set_prof(prof, tmp[0], pop, gp) self.M99lo.set_prof(prof, tmp[ll*0.01], pop, gp) self.M95lo.set_prof(prof, tmp[ll*0.05], pop, gp) self.M68lo.set_prof(prof, tmp[ll*0.32], pop, gp) self.Mmedi.set_prof(prof, tmp[ll/2], pop, gp) self.M68hi.set_prof(prof, tmp[ll*0.68], pop, gp) self.M95hi.set_prof(prof, tmp[ll*0.95], pop, gp) self.M99hi.set_prof(prof, tmp[ll*0.99], pop, gp) self.Mmax.set_prof(prof, tmp[-1], pop, gp) return tmp ## \fn sort_prof(self, prof, pop, gp) # sort the list of prof-profiles, and store the {1,2}sigma, min, medi, max in the appropriate place # @param prof profile identifier, 'rho', 'beta', ... # @param pop population identifier # @param gp global parameters # @return tmp profiles sorted binwise def calculate_J(self, gp): if len(self.profs)>0: for i in range(len(self.profs)): Sigprof = gip.rho_INT_Sig(gp.xepol, self.profs[i].get_prof('rho', 0), gp) Jprof = gip.Jpar(gp.xepol, Sigprof, gp) # add 3 extension bins tck = splrep(np.log(gp.xepol[:-gp.nexp]), np.log(Jprof), k=1, s=0.1) Jext = np.exp(splev(np.log(gp.xepol[-gp.nexp:]), tck)) Jfull = np.hstack([Jprof, Jext]) for k in range(gp.nepol): Jfull[k] = max(0, Jfull[k]) self.profs[i].set_prof('J', Jfull, 0, gp) else: gh.LOG(1, 'len(self.profs) == 0, did not calculate self.profs.J') ## \fn calculate_J(self, gp) # calculate J from Sig from rho # @param gp global parameters def sort_profiles(self, gp): self.sort_prof('rho', 0, gp) self.sort_prof('M', 0, gp) self.sort_prof('Sig', 0, gp) self.sort_prof('nr', 0, gp) self.sort_prof('nrnu', 0, gp) self.sort_prof('nu', 0, gp) for pop in np.arange(1, gp.pops+1): self.sort_prof('betastar', pop, gp) self.sort_prof('beta', pop, gp) self.sort_prof('nu', pop, gp) self.sort_prof('nrnu', pop, gp) self.sort_prof('Sig', pop, gp) self.sort_prof('sig', pop, gp) return ## \fn sort_profiles(self, gp) # sort all profiles, in a parallel way # @param gp global parameters def set_analytic(self, x0, gp): r0 = x0 # [pc], spherical case self.analytic.x0 = r0 anbeta = []; annu = []; anSig = [] if gp.investigate == 'gaia': anrho = ga.rho_gaia(r0, gp)[0] anM = gip.rho_SUM_Mr(r0, anrho) annr = ga.nr3Dtot_gaia(r0, gp) tmp_annu = ga.rho_gaia(r0, gp)[1] annu.append( tmp_annu ) anSig.append( gip.rho_INT_Sig(r0, tmp_annu, gp) ) for pop in np.arange(1, gp.pops+1): beta = ga.beta_gaia(r0, gp)[pop] anbeta.append(beta) nu = ga.rho_gaia(r0,gp)[pop] annu.append(nu) anSig.append(gip.rho_INT_Sig(r0, nu, gp)) elif gp.investigate == 'walk': anrho = ga.rho_walk(r0, gp)[0] anM = gip.rho_SUM_Mr(r0, anrho) annr = ga.nr3Dtot_deriv_walk(r0, gp) # TODO too high in case of core tmp_annu = ga.rho_walk(r0, gp)[1] annu.append( tmp_annu ) anSig.append( gip.rho_INT_Sig(r0, tmp_annu, gp) ) for pop in np.arange(1, gp.pops+1): beta = ga.beta_walk(r0, gp)[pop] anbeta.append(beta) nu = ga.rho_walk(r0, gp)[pop] dum,dum,dum,nudat,nuerr = np.transpose(np.loadtxt(gp.files.nufiles[pop], unpack=False, skiprows=1)) locrhalf = np.argmin(abs(gp.xipol-gp.Xscale[pop])) nuhalf = nudat[locrhalf]*gp.nu0pc[pop] annuhalf = nu[np.argmin(abs(r0-locrhalf))] annu.append(nu*nuhalf/annuhalf) dum,dum,dum,Sigdat,Sigerr = np.transpose(np.loadtxt(gp.files.Sigfiles[pop], unpack=False, skiprows=1)) locrhalf = np.argmin(abs(gp.xipol-gp.Xscale[pop])) Sighalf = Sigdat[locrhalf]*gp.Sig0pc[pop] Sig = gip.rho_INT_Sig(r0, nu, gp) anSighalf = Sig[np.argmin(abs(r0-locrhalf))] anSig.append(Sig*Sighalf/anSighalf) elif gp.investigate == 'triax': anrho = ga.rho_triax(r0, gp) # one and only anM = gip.rho_SUM_Mr(r0, anrho) annr = ga.nr3Dtot_deriv_triax(r0, gp) tmp_annu = ga.rho_triax(r0, gp) # TODO, M/L=1 assumed here, wrong annu.append(tmp_annu) anSig.append( gip.rho_INT_Sig(r0, tmp_annu, gp)) for pop in np.arange(1, gp.pops+1): beta = ga.beta_triax(r0) anbeta.append(beta) nu = ga.rho_triax(r0, gp) # TODO, assumes M/L=1 annu.append(nu) anSig.append( gip.rho_INT_Sig(r0, nu, gp)) self.analytic.set_prof('rho', anrho, 0, gp) self.analytic.set_prof('M', anM, 0, gp) self.analytic.set_prof('nr', annr, 0, gp) self.analytic.set_prof('nu', annu[0], 0, gp) self.analytic.set_prof('nrnu', -gh.derivipol(np.log(annu[0]), np.log(r0)), 0, gp) self.analytic.set_prof('Sig', anSig[0], 0, gp) for pop in np.arange(1, gp.pops+1): self.analytic.set_prof('beta', anbeta[pop-1], pop, gp) self.analytic.set_prof('betastar', anbeta[pop-1]/(2.-anbeta[pop-1]), pop, gp) self.analytic.set_prof('nu', annu[pop], pop, gp) nrnu = -gh.derivipol(np.log(annu[pop]), np.log(r0)) self.analytic.set_prof('nrnu', nrnu, pop, gp) self.analytic.set_prof('Sig', anSig[pop] , pop, gp)#/ Signorm, pop, gp) self.analytic.set_prof('sig', -np.ones(len(r0)), pop, gp) return ## \fn set_analytic(x0, gp) # set analytic curves (later shown in blue) # @param x0 radius in [pc] # @param gp global parameters def write_prof(self, basename, prof, pop, gp): output = go.Output() uni = unit(prof) output.add('radius (models) [pc]', gp.xepol) output.add('M 99% CL low ' + uni, self.M99lo.get_prof(prof, pop)) output.add('M 95% CL low ' + uni, self.M95lo.get_prof(prof, pop)) output.add('M 68% CL low ' + uni, self.M68lo.get_prof(prof, pop)) output.add('M median ' + uni, self.Mmedi.get_prof(prof, pop)) output.add('M 68% CL high '+ uni, self.M68hi.get_prof(prof, pop)) output.add('M 95% CL high '+ uni, self.M95hi.get_prof(prof, pop)) output.add('M 99% CL high '+ uni, self.M99hi.get_prof(prof, pop)) output.write(basename+'output/ascii/prof_'+prof+'_'+str(pop)+'.ascii') if (gp.investigate =='walk' or gp.investigate=='gaia') \ and (prof != 'Sig'): out_an = go.Output() out_an.add('radius [pc]', self.analytic.x0) out_an.add('analytic profile', self.analytic.get_prof(prof, pop)) out_an.write(basename+'output/analytic/prof_'+prof+'_'+str(pop)+'.analytic') ## \fn write_prof(self, basename, prof, pop, gp) # write output file for a single profile # @param basename directory string # @param prof string for profile. rho, nr, betastar, ... # @param pop population int # @param gp global parameters def write_chi2(self, basename, edges, bins): output = go.Output() output.add('edges', edges[1:]) output.add('bins', bins) output.write(basename+'output/prof_chi2_0.ascii') return ## \fn write_chi2(self, basename, edges, bins) # write ascii file with chi2 information # @param basename directory string # @param edges array of edges # @param bins y-values def write_all(self, basename, gp): self.write_prof(basename, 'rho', 0, gp) #self.write_prof(basename, 'J', 0, gp) if gp.geom == 'sphere': self.write_prof(basename, 'M', 0, gp) self.write_prof(basename, 'Sig', 0, gp) self.write_prof(basename, 'nu', 0, gp) self.write_prof(basename, 'nrnu', 0, gp) if gp.geom=='sphere': self.write_prof(basename, 'nr', 0, gp) for pop in np.arange(1, gp.pops+1): self.write_prof(basename, 'betastar', pop, gp) self.write_prof(basename, 'beta', pop, gp) self.write_prof(basename, 'Sig', pop, gp) self.write_prof(basename, 'nu', pop, gp) self.write_prof(basename, 'nrnu', pop, gp) self.write_prof(basename, 'sig', pop, gp) ## \fn write_all(self, basename, gp) # write output files for all profiles # @param basename directory string # @param gp global parameters def plot_N_samples(self, ax, prof, pop): k=0 while k<30: ind = npr.randint(len(self.profs)) if self.subset[0] <= self.chis[ind] <= self.subset[1]: lp = self.profs[ind] ax.plot(self.Mmedi.x0, lp.get_prof(prof, pop), color='black', alpha=0.1, lw=0.25) k += 1 return ## \fn plot_N_samples(self, ax, prof, pop) # plot 30 sample profiles on top of the model {1,2} sig boundaries # @param ax axis object to draw upon # @param prof string # @param pop integer for which population def plot_data(self, ax, basename, prof, pop, gp): output = go.Output() r0 = gp.xipol # [pc] output.add('radius (data) [pc]', r0) if prof == 'Sig': # get 2D data here # Rbin [Xscale], Binmin [Xscale], Binmax [Xscale], Sig(R)/Sig(0) [1], error [1] dum,dum,dum,Sigdat,Sigerr = np.transpose(np.loadtxt(gp.files.Sigfiles[pop], unpack=False, skiprows=1)) Sigdat *= gp.Sig0pc[pop] # [Msun/pc^2] Sigerr *= gp.Sig0pc[pop] # [Msun/pc^2] #Signorm = gh.ipol_rhalf_log(gp.xipol, Sigdat, gp.Xscale[pop]) output.add('data [Msun/pc^2]', Sigdat) output.add('error [Msun/pc^2]', Sigerr) output.add('data - error [Msun/pc^2]', Sigdat-Sigerr) output.add('data + error [Msun/pc^2]', Sigdat+Sigerr) ax.fill_between(r0, Sigdat-Sigerr, Sigdat+Sigerr, color='blue', alpha=0.3, lw=1) self.broaden_lim('Sig', pop, min(Sigdat-Sigerr)/2, 2*max(Sigdat+Sigerr)) elif prof == 'nu': # get 3D data here # Rbin [Xscale], Binmin [Xscale], Binmax [Xscale], nu(R)/nu(0) [1], error [1] dum,dum,dum,nudat,nuerr = np.transpose(np.loadtxt(gp.files.nufiles[pop], unpack=False, skiprows=1)) nudat *= gp.nu0pc[pop] # [Msun/pc^2] nuerr *= gp.nu0pc[pop] # [Msun/pc^2] output.add('data [Msun/pc^3]', nudat) output.add('error [Msun/pc^3]', nuerr) output.add('data - error [Msun/pc^2]', nudat-nuerr) output.add('data + error [Msun/pc^2]', nudat+nuerr) ax.fill_between(r0, nudat-nuerr, nudat+nuerr, color='blue', alpha=0.3, lw=1) self.broaden_lim('nu', pop, min(nudat-nuerr)/2., 2*max(nudat+nuerr)) elif prof == 'sig': DATA = np.transpose(np.loadtxt(gp.files.sigfiles[pop], unpack=False, skiprows=1)) sigdat = DATA[4-1] # [maxsiglosi] sigerr = DATA[5-1] # [maxsiglosi] sigdat *= gp.maxsiglos[pop] # [km/s] sigerr *= gp.maxsiglos[pop] # [km/s] output.add('data [km/s]', sigdat) output.add('error [km/s]', sigerr) output.add('data - error [km/s]', sigdat-sigerr) output.add('data + error [km/s]', sigdat+sigerr) ax.fill_between(r0, sigdat-sigerr, sigdat+sigerr, color='blue', alpha=0.3, lw=1) self.broaden_lim('sig', pop, 0., 2*max(sigdat+sigerr)) output.write(basename+'output/data/prof_'+prof+'_'+str(pop)+'.data') return ## \fn plot_data(self, ax, basename, prof, pop, gp) # plot data as blue shaded region # @param ax axis object # @param basename string # @param prof string of profile # @param pop which population to analyze: 0 (all), 1, 2, ... # @param gp global parameters def plot_labels(self, ax, prof, pop, gp): if prof=='chi2': ax.set_xlabel('$\\log_{10}\\chi^2$') ax.set_ylabel('frequency') else: ax.set_xlabel('$R\\quad[\\rm{pc}]$') if prof == 'rho': ax.set_ylabel('$\\rho\\quad[\\rm{M}_\\odot/\\rm{pc}^3]$') elif prof == 'M': ax.set_ylabel('$M(r)$') elif prof == 'nr': ax.set_ylabel('$n(r)$') self.broaden_lim('nr', 0, -1, 5) elif prof == 'beta': ax.set_ylabel('$\\beta_'+str(pop)+'$') self.broaden_lim('beta', pop, -1.05, 1.05) elif prof == 'betastar': ax.set_ylabel('$\\beta^*_'+str(pop)+'$') self.broaden_lim('betastar', pop, -1.05, 1.05) elif prof == 'Sig' and pop > 0: ax.set_ylabel('$\\Sigma_'+str(pop)+'\\quad[\\rm{M}_\\odot/\\rm{pc}^2]$') elif prof == 'Sig' and pop == 0: ax.set_ylabel('$\\Sigma^*\\quad[\\rm{M}_\\odot/\\rm{pc}^2]$') elif prof == 'nu' and pop > 0: ax.set_ylabel('$\\nu_'+str(pop)+'\\quad[\\rm{M}_\\odot/\\rm{pc}^3]$') elif prof == 'nu' and pop == 0: ax.set_ylabel('$\\rho^*\\quad[\\rm{M}_\\odot/\\rm{pc}^3]$') elif prof == 'nrnu': ax.set_ylabel('$n_{\\nu,'+str(pop)+'}(r)$') elif prof == 'sig': ax.set_ylabel('$\\sigma_{\\rm{LOS},'+str(pop)+'}\\quad[\\rm{km}/\\rm{s}]$') return ## \fn plot_labels(self, ax, prof, pop, gp) # draw x and y labels # @param ax axis object to use # @param prof string of profile to look at # @param pop which population to analyze: 0 (all), 1, 2, ... # @param gp global parameters def plot_Xscale_3D(self, ax, gp): rmin = np.log10(min(gp.xipol)) rmax = np.log10(max(gp.xipol)) gp.xfine = np.logspace(rmin, rmax, gp.nfine) if gp.investigate == 'walk': if gp.pops == 1: rhodm, nu1 = ga.rho_walk(gp.xepol, gp) else: rhodm, nu1, nu2 = ga.rho_walk(gp.xepol, gp) elif gp.investigate == 'gaia': rhodm, nu1 = ga.rho_gaia(gp.xepol, gp) for pop in range(gp.pops): # use our models nuprof = self.Mmedi.get_prof('nu', pop+1) tck = splrep(gp.xepol, nuprof) nuproffine = splev(gp.xfine, tck) if gp.investigate == 'walk' or gp.investigate == 'gaia': # or rather use analytic values, where available if pop == 0: nuprof = nu1 elif pop == 1: nuprof = nu2 if gp.geom == 'sphere': Mprof = gip.rho_SUM_Mr(gp.xfine, nuproffine) Mmax = max(Mprof) # Mprof[-1] ihalf = -1 for kk in range(len(Mprof)): # half-light radius (3D) is where mass is more than half # ihalf gives the iindex of where this happens if Mprof[kk] >= Mmax/2 and ihalf < 0: xx = (gp.xfine[kk-1]+gp.xfine[kk])/2 print('rhalf = ', xx, ' pc') ax.axvline(xx, color='green', lw=0.5, alpha=0.7) ihalf = kk ## \fn plot_Xscale_3D(ax, gp) # plot 3D half-light radii, based on median nu model # @param ax axis object # @param gp global parameters def plot_full_distro(self, ax, prof, pop, gp): x = self.x0 y = self.sort_prof(prof, pop, gp) # gives [Nmodels, Nbin] shape matrix Nvertbin = np.sqrt(len(y[:,0])) xbins = np.hstack([self.binmin, self.binmax[-1]]) ybins = np.linspace(min(y[:,:]), max(y[:,:]), num=Nvertbin) H, xedges, yedges = np.histogram2d(x, y, bins=[xbins, ybins]) fig, ax = plt.subplots(figsize=(8, 8), dpi=80, facecolor='w', edgecolor='k') ax.set_xlim([self.x[0],self.x0[-1]]) extent = [min(xbins), max(xbins), min(ybins), max(ybins)] im = ax.imshow(H.T, extent=extent, aspect='auto', interpolation='nearest', cmap=plt.cm.binary) #plt.cm.Blues) fig.colorbar(im) if prof == 'Sig' or prof == 'sig': for pop in range(gp.pops): ax.axvline(gp.Xscale[pop+1], color='blue', lw=0.5) # [pc] else: self.plot_Xscale_3D(ax, gp) return ## \fn plot_full_distro(self, ax, prof, pop, gp) # plot filled region with grayscale propto # models in log bin # @param ax axis object to plot into # @param prof string # @param pop int # @param gp def fill_nice(self, ax, prof, pop, gp): M99lo = self.M99lo.get_prof(prof, pop) M95lo = self.M95lo.get_prof(prof, pop) M68lo = self.M68lo.get_prof(prof, pop) Mmedi = self.Mmedi.get_prof(prof, pop) r0 = gp.xepol M68hi = self.M68hi.get_prof(prof, pop) M95hi = self.M95hi.get_prof(prof, pop) M99hi = self.M99hi.get_prof(prof, pop) #print('lengths:', len(r0), len(M95lo), len(M95hi)) #print('min max M95: ', min(M95lo), max(M95lo), prof) ax.fill_between(r0, M99lo, M99hi, color='black', alpha=0.1, lw=0.1) ax.plot(r0, M99lo, color='black', lw=0.4) ax.plot(r0, M99hi, color='black', lw=0.3) ax.fill_between(r0, M95lo, M95hi, color='black', alpha=0.2, lw=0.1) ax.plot(r0, M95lo, color='black', lw=0.4) ax.plot(r0, M95hi, color='black', lw=0.3) ax.fill_between(r0, M68lo, M68hi, color='black', alpha=0.4, lw=0.1) ax.plot(r0, M68lo, color='black', lw=0.4) ax.plot(r0, M68hi, color='black', lw=0.3) ax.plot(r0, Mmedi, 'r', lw=1) if prof == 'Sig' or prof == 'sig': for pop in range(gp.pops): ax.axvline(gp.Xscale[pop+1], color='blue', lw=0.5) # [pc] else: self.plot_Xscale_3D(ax, gp) ax.set_xlim([r0[0], r0[-1]]) if prof == 'beta' or prof == 'betastar': self.broaden_lim('beta', pop, -1, 1) self.broaden_lim('betastar', pop, -1, 1) elif prof == 'nr': self.broaden_lim('nr', pop, -0.5, 5) elif prof == 'nrnu': self.broaden_lim('nrnu', pop, 0., max(M95hi)) elif prof == 'M': self.broaden_lim('M', 0, min(M68lo), max(M68hi)) elif prof == 'rho': self.broaden_lim('rho', 0, min(M68lo), max(M68hi)) elif prof == 'nu': self.broaden_lim('nu', pop, min(M68lo), max(M68hi)) return ## \fn fill_nice(self, ax, prof, pop, gp) # plot filled region for 1sigma and 2sigma confidence interval # @param ax axis object to plot into # @param prof string # @param pop int # @param gp def plot_profile(self, basename, prof, pop, gp): gh.LOG(1, 'prof '+str(prof)+', pop '+str(pop)+', run '+basename) fig = plt.figure() ax = fig.add_subplot(111) if prof != 'chi2': ax.set_xscale('log') if prof == 'rho' or prof == 'J' or prof == 'Sig' or\ prof == 'M' or prof == 'nu': ax.set_yscale('log') self.plot_labels(ax, prof, pop, gp) if len(self.profs)>0: if prof == 'chi2': goodchi = [] for k in range(len(self.profs)): # do include all chi^2 values for plot goodchi.append(self.chis[k]) print('plotting profile chi for '+str(len(goodchi))+' models') bins, edges = np.histogram(np.log10(goodchi), range=[-2,6], \ bins=max(6,np.sqrt(len(goodchi))),\ density=True) ax.step(edges[1:], bins, where='pre') plt.draw() self.write_chi2(basename, edges, bins) fig.savefig(basename+'output/prof_chi2_0.pdf') return self.fill_nice(ax, prof, pop, gp) # TODO: replace above with full distribution plot (has bugs, # File "programs/plotting/gi_collection.py", line 466, in plot_full_distro # ybins = np.linspace(min(y[:,:]), max(y[:,:]), num=Nvertbin) # ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() #self.plot_full_distro(ax, prof, pop, gp) self.plot_N_samples(ax, prof, pop) if prof == 'Sig' or prof == 'sig': self.plot_data(ax, basename, prof, pop, gp) if (gp.investigate == 'gaia' or gp.investigate=='triax') and prof != 'sig' or (gp.investigate=='walk' and prof!='sig' and prof!='nu' and prof!='Sig'): r0 = self.analytic.x0 y0 = self.analytic.get_prof(prof, pop) self.broaden_lim(prof, pop, min(y0), max(y0)) ax.plot(r0, y0, 'b--', lw=2) ax.set_ylim(self.ranges[prof+str(pop)]) plt.draw() else: gh.LOG(1, 'empty self.profs') fig.savefig(basename+'output/pdf/prof_'+prof+'_'+str(pop)+'.pdf') return 1 ## \fn plot_profile(self, basename, prof, pop, gp) # plot single profile # @param basename # @param prof string of profile to look at # @param pop population number # @param gp global parameters def __repr__(self): return "Profile Collection with "+str(len(self.profs))+" Profiles"
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