Пример #1
0
    def read_zeta(self, gp):
        for pop in np.arange(gp.pops + 1):
            D1, D2, D3, zetaa, zetaaerr = gh.readcol5(gp.files.zetaafiles[pop])
            self.zetaa.append(zetaa)
            self.zetaaerr.append(zetaaerr)

            D1, D2, D3, zetab, zetaberr = gh.readcol5(gp.files.zetabfiles[pop])
            self.zetab.append(zetab)
            self.zetaberr.append(zetaberr)
        return
Пример #2
0
    def read_zeta(self, gp):
        for pop in np.arange(gp.pops+1):
            D1,D2,D3,zetaa,zetaaerr=gh.readcol5(gp.files.zetaafiles[pop])
            self.zetaa.append(zetaa)
            self.zetaaerr.append(zetaaerr)

            D1,D2,D3,zetab,zetaberr=gh.readcol5(gp.files.zetabfiles[pop])
            self.zetab.append(zetab)
            self.zetaberr.append(zetaberr)
        return
Пример #3
0
 def read_kappa(self, gp):
     for pop in np.arange(gp.pops+1):
         Dummy1, Dummy2, Dummy3, kapdat, kaperr = gh.readcol5(gp.files.kappafiles[pop])
         # 3*[Xscale], [1], [1]
         self.kap.append(kapdat) # [1]
         self.kaperr.append(kaperr) # [1]
     return
Пример #4
0
 def read_kappa(self, gp):
     for pop in np.arange(gp.pops + 1):
         Dummy1, Dummy2, Dummy3, kapdat, kaperr = gh.readcol5(
             gp.files.kappafiles[pop])
         # 3*[Xscale], [1], [1]
         self.kap.append(kapdat)  # [1]
         self.kaperr.append(kaperr)  # [1]
     return
Пример #5
0
 def read_sig(self, gp):
     # only ever use the tracer particles for velocity information
     self.sig.append(np.zeros(gp.nipol))
     self.sigerr.append(np.zeros(gp.nipol))
     for pop in np.arange(gp.pops):
         print('read_sig on file ', gp.files.sigfiles[pop+1])
         Dummy1, Dummy2, Dummy3, sigdat, sigerr = gh.readcol5(gp.files.sigfiles[pop+1])
         # 3*[Xscale], [maxsiglos], [maxsiglos]
         # change to km/s here
         self.sig.append(sigdat[:] * gp.maxsiglos[pop+1]) # [km/s]
         self.sigerr.append(sigerr[:] * gp.maxsiglos[pop+1]) # [km/s]
         self.barsig.append(np.mean(sigerr[:]*gp.maxsiglos[pop+1]))
     return
Пример #6
0
 def read_sig(self, gp):
     # only ever use the tracer particles for velocity information
     self.sig.append(np.zeros(gp.nipol))
     self.sigerr.append(np.zeros(gp.nipol))
     for pop in np.arange(gp.pops):
         print('read_sig on file ', gp.files.sigfiles[pop + 1])
         Dummy1, Dummy2, Dummy3, sigdat, sigerr = gh.readcol5(
             gp.files.sigfiles[pop + 1])
         # 3*[Xscale], [maxsiglos], [maxsiglos]
         # change to km/s here
         self.sig.append(sigdat[:] * gp.maxsiglos[pop + 1])  # [km/s]
         self.sigerr.append(sigerr[:] * gp.maxsiglos[pop + 1])  # [km/s]
         self.barsig.append(np.mean(sigerr[:] * gp.maxsiglos[pop + 1]))
     return
Пример #7
0
ip.insert_sys_path(basedir + 'programs/sphere')
import gi_params as ngip
ngp = ngip.Params(tt)
print(ngp)
print('ngp.rinfty = ', ngp.rinfty)
import select_run as sr
ngp.pops = sr.get_pops(basedir)
print('working with ', ngp.pops, ' populations')
prepare_output_folder(basedir)

# check whether we need to read in ngp.dat, or whether we are plotting from inside gravimage main program
if len(ngp.dat.Sig) == 0:
    import gi_file as glf
    ngp.dat = glf.get_binned_data(ngp)
read_scale(ngp)  # store half-light radii in  gp.Xscale
import gi_helper as gh
Radii, Binmin, Binmax, Sigdat1, Sigerr1 = gh.readcol5(ngp.files.Sigfiles[0])
# [Xscale0], [Munit/Xscale0^2]
# verified that indeed the stored files in the run directory are used
ngp.xipol = Radii * ngp.Xscale[0]  # [pc]
maxR = max(Radii)  # [pc]
minR = min(Radii)  # [pc]
Radii = np.hstack(
    [minR / 8, minR / 4, minR / 2, Radii, 2 * maxR, 4 * maxR, 8 * maxR])
