def POTDEF1(z, TheTa2): TheTa = np.sqrt(TheTa2**2 + theta1[l]**2) R = D_d * TheTa MN_Bulge_p = MiyamotoNagaiPotential(amp=M1, a=0, b=b1, normalize=False) Sigma = MN_Bulge_p.dens(R, z) kappa = Sigma / SIGMA_CRIT return (4 / theta2[l]) * TheTa2 * kappa / SIGMA_CRIT**2
def MWPotentialSCFbar_nogrow(mbar,Acos,Asin,rs=1.,normalize=False,pat_speed=40.,fin_phi_deg=27.,t_stream_age=5.): a=rs/ro omegaP=pat_speed*(ro/vo) fin_phi= np.radians(fin_phi_deg) #init_phi= fin_phi - o_p*(tpal5age*Gyr_to_s) init_phi= fin_phi - omegaP*t_stream_age/bovy_conversion.time_in_Gyr(vo,ro) mrat=mbar/10.**10. #10^10 mass of bar used to compute Acos and Asin static_bar=potential.SCFPotential(amp=mrat,Acos=Acos,Asin=Asin,a=a,normalize=normalize) #Note only m=0 terms are considered static_axi_bar=potential.SCFPotential(amp=mrat,Acos=np.atleast_3d(Acos[:,:,0]),a=a) barrot=potential.SolidBodyRotationWrapperPotential(pot=static_bar,omega=omegaP,ro=ro,vo=vo,pa=init_phi) if mbar <= 5.*10**9. : MWP2014SCFbar=[MWPotential2014[0],MiyamotoNagaiPotential(amp=(6.8-mrat)*10.**10*u.Msun,a=3./8.,b=0.28/8.),MWPotential2014[2],barrot] turn_physical_off(MWP2014SCFbar) #setup the corresponding axisymmetric bar MWP2014SCFnobar= [MWPotential2014[0],MiyamotoNagaiPotential(amp=(6.8-mrat)*10.**10*u.Msun,a=3./8.,b=0.28/8.),MWPotential2014[2],static_axi_bar] turn_physical_off(MWP2014SCFnobar) else : MWP2014SCFbar=[MiyamotoNagaiPotential(amp=(6.8+0.5-mrat)*10.**10*u.Msun,a=3./8.,b=0.28/8.),MWPotential2014[2],barrot] turn_physical_off(MWP2014SCFbar) MWP2014SCFnobar= [MiyamotoNagaiPotential(amp=(6.8+0.5-mrat)*10.**10*u.Msun,a=3./8.,b=0.28/8.),MWPotential2014[2],static_axi_bar] turn_physical_off(MWP2014SCFnobar) return (MWP2014SCFbar,MWP2014SCFnobar)
def test_TimeInterpPotential(): #Just to check that the code above has run properly from galpy.potential import LogarithmicHaloPotential, \ MiyamotoNagaiPotential lp= LogarithmicHaloPotential(normalize=1.) mp= MiyamotoNagaiPotential(normalize=1.) tip= TimeInterpPotential(lp,mp) assert numpy.fabs(tip.Rforce(1.,0.1,t=10.)-lp.Rforce(1.,0.1)) < 10.**-8., 'TimeInterPotential does not work as expected' assert numpy.fabs(tip.Rforce(1.,0.1,t=200.)-mp.Rforce(1.,0.1)) < 10.**-8., 'TimeInterPotential does not work as expected' return None
def integ(z, TheTa1, TheTa2): TheTa = np.sqrt(TheTa1**2 + TheTa2**2) R = D_d * TheTa MN_Bulge_p = MiyamotoNagaiPotential(amp=MN_M, a=MN_a, b=MN_b, normalize=False) Densidad = MN_Bulge_p.dens(R, z) Kappa = 2 * Densidad return Kappa / (SIGMA_CRIT**2)
def minimize_function(x, rho_nfw_target, rho_midplane_target, density_conversion): """ Computes the chi^2 penalty for a galactic potential for the purpose of finding an NFWPotential and MiyamotoNagaiPotential circular velocity normalization that yeild the desired midplane and nfw physical densities :param x: numpy array of proposed disk and nfw circular velocity normalizations (in that order) :param rho_nfw_target: desired nfw_normalization in physical M_sun / pc^2 :param rho_midplane_target: desired midplane density in physical M_sun / pc^2 :param density_conversion: a conversion factor between galpy internal density units and physical M_sun / pc^2 :return: chi^2 penalty """ galactic_potential = [ PowerSphericalPotentialwCutoff(normalize=0.05, alpha=1.8, rc=1.9 / 8.), MiyamotoNagaiPotential(a=3. / 8., b=0.28 / 8., normalize=x[0]), NFWPotential(a=2., normalize=x[1]) ] nfw_potential = NFWPotential(a=2., normalize=x[1]) rho = evaluateDensities(galactic_potential, R=1., z=0.) * density_conversion rho_nfw = evaluateDensities(nfw_potential, R=1, z=0.) * density_conversion dx = (rho - rho_midplane_target)**2 / 0.000001**2 + ( rho_nfw - rho_nfw_target)**2 / 0.000001**2 return dx**0.5
def setup(self): nfw_norm = [0.2, 0.4, 0.6] disk_norm = [0.15, 0.3, 0.45] scale_height = [0.25, 0.27, 0.29] pot_list = [] for normnfw in nfw_norm: for normdisk in disk_norm: for scale_h in scale_height: pot = [ PowerSphericalPotentialwCutoff(normalize=0.05, alpha=1.8, rc=1.9 / 8.), MiyamotoNagaiPotential(a=3. / 8., b=scale_h / 8., normalize=normdisk), NFWPotential(a=2., normalize=normnfw) ] pot_extension = PotentialExtension( pot, 2, 120, 3, compute_action_angle=True) pot_list.append(pot_extension) self.disk_norm = disk_norm self.nfw_norm = nfw_norm self.scale_height = scale_height self.pot_list = pot_list self.tabulated_potential = TabulatedPotential3D( self.pot_list, self.nfw_norm, self.disk_norm, self.scale_height)
def setup(self): nfw_norm = [0.2, 0.4, 0.6] disk_norm = [0.15, 0.3, 0.45] pot_list = [] for normnfw in nfw_norm: for normdisk in disk_norm: pot = [ PowerSphericalPotentialwCutoff(normalize=0.05, alpha=1.8, rc=1.9 / 8.), MiyamotoNagaiPotential(a=3. / 8., b=0.28 / 8., normalize=normdisk), NFWPotential(a=2., normalize=normnfw) ] pot_extension = PotentialExtension(pot, 2, 120, 10) pot_list.append(pot_extension) self.disk_norm = disk_norm self.nfw_norm = nfw_norm self.pot_list = pot_list self.tabulated_potential = TabulatedPotential(self.pot_list, self.nfw_norm, self.disk_norm)
def diskmass(out): if _dexp: dp= DoubleExponentialDiskPotential(normalize=out[0], hr=out[4], hz=0.3/_REFR0) else: dp= MiyamotoNagaiPotential(normalize=out[0], a=out[4], b=0.3/_REFR0) return integrate.dblquad((lambda x,y: dp.dens(y,x)*y),0.,25./_REFR0,lambda x: 0.,lambda x: 10./_REFR0)[0]*2.*numpy.pi*_convertmass/out[2]**2.
def obj(x,data,bp,dp,hp): #x=[fd,fh,vc,rs,hdisk] if x[0] > 1. or x[0] < 0.: return numpy.finfo(numpy.dtype(numpy.float64)).max if x[1] > 1. or x[1] < 0.: return numpy.finfo(numpy.dtype(numpy.float64)).max if (1.-x[0]-x[1]) > 1. or (1.-x[0]-x[1]) < 0.: return numpy.finfo(numpy.dtype(numpy.float64)).max if x[2] < 0. or x[3] < 0. or x[4] < 0.: return numpy.finfo(numpy.dtype(numpy.float64)).max if x[2] > 2. or x[3] > 10. or x[4] > 2.: return numpy.finfo(numpy.dtype(numpy.float64)).max if False: #Renormalize potentials, intially normalized to 1./3. each bp= copy.deepcopy(bp) dp= copy.deepcopy(dp) hp= copy.deepcopy(hp) bp._amp*= (1.-x[0]-x[1])**2.*9. dp._amp*= x[0]**2.*9. hp._amp*= x[1]**2.*9. #Re-define disk scale length and halo scale length if _dexp: dp._hr= x[4] else: dp._a= x[4] hp._a= x[3] else: #Set-up bp= HernquistPotential(a=0.6/_REFR0,normalize=1.-x[0]-x[1]) if _dexp: dp= DoubleExponentialDiskPotential(normalize=x[0], hr=x[4], hz=0.3/_REFR0) else: dp= MiyamotoNagaiPotential(normalize=x[0], a=x[4], b=0.3/_REFR0) hp= NFWPotential(normalize=x[1], a=x[3]) #Re-normalize data vcircdata= copy.copy(data) vcircdata[:,1]/= x[2] vcircdata[:,2]/= x[2] #Vcirc chi2 vcmodel= numpy.zeros(vcircdata.shape[0]) for ii in range(vcircdata.shape[0]): vcmodel[ii]= numpy.sqrt(vcircdata[ii,0]\ *numpy.fabs(evaluateRforces(vcircdata[ii,0], 0.,[bp,dp,hp]))) #print vcircdata[:,0], vcmodel chi2= numpy.sum((vcircdata[:,1]-vcmodel)**2./vcircdata[:,2]**2.) #Add scale length measurement chi2+= (x[4]-_diskscale)**2./_diskscaleerr**2. #Add dark matter density at the Solar radius #print hp.dens(1.,0.),_rhodm*x[2]**2. #chi2+= (hp.dens(1.,0.)-_rhodm*x[2]**2.)**2./_rhodmerr**2./x[2]**4. return chi2
def MWPotential(Ms=0.76, rs=24.8, c=1., T=True): ''' Milky Way potential from Marchetti 2017b -- see galpy for the definitions of the potential components Parameters ---------- Ms : float NFW profile scale mass in units of e12 Msun rs : float Radial profile in units of kpc c : float Axis ratio T : bool If True, use triaxialNFWPotential ''' # NFW profile Ms = Ms * 1e12 * u.Msun rs = rs * u.kpc #Disk Md = 1e11 * u.Msun ad = 6.5 * u.kpc bd = 260. * u.pc #Bulge Mb = 3.4 * 1e10 * u.Msun Rb = 0.7 * u.kpc #BH mass in 1e6 Msun Mbh = 4e6 * u.Msun if (T): halop = TriaxialNFWPotential(amp=Ms, a=rs, c=c, normalize=False) else: halop = NFWPotential(amp=Ms, a=rs, normalize=False) diskp = MiyamotoNagaiPotential(amp=Md, a=ad, b=bd, normalize=False) bulgep = HernquistPotential( amp=2 * Mb, a=Rb, normalize=False) #Factor 2 because of the galpy definition bh = KeplerPotential(amp=Mbh, normalize=False) return [halop, diskp, bulgep, bh]
def test_minimize_func(self): disk_norm, nfw_norm = solve_normalizations(self.rho_nfw_target, self.rho_midplane_target, self.density_conversion) pot = [ PowerSphericalPotentialwCutoff(normalize=0.05, alpha=1.8, rc=1.9 / 8.), MiyamotoNagaiPotential(a=3. / 8., b=0.28 / 8., normalize=disk_norm), NFWPotential(a=2., normalize=nfw_norm) ] rho = evaluateDensities(pot, R=1., z=0) * self.density_conversion npt.assert_almost_equal(rho, self.rho_midplane_target, 3) disk_norm, nfw_norm = solve_normalizations(self.rho_nfw_target, self.rho_nfw_target * 0.5, self.density_conversion) npt.assert_equal(True, disk_norm < 0)
from galpy.potential import HernquistPotential from galpy.potential import LogarithmicHaloPotential from galpy.potential import MiyamotoNagaiPotential from .mwahpy_glob import G #=============================================================================== # CONSTANTS #=============================================================================== m_bulge = 3.4e10*u.solMass #solar masses m_disk = 1.0e11*u.solMass v_halo = 74.61*u.km/u.s #km/s pot_bulge = HernquistPotential(amp=2*m_bulge, a=0.7*u.kpc, ro=8., vo=220.) pot_disk = MiyamotoNagaiPotential(amp=G*m_disk, a=6.5*u.kpc, b=0.26*u.kpc, ro=8., vo=220.) pot_halo = LogarithmicHaloPotential(amp=2*v_halo**2, q=1., core=12.0*u.kpc, ro=8., vo=220.) #this potential is from Newberg et al. 2010, Orphan Stream Model 5. It's basically Law 2005 mwahpy_default_pot = [pot_bulge, pot_disk, pot_halo] energy_offset = -60000 #adjusts the energy to be consistent with Donlon et al. 2019 #=============================================================================== # FUNCTIONS #=============================================================================== #produces a rotation curve for the given potential def plot_potential(potential, Rrange=[0.01,10.]): fig = plt.figure(figsize=(12,8)) potential.plotRotcurve(Rrange=Rrange, overplot=True)
def MWPotentialSCFbar_grow(mbar, Acos, Asin, rs=1., normalize=False, pat_speed=40., fin_phi_deg=27., t_on=-2., tgrow=2, tstream=5.): ''' SCFbar starts growing at -x Gyr tstream : age of the stream/max stripping time t_on: time in Gyr in the past at which the bar acquired full strength tgrow: no of bar periods it took the bar to grow to full strength starting at tform ''' #setup the full strength bar and axisymmetric "bar" a = rs / ro omegaP = pat_speed * (ro / vo) fin_phi = np.radians(fin_phi_deg) Tbar = 2. * np.pi / np.abs(omegaP) #bar period in galpy units. t_on = t_on / bovy_conversion.time_in_Gyr(vo, ro) tsteady = tgrow * Tbar tform = t_on - tsteady #- because past is negative mrat = mbar / 10.**10. #10^10 mass of bar used to compute Acos and Asin static_bar = mySCFPotential(amp=mrat, Acos=Acos, Asin=Asin, a=a, normalize=normalize) #Note only m=0 terms are considered static_axi_bar = mySCFPotential(amp=mrat, Acos=np.atleast_3d(Acos[:, :, 0]), a=a) barrot = potential.SolidBodyRotationWrapperPotential(pot=static_bar, omega=omegaP, ro=ro, vo=vo, pa=fin_phi) if mbar <= 5. * 10**9.: MWP2014SCFbar = [ MWPotential2014[0], MiyamotoNagaiPotential(amp=(6.8 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], barrot ] turn_physical_off(MWP2014SCFbar) #setup the corresponding axisymmetric bar MWP2014SCFnobar = [ MWPotential2014[0], MiyamotoNagaiPotential(amp=(6.8 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], static_axi_bar ] turn_physical_off(MWP2014SCFnobar) else: MWP2014SCFbar = [ MiyamotoNagaiPotential(amp=(6.8 + 0.5 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], barrot ] turn_physical_off(MWP2014SCFbar) MWP2014SCFnobar = [ MiyamotoNagaiPotential(amp=(6.8 + 0.5 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], static_axi_bar ] turn_physical_off(MWP2014SCFnobar) #if t_on >= t_stream, then stream sees the bar as always on if np.abs(t_on) * bovy_conversion.time_in_Gyr(vo, ro) >= tstream: return (MWP2014SCFbar, MWP2014SCFnobar) elif np.abs(tform) * bovy_conversion.time_in_Gyr(vo, ro) >= tstream: print("tform > age of stream") elif np.abs(tform) * bovy_conversion.time_in_Gyr(vo, ro) < tstream: MWbar_grow = DehnenWrap(amp=1., pot=MWP2014SCFbar, tform=tform, tsteady=tsteady) MWaxibar_destroy = DehnenWrap(amp=-1., pot=MWP2014SCFnobar, tform=tform, tsteady=tsteady) growbarpot = [MWbar_grow, MWP2014SCFnobar, MWaxibar_destroy] turn_physical_off(growbarpot) return (growbarpot, MWP2014SCFnobar)
import sys import numpy from galpy.orbit import Orbit from galpy.potential import MiyamotoNagaiPotential if __name__ == '__main__': # python orbitint4sigint.py symplec4_c full mp= MiyamotoNagaiPotential(normalize=1.,a=0.5,b=0.05) ts= numpy.linspace(0.,10000000.,1000001) if sys.argv[2] == 'full' or sys.argv[2] == 'planar': if sys.argv[2] == 'full': o= Orbit([1.,0.1,1.1,0.1,0.1,0.]) elif sys.argv[2] == 'planar': o= Orbit([1.,0.1,1.1,0.1]) o.integrate(ts,mp,method=sys.argv[1]) elif sys.argv[2] == 'planardxdv': o= Orbit([1.,0.1,1.1,0.1]) o.integrate_dxdv([0.1,0.1,0.1,0.1],ts,mp,method=sys.argv[1]) sys.exit(0)
# 'error_colnames':None, # 'corr_colnames':None, } cart_colnames = { # 'main_colnames':None, # 'error_colnames':None, # 'corr_colnames':None, } from galpy.potential import PowerSphericalPotentialwCutoff,\ MiyamotoNagaiPotential, NFWPotential, verticalfreq, MWPotential2014 scale_height_factor = 2.0 bp = PowerSphericalPotentialwCutoff(alpha=1.8, rc=1.9 / 8., normalize=0.05) mp = MiyamotoNagaiPotential(a=3. / 8., b=scale_height_factor * 0.28 / 8., normalize=.6) np = NFWPotential(a=16 / 8., normalize=.35) my_mwpotential2014 = [bp, mp, np] orbit = { 'potential': my_mwpotential2014, # TC: varied params randomly... } special = { 'component':'sphere', # parameterisation for the origin } advanced = { 'burnin_steps':500, # emcee parameters, number of steps for each burnin iteraton 'sampling_steps':500, }
def MWPotentialSCFbar(mbar, Acos, Asin, rs=1., normalize=False, pat_speed=40., fin_phi_deg=27., t_stream_age=5., t_on=2., tgrow=2): ''' t_stream_age : age of the stream/max stripping time t_on: time in Gyr in the past at which the bar acquired full strength tgrow: no of bar periods it took the bar to grow to full strength starting at tform ''' #setup the full strength bar and axisymmetric "bar" a = rs / ro omegaP = pat_speed * (ro / vo) fin_phi = np.radians(fin_phi_deg) t_stream_age = t_stream_age / bovy_conversion.time_in_Gyr(vo, ro) Tbar = 2. * np.pi / omegaP #bar period in galpy units. t_on = t_on / bovy_conversion.time_in_Gyr(vo, ro) tsteady = tgrow * Tbar tform = t_on + tsteady init_phi = fin_phi - omegaP * t_stream_age / bovy_conversion.time_in_Gyr( vo, ro) mrat = mbar / 10.**10. #10^10 mass of bar used to compute Acos and Asin static_bar = SCFPotential(amp=mrat, Acos=Acos, Asin=Asin, a=a, normalize=normalize) #Note only m=0 terms are considered static_axi_bar = SCFPotential(amp=mrat, Acos=np.atleast_3d(Acos[:, :, 0]), a=a) barrot = potential.SolidBodyRotationWrapperPotential(pot=static_bar, omega=omegaP, ro=ro, vo=vo, pa=init_phi) if mbar <= 5. * 10**9.: MWP2014SCFbar = [ MWPotential2014[0], MiyamotoNagaiPotential(amp=(6.8 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], barrot ] turn_physical_off(MWP2014SCFbar) #setup the corresponding axisymmetric bar MWP2014SCFnobar = [ MWPotential2014[0], MiyamotoNagaiPotential(amp=(6.8 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], static_axi_bar ] turn_physical_off(MWP2014SCFnobar) else: MWP2014SCFbar = [ MiyamotoNagaiPotential(amp=(6.8 + 0.5 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], barrot ] turn_physical_off(MWP2014SCFbar) MWP2014SCFnobar = [ MiyamotoNagaiPotential(amp=(6.8 + 0.5 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], static_axi_bar ] turn_physical_off(MWP2014SCFnobar) #setup Dehnen smooth growth wrapper for the bar #convert to galpy units #if t_on >= t_pal5_age, then Pal 5 sees the bar as always on if t_on >= t_stream_age: return (MWP2014SCFbar, MWP2014SCFnobar) elif tform >= t_stream_age: print("tform > age of Pal 5 stream") elif tform < t_stream_age: #change tform in the past, i.e. instead of from today, to time in the future from 5 Gyr in the past tform = t_stream_age - tform MWbar_grow = DehnenWrap(amp=1., pot=MWP2014SCFbar, tform=tform, tsteady=tsteady) MWaxibar_destroy = DehnenWrap(amp=-1., pot=MWP2014SCFnobar, tform=tform, tsteady=tsteady) growbarpot = [MWbar_grow, MWP2014SCFnobar, MWaxibar_destroy] turn_physical_off(growbarpot) return (growbarpot, MWP2014SCFnobar)
def test_get_physical(): #Test that the get_physical function returns the right scaling parameters from galpy.util.bovy_conversion import get_physical # Potential and variations thereof from galpy.potential import MWPotential2014, DehnenBarPotential dp = DehnenBarPotential assert numpy.fabs( get_physical(MWPotential2014[0]).get('ro') - 8. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(MWPotential2014[0]).get('vo') - 220. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' ro, vo = 9., 230. dp = DehnenBarPotential(ro=ro, vo=vo) assert numpy.fabs( get_physical(dp).get('ro') - ro ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(dp).get('vo') - vo ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(MWPotential2014).get('ro') - 8. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(MWPotential2014).get('vo') - 220. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(MWPotential2014 + dp).get('ro') - 8. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(MWPotential2014 + dp).get('vo') - 220. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(MWPotential2014 + dp).get('ro') - 8. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' assert numpy.fabs( get_physical(MWPotential2014 + dp).get('vo') - 220. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a Potential' # Orbits from galpy.orbit import Orbit ro, vo = 10., 210. o = Orbit(ro=ro, vo=vo) assert numpy.fabs( get_physical(o).get('ro') - ro ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an Orbit' assert numpy.fabs( get_physical(o).get('vo') - vo ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an Orbit' # even though one shouldn't do this, let's test a list assert numpy.fabs( get_physical([o, o]).get('ro') - ro ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an Orbit' assert numpy.fabs( get_physical([o, o]).get('vo') - vo ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an Orbit' # actionAngle from galpy.actionAngle import actionAngleStaeckel aAS = actionAngleStaeckel(pot=MWPotential2014, delta=0.45) assert numpy.fabs( get_physical(aAS).get('ro') - 8. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an actionAngle instance' assert numpy.fabs( get_physical(aAS).get('vo') - 220. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an actionAngle instance' # This doesn't make much sense, but let's test... ro, vo = 19., 130. dp = DehnenBarPotential(ro=ro, vo=vo) aAS = actionAngleStaeckel(pot=dp, delta=0.45, ro=ro, vo=vo) assert numpy.fabs( get_physical(aAS).get('ro') - ro ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an actionAngle instance' assert numpy.fabs( get_physical(aAS).get('vo') - vo ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for an actionAngle instance' # DF from galpy.df import quasiisothermaldf aAS = actionAngleStaeckel(pot=MWPotential2014, delta=0.45) qdf = quasiisothermaldf(1. / 3., 0.2, 0.1, 1., 1., aA=aAS, pot=MWPotential2014) assert numpy.fabs( get_physical(qdf).get('ro') - 8. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a DF instance' assert numpy.fabs( get_physical(qdf).get('vo') - 220. ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a DF instance' # non-standard ro,vo from galpy.potential import MiyamotoNagaiPotential ro, vo = 4., 330. mp = MiyamotoNagaiPotential(a=0.5, b=0.1, ro=ro, vo=vo) aAS = actionAngleStaeckel(pot=mp, delta=0.45, ro=ro, vo=vo) qdf = quasiisothermaldf(1. / 3., 0.2, 0.1, 1., 1., aA=aAS, pot=mp, ro=ro, vo=vo) assert numpy.fabs( get_physical(qdf).get('ro') - ro ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a DF instance' assert numpy.fabs( get_physical(qdf).get('vo') - vo ) < 1e-10, 'get_physical does not return the correct unit conversion parameter for a DF instance' return None
def MWPotentialSCFbar_invert(mbar, Acos, Asin, rs=1., normalize=False, pat_speed=40., fin_phi_deg=27., t_stream_age=5., t_on=2., tgrow=2): ''' t_stream_age : age of the stream/max stripping time tform: time in Gyr in the past at which the bar started to form tgrow: no of bar periods it took the bar to grow to full strength starting at tform ''' #setup the full strength bar and axisymmetric "bar" a = rs / ro omegaP = pat_speed * (ro / vo) fin_phi = np.radians(fin_phi_deg) mrat = mbar / 10.**10. #10^10 mass of bar used to compute Acos and Asin static_bar = potential.SCFPotential(amp=mrat, Acos=Acos, Asin=Asin, a=a, normalize=normalize) #Note only m=0 terms are considered static_axi_bar = potential.SCFPotential(amp=mrat, Acos=np.atleast_3d(Acos[:, :, 0]), a=a) #pa = final phi and omega is negative since we are going back in time barrot = potential.SolidBodyRotationWrapperPotential(pot=static_bar, omega=-omegaP, ro=ro, vo=vo, pa=fin_phi) if mbar <= 5. * 10**9.: MWP2014SCFbar = [ MWPotential2014[0], MiyamotoNagaiPotential(amp=(6.8 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], barrot ] turn_physical_off(MWP2014SCFbar) #setup the corresponding axisymmetric bar MWP2014SCFnobar = [ MWPotential2014[0], MiyamotoNagaiPotential(amp=(6.8 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], static_axi_bar ] turn_physical_off(MWP2014SCFnobar) else: MWP2014SCFbar = [ MiyamotoNagaiPotential(amp=(6.8 + 0.5 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], barrot ] turn_physical_off(MWP2014SCFbar) MWP2014SCFnobar = [ MiyamotoNagaiPotential(amp=(6.8 + 0.5 - mrat) * 10.**10 * u.Msun, a=3. / 8., b=0.28 / 8.), MWPotential2014[2], static_axi_bar ] turn_physical_off(MWP2014SCFnobar) #setup Dehnen smooth growth wrapper for the bar #while going back, t_on = tform, then deconstruct the bar to no bar during tsteady tform = t_on / bovy_conversion.time_in_Gyr(vo, ro) Tbar = 2. * np.pi / omegaP tsteady = tgrow * Tbar MWaxibar_grow = DehnenWrap(amp=1., pot=MWP2014SCFnobar, tform=tform, tsteady=tsteady) MWbar_destroy = DehnenWrap(amp=-1., pot=MWP2014SCFbar, tform=tform, tsteady=tsteady) growbarpot_invert = [MWP2014SCFbar, MWaxibar_grow, MWbar_destroy] turn_physical_off(growbarpot_invert) return growbarpot_invert
# 'main_colnames':None, # list of names # 'error_colnames':None, # 'corr_colnames':None, } cart_colnames = { # 'main_colnames':None, # 'error_colnames':None, # 'corr_colnames':None, } from galpy.potential import MiyamotoNagaiPotential, MWPotential2014 orbit = { # 'potential': None, #'potential': MWPotential2014, #'potential': MiyamotoNagaiPotential(a=0.5,b=0.0375,amp=1.,normalize=1.), # Params from the example webpage. No idea if that's good or not. 'potential': MiyamotoNagaiPotential(a=0.5, b=0.1375, amp=1., normalize=1.), # TC: varied params randomly... } special = { 'component': 'sphere', # parameterisation for the origin } advanced = { 'burnin_steps': 500, # emcee parameters, number of steps for each burnin iteraton 'sampling_steps': 500, }
r *= ro #r is now in physical units acc = 1e10 * interp_m_over_r2(r) * (conversion._G * 0.001) #(km/s)^2/kpc acc *= (0.001 * conversion._kmsInPcMyr) #km/s/Myr acc *= (-1. / conversion.force_in_kmsMyr(vo, ro)) #in galpy units return (acc) Phi0 = rad_acc(rgrid[0] / ro) * (rgrid[0] / ro) # in galpy units ip_halo = potential.interpSphericalPotential(rforce=rad_acc, rgrid=rgrid / ro, Phi0=Phi0) ip_halo.turn_physical_off() disk_pot = MiyamotoNagaiPotential(amp=5.78 * 10**10 * u.Msun, a=3.5 * u.kpc, b=0.5 * u.kpc) disk_pot.turn_physical_off() tot_pot = ip_halo + disk_pot sdf_smooth = mockgd1_util.setup_gd1model(age=options.td, isob=options.isob, leading=lead, sigv=options.sigv) #if not os.path.exists(folder): # os.makedirs(folder,exist_ok=True) pepperfilename = 'mockgd1_pepper_{}_{}_sigv{}_td{}_{}sampling_InterpSphPotAnalyticDisk.pkl'.format( lead_name, sub_type, options.sigv, options.td, len(timpacts))
def fitMass(): #Read data vcircdata= numpy.loadtxt('vcirc.txt',comments='#',delimiter='|') vcircdata[:,0]/= _REFR0 vcircdata[:,1]/= _REFV0 vcircdata[:,2]/= _REFV0 #Set-up bp= HernquistPotential(a=0.6/_REFR0,normalize=1./3.) if _dexp: dp= DoubleExponentialDiskPotential(normalize=1./3., hr=3.25/_REFR0, hz=0.3/_REFR0) else: dp= MiyamotoNagaiPotential(normalize=1./3., a=3.25/_REFR0, b=0.3/_REFR0) hp= NFWPotential(normalize=1./3., a=5./_REFR0) init= numpy.array([0.6,0.35,218./_REFV0,15./_REFR0,3.25/_REFR0]) #print _convertrho out= optimize.fmin_powell(obj,init,args=(vcircdata,bp,dp,hp), callback=cb) print out #Calculate mass #Halo mass halo= halomass(out) bulge= halomass(out) disk= diskmass(out) print halo, disk, bulge, totalmass(out) #Sample samples= bovy_mcmc.markovpy(out,0.05, (lambda x: -obj(x,vcircdata,bp,dp,hp)), (), isDomainFinite=[[True,True], [True,True], [True,True], [True,True], [True,True]], domain=[[0.,1.], [0.,1.], [0.,2.], [0.,10.], [0.,2.]], nwalkers=8, nsamples=10000) print "Done with sampling ..." print numpy.mean(numpy.array(samples),axis=0) print numpy.std(numpy.array(samples),axis=0) samples= numpy.random.permutation(samples)[0:500] #halo totalmasssamples= [] for s in samples: totalmasssamples.append(halomass(s)) totalmasssamples= numpy.array(totalmasssamples) print "halo mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples) print sixtyeigthinterval(halomass(out),totalmasssamples,quantile=.68) #total totalmasssamples= [] for s in samples: totalmasssamples.append(totalmass(s)) totalmasssamples= numpy.array(totalmasssamples) print "total mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples) print sixtyeigthinterval(totalmass(out),totalmasssamples,quantile=.68) bovy_plot.bovy_print() bovy_plot.bovy_hist(totalmasssamples,bins=16,range=[0.,2.]) bovy_plot.bovy_end_print('totalmass.png') return None #disk totalmasssamples= [] for s in samples: totalmasssamples.append(diskmass(s)) totalmasssamples= numpy.array(totalmasssamples) print "disk mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples) #bulge totalmasssamples= [] for s in samples: totalmasssamples.append(bulgemass(s)) totalmasssamples= numpy.array(totalmasssamples) print "bulge mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples) return None
def calc_es(): savefilename= 'myes.sav' if os.path.exists(savefilename): savefile= open(savefilename,'rb') mye= pickle.load(savefile) e= pickle.load(savefile) savefile.close() else: #Read data dialect= csv.excel dialect.skipinitialspace=True reader= csv.reader(open('../data/Dierickx-etal-tab2.txt','r'),delimiter=' ',dialect=dialect) vxvs= [] es= [] vphis= [] vxs= [] vys= [] vzs= [] ls= [] for row in reader: thisra= float(row[3]) thisdec= float(row[4]) thisd= float(row[17])/1000. thispmra= float(row[13]) thispmdec= float(row[15]) thisvlos= float(row[11]) thise= float(row[26]) vxvs.append([thisra,thisdec,thisd,thispmra,thispmdec,thisvlos]) es.append(thise) vphis.append(float(row[25])) vxs.append(float(row[19])) vys.append(float(row[21])) vzs.append(float(row[23])) ls.append(float(row[5])) vxvv= nu.array(vxvs) e= nu.array(es) vphi= nu.array(vphis) vx= nu.array(vxs) vy= nu.array(vys) vz= nu.array(vzs) l= nu.array(ls) #Define potential lp= LogarithmicHaloPotential(normalize=1.) mp= MiyamotoNagaiPotential(a=0.5,b=0.0375,amp=1.,normalize=.6) np= NFWPotential(a=4.5,normalize=.35) hp= HernquistPotential(a=0.6/8,normalize=0.05) ts= nu.linspace(0.,20.,10000) mye= nu.zeros(len(e)) for ii in range(len(e)): #Integrate the orbit o= Orbit(vxvv[ii,:],radec=True,vo=220.,ro=8.) o.integrate(ts,lp) mye[ii]= o.e() #Save savefile= open(savefilename,'wb') pickle.dump(mye,savefile) pickle.dump(e,savefile) savefile.close() #plot plot.print() plot.plot(nu.array([0.,1.]),nu.array([0.,1.]),'k-', xlabel=r'$\mathrm{Dierickx\ et\ al.}\ e$', ylabel=r'$\mathrm{galpy}\ e$') plot.plot(e,mye,'k,',overplot=True) plot.end_print('myee.png') plot.print() plot.hist(e,bins=30,xlabel=r'$\mathrm{Dierickx\ et\ al.}\ e$') plot.end_print('ehist.png') plot.print() plot.hist(mye,bins=30,xlabel=r'$\mathrm{galpy}\ e$') plot.end_print('myehist.png')
def test_different_potential(): miya_pot = MiyamotoNagaiPotential(a=0.5, b=0.0375, amp=1., normalize=1.) miya_trace_cartesian_orbit = torb.trace_orbit_builder(miya_pot) ABS_TOLERANCE = 1e-3 xyzuvws = np.array([ [0., 0., 25., 0., 0., 0.], [10., 0., -50., 0., 0., 0.], [10., 0., -50., 0., 0., -5.], [0., 0., 0., 10., 25., 30.,], ]) age = 100. times = np.linspace(0, 100, 1001) for xyzuvw_start in xyzuvws: xyzuvw_end = miya_trace_cartesian_orbit(xyzuvw_start, times=age, single_age=True, ) xyzuvw_start_again = miya_trace_cartesian_orbit(xyzuvw_end, times=-age, single_age=True, ) assert np.allclose(xyzuvw_start, xyzuvw_start_again, atol=ABS_TOLERANCE) # Confirm that tracing forward with one potential but back with another # gives different starting position xyzuvw_start_but_with_diff_pot = torb.trace_cartesian_orbit(xyzuvw_end, times=-age,) assert not np.allclose(xyzuvw_start, xyzuvw_start_but_with_diff_pot) def test_traceforwardThenBack(): """Check that tracing a point forward then back for the same time step returns initial position """ return ABS_TOLERANCE = 1e-3 xyzuvws = np.array([ [0., 0., 25., 0., 0., 0.], # [10.,0.,-50.,0.,0.,0.], # [0.,0.,0.,10.,25.,30.,], ]) age = 100. times = np.linspace(0, 100, 1001) for xyzuvw_start in xyzuvws: galpy_start = None xyzuvw_end = torb.trace_cartesian_orbit(xyzuvw_start, times=age, single_age=True, ) xyzuvw_start_again = torb.trace_cartesian_orbit(xyzuvw_end, times=-age, single_age=True, ) assert np.allclose(xyzuvw_start, xyzuvw_start_again, atol=ABS_TOLERANCE) def test_galpy_stationary_conversions(): """Check if gaply conversions behave as expected where everything is at time 0""" # Test LSR lsr_chron = np.zeros(6) lsr_galpy = np.array([1., 0, 1, 0, 0, 0]) assert np.allclose(lsr_chron, torb.convert_galpycoords2cart(lsr_galpy, ts=0.)) assert np.allclose(lsr_galpy, torb.convert_cart2galpycoords(lsr_chron, ts=0.)) # Test galactic centre gc_chron = np.array([8000., 0, 0, 0, -220., 0, ]) gc_galpy = np.ones(6) * 1e-15 assert np.allclose(gc_chron, torb.convert_galpycoords2cart(gc_galpy, ts=0.)) assert np.allclose(gc_galpy, torb.convert_cart2galpycoords(gc_chron, ts=0.)) # Test simple, off origin point off_chron = np.array([4000, 8000. * np.sqrt(3) / 2, 0, np.sin(np.pi / 3) * 220., -np.cos(np.pi / 3) * 220., 0]) off_galpy = np.array([1., 0, 1, 0, 0, np.pi / 3.]) assert np.allclose(off_galpy, torb.convert_cart2galpycoords(off_chron, ts=0.)) assert np.allclose(off_chron, torb.convert_galpycoords2cart(off_galpy, ts=0.)) # Test random positions SPREAD = 100000 NSAMPLES = int(1e6) many_pos_chron = (np.random.rand(NSAMPLES, 6) - 0.5) * SPREAD # uniform between -10 and 10 many_pos_galpy = torb.convert_cart2galpycoords(many_pos_chron, ts=0.) assert np.allclose(many_pos_chron, torb.convert_galpycoords2cart(many_pos_galpy, ts=0.), atol=1e-2) def test_galpy_moving_conversions(): """Check if gaply conversions behave as expected where time is allowed to vary.""" lsr_chron = np.zeros(6) lsr_galpy = np.array([1., 0, 1, 0, 0, 0]) # Incorporate positive time into lsr position checks NSTEPS = 10 galpy_times = np.linspace(0., 2 * np.pi, NSTEPS) lsrs_chron = np.repeat(lsr_chron, NSTEPS).reshape(6, -1).T lsrs_galpy = np.repeat(lsr_galpy, NSTEPS).reshape(6, -1).T lsrs_galpy[:, -1] = galpy_times chron_times = torb.convert_bovytime2myr(galpy_times) assert np.allclose( lsrs_chron, torb.convert_galpycoords2cart(lsrs_galpy, ts=galpy_times)) assert np.allclose( lsrs_galpy, torb.convert_cart2galpycoords(lsrs_chron, ts=chron_times) ) # Incorporate negative time into lsr position checks galpy_times = np.linspace(0., -2 * np.pi, NSTEPS) lsrs_chron = np.repeat(lsr_chron, NSTEPS).reshape(6, -1).T lsrs_galpy = np.repeat(lsr_galpy, NSTEPS).reshape(6, -1).T lsrs_galpy[:, -1] = galpy_times chron_times = torb.convert_bovytime2myr(galpy_times) assert np.allclose( lsrs_chron, torb.convert_galpycoords2cart(lsrs_galpy, ts=galpy_times)) assert np.allclose( lsrs_galpy, torb.convert_cart2galpycoords(lsrs_chron, ts=chron_times) ) # Test random positions with random times SPREAD = int(1e4) # pc NSAMPLES = 100 many_pos_chron = (np.random.rand(NSAMPLES, 6) - 0.5) * SPREAD # uniform between -10 and 10 many_chron_times = np.random.rand(NSAMPLES) * 100 # Myr many_pos_galpy = torb.convert_cart2galpycoords( many_pos_chron, ts=many_chron_times ) many_galpy_times = torb.convert_myr2bovytime(many_chron_times) for i in range(NSAMPLES): assert np.allclose(many_pos_chron[i], torb.convert_galpycoords2cart( many_pos_galpy[i], ts=many_galpy_times[i] ), atol=1e-2) def test_careful_traceback_and_forward(): """Step by step, project orbit forward, then backward""" bovy_times = np.array([0., np.pi / 3.]) chron_times = torb.convert_bovytime2myr(bovy_times) init_pos_chron = np.array([ 4000, 8000. * np.sqrt(3) / 2, 0, np.sin(np.pi / 3) * 220., -np.cos(np.pi / 3) * 220., 0 ]) init_pos_galpy = torb.convert_cart2galpycoords(init_pos_chron, ts=0.) assert np.allclose(np.array([1., 0, 1, 0, 0, np.pi / 3.]), init_pos_galpy) o = Orbit(vxvv=init_pos_galpy, ro=8., vo=220.) o.integrate(bovy_times, MWPotential2014, method='odeint') orbit_galpy = o.getOrbit() assert np.allclose(init_pos_galpy, orbit_galpy[0]) assert np.allclose(init_pos_galpy + np.array([0., 0., 0., 0., 0., bovy_times[-1]]), orbit_galpy[-1]) orbit_chron = torb.convert_galpycoords2cart(orbit_galpy, ts=bovy_times) assert np.allclose(init_pos_chron, orbit_chron[0]) assert np.allclose(init_pos_chron, orbit_chron[-1]) # Setup for backwards time integration # Currently at time of PI/3 back_init_pos_chron = orbit_chron[-1] back_init_pos_galpy = torb.convert_cart2galpycoords( back_init_pos_chron, bovy_times=bovy_times[-1], ) assert np.allclose(back_init_pos_galpy, torb.convert_cart2galpycoords( back_init_pos_chron, bovy_times=bovy_times[-1] )) back_o = Orbit(vxvv=back_init_pos_galpy, ro=8., vo=220.) back_o.integrate(-1 * bovy_times, MWPotential2014, method='odeint') back_orbit_galpy = back_o.getOrbit() assert np.allclose(back_init_pos_galpy, back_orbit_galpy[0]) assert np.allclose(back_init_pos_galpy - np.array([0., 0., 0., 0., 0., bovy_times[-1]]), back_orbit_galpy[-1]) assert np.allclose(init_pos_galpy, back_orbit_galpy[-1]) back_orbit_chron = torb.convert_galpycoords2cart( back_orbit_galpy, ts=bovy_times[::-1], ) assert np.allclose(init_pos_chron, back_orbit_chron[-1]) def test_traceback_and_forward(): """The test that shows things are broken""" time = 10. # Myr times = np.array([0., 10.]) init_pos_chron = np.array([10., 0., 30., 0., 0., 0.]) # init_pos_chron = np.zeros(6) init_pos_chron = np.array([4000, 8000. * np.sqrt(3) / 2, 0, np.sin(np.pi / 3) * 220., -np.cos(np.pi / 3) * 220., 0]) final_pos_chron = torb.trace_cartesian_orbit( init_pos_chron, times=times, single_age=False)[-1] final_pos_chron = torb.traceforward_from_now( init_pos_chron, time=time, ) assert np.allclose( init_pos_chron, torb.traceback_to_now( final_pos_chron, time, ), atol=1e-5 ) def test_multi_traceback_and_forward(): np.random.seed(0) NPOSITIONS = 10 init_positions = np.random.rand(NPOSITIONS, 6) * 20 - 10 time_spans = np.random.rand(NPOSITIONS) * 30 for pos, time in zip(init_positions, time_spans): final_pos = torb.traceforward_from_now(pos, time) init_pos = torb.traceback_to_now(final_pos, time) assert np.allclose(pos, init_pos, atol=1e-3) for pos, time in zip(init_positions, time_spans): print('time: {}'.format(time)) final_pos = torb.traceback_from_now(pos, time) init_pos = torb.traceforward_to_now(final_pos, time) assert np.allclose(pos, init_pos, atol=1e-3) def test_interval_tracing(): np.random.seed(0) start = np.random.rand(6) * 20 - 10 time_steps = [3., -10., -3., 10] current_pos = start for time_step in time_steps: current_pos = torb.base_trace_cartesian_orbit( current_pos, end_time=time_step, ) assert np.allclose(start, current_pos, atol=1e-3) def test_interval_tracing_orig(): np.random.seed(0) start = np.random.rand(6) * 20 - 10 time_steps = [3., -10., -3., 10] current_pos = start for time_step in time_steps: current_pos = torb.trace_cartesian_orbit( current_pos, times=time_step, single_age=True, ) assert np.allclose(start, current_pos, 1e-3)
def calcj(rotcurve): if rotcurve == 'flat': savefilename = 'myjs.sav' elif rotcurve == 'power': savefilename = 'myjs_power.sav' if os.path.exists(savefilename): savefile = open(savefilename, 'rb') myjr = pickle.load(savefile) myjp = pickle.load(savefile) mywr = pickle.load(savefile) mywp = pickle.load(savefile) mye = pickle.load(savefile) myzmax = pickle.load(savefile) e = pickle.load(savefile) zmax = pickle.load(savefile) savefile.close() else: dialect = csv.excel dialect.skipinitialspace = True reader = csv.reader(open('../data/gcs.tsv', 'r'), delimiter='|', dialect=dialect) vxvs = [] es = [] zmaxs = [] for row in reader: if row[0][0] == '#': continue thisra = row[0] thisdec = row[1] thisd = read_float(row[2]) / 1000. if thisd > 0.2: continue thisu = read_float(row[3]) thisv = read_float(row[4]) thisw = read_float(row[5]) thise = read_float(row[6]) thiszmax = read_float(row[7]) if thisd == -9999 or thisu == -9999 or thisv == -9999 or thisw == -9999: continue vxvs.append([ hms_to_rad(thisra), dms_to_rad(thisdec), thisd, thisu, thisv, thisw ]) es.append(thise) zmaxs.append(thiszmax) vxvv = nu.array(vxvs) e = nu.array(es) zmax = nu.array(zmaxs) #Define potential lp = LogarithmicHaloPotential(normalize=1.) pp = PowerSphericalPotential(normalize=1., alpha=-2.) mp = MiyamotoNagaiPotential(a=0.5, b=0.0375, amp=1., normalize=.6) np = NFWPotential(a=4.5, normalize=.35) hp = HernquistPotential(a=0.6 / 8, normalize=0.05) ts = nu.linspace(0., 20., 10000) myjr = nu.zeros(len(e)) myjp = nu.zeros(len(e)) mywr = nu.zeros(len(e)) mywp = nu.zeros(len(e)) mye = nu.zeros(len(e)) myzmax = nu.zeros(len(e)) for ii in range(len(e)): #Integrate the orbit o = Orbit(vxvv[ii, :], radec=True, uvw=True, vo=220., ro=8.) #o.integrate(ts,[mp,np,hp]) if rotcurve == 'flat': o.integrate(ts, lp) mye[ii] = o.e() myzmax[ii] = o.zmax() * 8. print e[ii], mye[ii], zmax[ii], myzmax[ii] o = o.toPlanar() myjr[ii] = o.jr(lp)[0] else: o = o.toPlanar() myjr[ii] = o.jr(pp)[0] myjp[ii] = o.jp()[0] mywr[ii] = o.wr()[0] mywp[ii] = o.wp() #Save savefile = open(savefilename, 'wb') pickle.dump(myjr, savefile) pickle.dump(myjp, savefile) pickle.dump(mywr, savefile) pickle.dump(mywp, savefile) pickle.dump(mye, savefile) pickle.dump(myzmax, savefile) pickle.dump(e, savefile) pickle.dump(zmax, savefile) savefile.close() #plot if rotcurve == 'flat': plot.bovy_print() plot.bovy_plot(nu.array([0., 1.]), nu.array([0., 1.]), 'k-', xlabel=r'$\mathrm{Holmberg\ et\ al.}\ e$', ylabel=r'$\mathrm{galpy}\ e$') plot.bovy_plot(e, mye, 'k,', overplot=True) plot.bovy_end_print('myee.png') plot.bovy_print() plot.bovy_plot( nu.array([0., 2.5]), nu.array([0., 2.5]), 'k-', xlabel=r'$\mathrm{Holmberg\ et\ al.}\ z_{\mathrm{max}}$', ylabel=r'$\mathrm{galpy}\ z_{\mathrm{max}}$') plot.bovy_plot(zmax, myzmax, 'k,', overplot=True) plot.bovy_end_print('myzmaxzmax.png') plot.bovy_print() plot.bovy_plot(myjp, myjr / 2. / nu.pi, 'k,', xlabel=r'$J_{\phi}$', ylabel=r'$J_R/2\pi$', xrange=[0.7, 1.3], yrange=[0., 0.05]) if rotcurve == 'flat': plot.bovy_end_print('jrjp.png') else: plot.bovy_end_print('jrjp_power.png')