ngp.xepol = Radii * ngp.Xscale[0]  # [pc]

pc = pcload_single_entries(basedir, ngp)

with open(basedir + 'pc', 'wb') as fn:
    pickle.dump(pc, fn)
Пример #8
0
    ip.insert_sys_path(basename+tt+'/programs/sphere')
    import gi_params as gip
    gp = gip.Params(tt)
    gp.pops = sr.get_pops(basename+tt+'/')
    print('working with ', gp.pops, ' populations')

    if len(pcall.chis) == 0:
        gh.LOG(1, 'no profiles found for plotting')
        sys.exit(1)
    # first plot all chi^2 values in histogram
    pcall.plot_profile(basename+tt+'/', 'chi2', 0, gp)
    # then select only the best models for plotting the profiles
    pcall.cut_subset()
    import gi_helper as gh
    read_scale(gp) # store half-light radii in  gp.Xscale
    Radii, Binmin, Binmax, Sigdat1, Sigerr1 = gh.readcol5(gp.files.Sigfiles[0])
    # [Xscale0], [Munit/Xscale0^2]
    # verified that indeed the stored files in the run directory are used
    gp.xipol = Radii * gp.Xscale[0]       # [pc]
    maxR = max(Radii)                     # [pc]
    minR = min(Radii)                     # [pc]
    Radii = np.hstack([minR/8, minR/4, minR/2, Radii, 2*maxR, 4*maxR, 8*maxR])
    gp.xepol = Radii * gp.Xscale[0]       # [pc]

    pcall.set_x0(gp.xepol, Binmin*gp.Xscale[0], Binmax*gp.Xscale[0]) # [pc]
    #if gp.investigate == 'obs':
    #pc.calculate_J(gp)

    if gp.investigate =='walk' or gp.investigate=='gaia' or gp.investigate =='triax':
        r0analytic = np.logspace(np.log10(1.), np.log10(max(gp.xepol)), 100)
        pcall.set_analytic(r0analytic, gp)
Пример #9
0
    def read_Sig(self, gp):
        for pop in np.arange(gp.pops+1):
            print('read_Sig on file ', gp.files.Sigfiles[pop])
            Sigx, binmin, binmax, Sigdat, Sigerr = gh.readcol5(gp.files.Sigfiles[pop])
            # 3*[rscale], [Sig0], [Sig0]
            # switch to Munit (msun) and pc here
            Sigx    = Sigx[:]    * gp.Xscale[pop]         # [pc]
            Sigdat  = Sigdat[:]  * gp.Sig0pc[pop]          # [Munit/pc^2]
            Sigerr  = Sigerr[:]  * gp.Sig0pc[pop]          # [Munit/pc^2]
            # take the overall bins for rbin, binmin, binmax vals
            if pop == 0:
                self.rbin = Sigx                                 # [pc]
                self.binmin = binmin * gp.Xscale[pop]           # [pc]
                self.binmax = binmax * gp.Xscale[pop]           # [pc]
                gp.xipol = self.rbin                            # [pc]
                minr = min(self.rbin)                           # [pc]
                maxr = max(self.rbin)                           # [pc]
                gp.xepol = np.hstack([minr/8., minr/4., minr/2., self.rbin, 2*maxr, 4*maxr, 8*maxr]) # [pc]
                gp.xfine = introduce_points_in_between(gp.xepol, gp)
            # deproject,
            # takes [pc], 2* [Munit/pc^2], gives [pc], 2* [Munit/pc^3],
            # already normalized to same total mass
            if gp.geom == 'sphere':
                Sigdatnu, Sigerrnu = gh.complete_nu(self.rbin, Sigdat, Sigerr, gp.xfine)
                dummyx, nudatnu, nuerrnu, Mrnu = gip.Sig_NORM_rho(gp.xfine, Sigdatnu, Sigerrnu, gp)
                self.nu_epol.append(gh.linipollog(gp.xfine, nudatnu, gp.xepol))
                self.nuerr_epol.append(gh.linipollog(gp.xfine, nuerrnu, gp.xepol))
                nudat = gh.linipollog(gp.xfine, nudatnu, gp.xipol)
                nuerr = gh.linipollog(gp.xfine, nuerrnu, gp.xipol)
                Mr = gh.linipollog(gp.xfine, Mrnu, gp.xipol)
                self.Mr.append(Mr) # [Munit]
                Mhalf = Mr[-1]/2.     # [Munit]
                self.Mhalf.append(Mhalf) # [Munit]
                # spline interpolation with M as x axis, to get half-mass of system:
                splpar_M = splrep(np.log(Mr), np.log(self.binmax), s=0.01)
                r_half = np.exp(splev(np.log(Mhalf), splpar_M)) # [pc]
                self.rhalf.append(r_half) # [pc]
                # spline interpolation of nu at r_half:
                splpar_nu = splrep(np.log(gp.xipol), np.log(nudat), s=0.01)
                nuhalf = np.exp(splev(np.log(r_half), splpar_nu)) # [pc]
                self.nuhalf.append(nuhalf)
                # [Munit/pc^3]
                # calculate n(r) parameters as used in gi_physics from the nu(r) profile
                rleft = gp.xfine[gp.xfine <= r_half]
                rleft = rleft[::-1]
                rright= gp.xfine[gp.xfine > r_half]
                nuleft = nudatnu[gp.xfine <= r_half]
                nuleft = nuleft[::-1]
                nuright = nudatnu[gp.xfine > r_half]
                rlast = 1.*r_half
                nulast = 1.*nuhalf
                sloperight = []
                for r0 in rright:
                    i = np.argmin(np.abs(rright - r0))
                    Deltanu = -(np.log(nuright[i]) - np.log(nulast))
                    Deltar  = np.log(rright[i]) - np.log(rlast)
                    sloperight.append(Deltanu/Deltar)
                    nulast = nuright[i]
                    rlast = rright[i]
                rlast = 1.*r_half
                nulast = 1.*nuhalf
                slopeleft = []
                # work through the array from the left, from r_half
                for r0 in rleft:
                    i = np.argmin(np.abs(rleft - r0))
                    Deltanu = np.log(nuleft[i]) - np.log(nulast)
                    Deltar  = np.log(rlast) - np.log(rleft[i])
                    slopeleft.append(Deltanu/Deltar)
                    nulast = nuleft[i]
                    rlast = rleft[i]
                # inverse order of slopeleft to have it sorted according increasing r
                slopeleft = slopeleft[::-1]
                slopes = np.hstack([slopeleft, sloperight])
                nrpar = 1.*slopes[:-1]
                # Deltalogr = np.log(gp.xfine[1:]) - np.log(gp.xfine[:-1])
                # nrpar = (slopes[1:]-slopes[:-1])/Deltalogr
                spl_nrpar = splrep(gp.xfine[:-1], nrpar, k=1)
                nre = splev( gp.xipol, spl_nrpar)
                extleft = splev(gp.xepol[0:3], spl_nrpar) # np.array([nrpar[0], nrpar[0], nrpar[0]])
                extright = splev(gp.xepol[-3:], spl_nrpar) #[nrpar[-1], nrpar[-1], nrpar[-1]])
                maxnre = max(nre)
                self.nrnu.append(np.hstack([nuhalf, nre[0], extleft, nre, extright, nre[-1]]))

                # checking for correct n(r) profile, have to wait for pop==1
                # if pop==1:
                # from pylab import plot, xscale
                # import gi_analytic as ga
                # testnu = ga.rho_gaia(gp.xfine,gp)[pop]
                # testnrnu = -gh.derivipol(np.log(testnu), np.log(gp.xfine))
                # plot(gp.xfine, testnrnu, 'b-')
                # plot(gp.xfine[:-1], nrpar, 'r.-')
                # xscale('log')

                errnre = np.ones(1+len(extleft)+len(nre)+len(extright)+1)*maxnre/10.
                for k in np.arange(1,4):
                    errnre[k-1] *= 5
                    errnre[-k] *= 5
                self.nrnuerr.append(np.hstack([nuhalf/3., errnre]))
                # import gi_physics as phys
                # from pylab import loglog, axvline, axhline, plot, xscale, clf
                # loglog(gp.xepol, self.nu_epol[0], 'b.-', lw=1)
                # axvline(r_half)
                # axhline(nuhalf)
                # rh = phys.rho(gp.xepol, self.nrnu, 0, gp)
                # rhmin = phys.rho(gp.xepol, self.nrnu - self.nrnuerr, 0, gp)
                # rhmax = phys.rho(gp.xepol, self.nrnu + self.nrnuerr, 0, gp)
                # loglog(gp.xepol, rh, 'r.-', linewidth=2)
                # loglog(gp.xepol, rhmin, 'g.-')
                # loglog(gp.xepol, rhmax, 'g--')
                # clf()
                # plot(gp.xfine[:-1], nrpar, '.-')
                # plot(gp.xipol, nre, '.-')
                # xscale('log')
                # axvline(r_half)
                # print(nrpar)
            else:
                gh.LOG(1, 'working in disc symmetry: reading nu directly')
                dummy1, dummy2, dummy3, nudat, nuerr = \
                        gh.readcol5(gp.files.nufiles[pop])
                self.nuhalf.append(nudat[round(len(nudat)/2)]) #HS ToDo: check validity of this
            self.Sig.append(Sigdat)    # [Munit/pc^2]
            self.Sigerr.append(Sigerr) # [Munit/pc^2]
            self.barSig.append(np.mean(Sigerr))
            self.nu.append(nudat)      # [Munit/pc^3]
            self.nuerr.append(nuerr)   # [Munit/pc^3]
        return
Пример #10
0
    def read_Sig(self, gp):
        for pop in np.arange(gp.pops + 1):
            print('read_Sig on file ', gp.files.Sigfiles[pop])
            Sigx, binmin, binmax, Sigdat, Sigerr = gh.readcol5(
                gp.files.Sigfiles[pop])
            # 3*[rscale], [Sig0], [Sig0]
            # switch to Munit (msun) and pc here
            Sigx = Sigx[:] * gp.Xscale[pop]  # [pc]
            Sigdat = Sigdat[:] * gp.Sig0pc[pop]  # [Munit/pc^2]
            Sigerr = Sigerr[:] * gp.Sig0pc[pop]  # [Munit/pc^2]
            # take the overall bins for rbin, binmin, binmax vals
            if pop == 0:
                self.rbin = Sigx  # [pc]
                self.binmin = binmin * gp.Xscale[pop]  # [pc]
                self.binmax = binmax * gp.Xscale[pop]  # [pc]
                gp.xipol = self.rbin  # [pc]
                minr = min(self.rbin)  # [pc]
                maxr = max(self.rbin)  # [pc]
                gp.xepol = np.hstack([
                    minr / 8., minr / 4., minr / 2., self.rbin, 2 * maxr,
                    4 * maxr, 8 * maxr
                ])  # [pc]
                gp.xfine = introduce_points_in_between(gp.xepol, gp)
            # deproject,
            # takes [pc], 2* [Munit/pc^2], gives [pc], 2* [Munit/pc^3],
            # already normalized to same total mass
            if gp.geom == 'sphere':
                Sigdatnu, Sigerrnu = gh.complete_nu(self.rbin, Sigdat, Sigerr,
                                                    gp.xfine)
                dummyx, nudatnu, nuerrnu, Mrnu = gip.Sig_NORM_rho(
                    gp.xfine, Sigdatnu, Sigerrnu, gp)
                self.nu_epol.append(gh.linipollog(gp.xfine, nudatnu, gp.xepol))
                self.nuerr_epol.append(
                    gh.linipollog(gp.xfine, nuerrnu, gp.xepol))
                nudat = gh.linipollog(gp.xfine, nudatnu, gp.xipol)
                nuerr = gh.linipollog(gp.xfine, nuerrnu, gp.xipol)
                Mr = gh.linipollog(gp.xfine, Mrnu, gp.xipol)
                self.Mr.append(Mr)  # [Munit]
                Mhalf = Mr[-1] / 2.  # [Munit]
                self.Mhalf.append(Mhalf)  # [Munit]
                # spline interpolation with M as x axis, to get half-mass of system:
                splpar_M = splrep(np.log(Mr), np.log(self.binmax), s=0.01)
                r_half = np.exp(splev(np.log(Mhalf), splpar_M))  # [pc]
                self.rhalf.append(r_half)  # [pc]
                # spline interpolation of nu at r_half:
                splpar_nu = splrep(np.log(gp.xipol), np.log(nudat), s=0.01)
                nuhalf = np.exp(splev(np.log(r_half), splpar_nu))  # [pc]
                self.nuhalf.append(nuhalf)
                # [Munit/pc^3]
                # calculate n(r) parameters as used in gi_physics from the nu(r) profile
                rleft = gp.xfine[gp.xfine <= r_half]
                rleft = rleft[::-1]
                rright = gp.xfine[gp.xfine > r_half]
                nuleft = nudatnu[gp.xfine <= r_half]
                nuleft = nuleft[::-1]
                nuright = nudatnu[gp.xfine > r_half]
                rlast = 1. * r_half
                nulast = 1. * nuhalf
                sloperight = []
                for r0 in rright:
                    i = np.argmin(np.abs(rright - r0))
                    Deltanu = -(np.log(nuright[i]) - np.log(nulast))
                    Deltar = np.log(rright[i]) - np.log(rlast)
                    sloperight.append(Deltanu / Deltar)
                    nulast = nuright[i]
                    rlast = rright[i]
                rlast = 1. * r_half
                nulast = 1. * nuhalf
                slopeleft = []
                # work through the array from the left, from r_half
                for r0 in rleft:
                    i = np.argmin(np.abs(rleft - r0))
                    Deltanu = np.log(nuleft[i]) - np.log(nulast)
                    Deltar = np.log(rlast) - np.log(rleft[i])
                    slopeleft.append(Deltanu / Deltar)
                    nulast = nuleft[i]
                    rlast = rleft[i]
                # inverse order of slopeleft to have it sorted according increasing r
                slopeleft = slopeleft[::-1]
                slopes = np.hstack([slopeleft, sloperight])
                nrpar = 1. * slopes[:-1]
                # Deltalogr = np.log(gp.xfine[1:]) - np.log(gp.xfine[:-1])
                # nrpar = (slopes[1:]-slopes[:-1])/Deltalogr
                spl_nrpar = splrep(gp.xfine[:-1], nrpar, k=1)
                nre = splev(gp.xipol, spl_nrpar)
                extleft = splev(
                    gp.xepol[0:3],
                    spl_nrpar)  # np.array([nrpar[0], nrpar[0], nrpar[0]])
                extright = splev(
                    gp.xepol[-3:],
                    spl_nrpar)  #[nrpar[-1], nrpar[-1], nrpar[-1]])
                maxnre = max(nre)
                self.nrnu.append(
                    np.hstack(
                        [nuhalf, nre[0], extleft, nre, extright, nre[-1]]))

                # checking for correct n(r) profile, have to wait for pop==1
                # if pop==1:
                # from pylab import plot, xscale
                # import gi_analytic as ga
                # testnu = ga.rho_gaia(gp.xfine,gp)[pop]
                # testnrnu = -gh.derivipol(np.log(testnu), np.log(gp.xfine))
                # plot(gp.xfine, testnrnu, 'b-')
                # plot(gp.xfine[:-1], nrpar, 'r.-')
                # xscale('log')

                errnre = np.ones(1 + len(extleft) + len(nre) + len(extright) +
                                 1) * maxnre / 10.
                for k in np.arange(1, 4):
                    errnre[k - 1] *= 5
                    errnre[-k] *= 5
                self.nrnuerr.append(np.hstack([nuhalf / 3., errnre]))
                # import gi_physics as phys
                # from pylab import loglog, axvline, axhline, plot, xscale, clf
                # loglog(gp.xepol, self.nu_epol[0], 'b.-', lw=1)
                # axvline(r_half)
                # axhline(nuhalf)
                # rh = phys.rho(gp.xepol, self.nrnu, 0, gp)
                # rhmin = phys.rho(gp.xepol, self.nrnu - self.nrnuerr, 0, gp)
                # rhmax = phys.rho(gp.xepol, self.nrnu + self.nrnuerr, 0, gp)
                # loglog(gp.xepol, rh, 'r.-', linewidth=2)
                # loglog(gp.xepol, rhmin, 'g.-')
                # loglog(gp.xepol, rhmax, 'g--')
                # clf()
                # plot(gp.xfine[:-1], nrpar, '.-')
                # plot(gp.xipol, nre, '.-')
                # xscale('log')
                # axvline(r_half)
                # print(nrpar)
            else:
                gh.LOG(1, 'working in disc symmetry: reading nu directly')
                dummy1, dummy2, dummy3, nudat, nuerr = \
                        gh.readcol5(gp.files.nufiles[pop])
                self.nuhalf.append(nudat[round(
                    len(nudat) / 2)])  #HS ToDo: check validity of this
            self.Sig.append(Sigdat)  # [Munit/pc^2]
            self.Sigerr.append(Sigerr)  # [Munit/pc^2]
            self.barSig.append(np.mean(Sigerr))
            self.nu.append(nudat)  # [Munit/pc^3]
            self.nuerr.append(nuerr)  # [Munit/pc^3]
        return