def raveRC():
data= readRave()
jk= data['Jmag2']-data['Kmag2']-0.17*numpy.exp(data['Av'])
z= isodist.FEH2Z(data['[M/H]K'],zsolar=0.017)
logg= data['loggK']
indx= (jk < 0.8)*(jk >= 0.5)\
*(z <= 0.06)\
*(z <= rcmodel.jkzcut(jk,upper=True))\
*(z >= rcmodel.jkzcut(jk))\
*(logg >= rcmodel.loggteffcut(data['TeffK'],z,upper=False))\
*(logg <= rcmodel.loggteffcut(data['TeffK'],z,upper=True))
data= data[indx]
#To allow for XY pixelization
data= esutil.numpy_util.add_fields(data,[('RC_GALR', float),
('RC_GALPHI', float),
('RC_GALZ', float),
('VHELIO_AVG', float)])
XYZ= bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['Dist'],
degree=True)
R,phi,Z= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],
XYZ[:,1],
XYZ[:,2],
Xsun=8.,Zsun=0.025)
data['RC_GALR']= R
data['RC_GALPHI']= phi
data['RC_GALZ']= Z
data['VHELIO_AVG']= data['HRV']
return data
def get_rcsample():
"""
NAME:
get_rcsample
PURPOSE:
get the RC sample
INPUT:
None so far
OUTPUT:
sample
HISTORY:
2015-02-10 - Started - Bovy (IAS@KITP)
"""
data = apread.rcsample()
# Cut to statistical sample
data = data[data['STAT'] == 1]
# Add the M_H-based distances
data = esutil.numpy_util.add_fields(data, [('RC_DIST_H', float),
('RC_DM_H', float),
('RC_GALR_H', float),
('RC_GALPHI_H', float),
('RC_GALZ_H', float)])
rcd = rcdist()
jk = data['J0'] - data['K0']
z = isodist.FEH2Z(data['METALS'], zsolar=0.017)
data['RC_DIST_H'] = rcd(jk, z, appmag=data['H0'], mh=True)
data['RC_DM_H'] = 5. * numpy.log10(data['RC_DIST_H']) + 10.
XYZ = bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['RC_DIST_H'],
degree=True)
R, phi, Z = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2],
Xsun=8.,
Zsun=0.025)
data['RC_GALR_H'] = R
data['RC_GALPHI_H'] = phi
data['RC_GALZ_H'] = Z
# Add the average alpha/Fe
data = esutil.numpy_util.add_fields(data, [('AVG_ALPHAFE', float)])
data['AVG_ALPHAFE'] = avg_alphafe(data)
# Apply -0.1 offset in [Fe/H]
data[_FEHTAG] += -0.10
# Remove locations outside of the Pan-STARRS dust map
# In the Southern hemisphere
data = data[data['LOCATION_ID'] != 4266] #240,-18
data = data[data['LOCATION_ID'] != 4331] #5.5,-14.2
data = data[data['LOCATION_ID'] != 4381] #5.2,-12.2
data = data[data['LOCATION_ID'] != 4332] #1,-4
data = data[data['LOCATION_ID'] != 4329] #0,-5
data = data[data['LOCATION_ID'] != 4351] #0,-2
data = data[data['LOCATION_ID'] != 4353] #358,0
data = data[data['LOCATION_ID'] != 4385] #358.6,1.4
# Close to the ecliptic pole where there's no data (is it the ecliptic pole?
data = data[data['LOCATION_ID'] != 4528] #120,30
data = data[data['LOCATION_ID'] != 4217] #123,22.4
# Remove stars w/ DM < 8.49, because for standard candle RC, these cannot be in the sample
data = data[data['RC_DM_H'] > 8.49]
return data
def _setup_effvol(locations,effsel,distmods):
# First restore the APOGEE selection function (assumed pre-computed)
selectFile= '../savs/selfunc-nospdata.sav'
if os.path.exists(selectFile):
with open(selectFile,'rb') as savefile:
apo= pickle.load(savefile)
# Now compute the necessary coordinate transformations
ds= 10.**(distmods/5-2.)
Rgrid, phigrid, zgrid= [], [], []
for loc in locations:
lcen, bcen= apo.glonGlat(loc)
XYZ= bovy_coords.lbd_to_XYZ(lcen*numpy.ones_like(ds),
bcen*numpy.ones_like(ds),
ds,
degree=True)
Rphiz= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],XYZ[:,1],XYZ[:,2],
Xsun=define_rcsample._R0,
Ysun=0.,
Zsun=define_rcsample._Z0)
Rgrid.append(Rphiz[0])
phigrid.append(Rphiz[1])
zgrid.append(Rphiz[2])
Rgrid= numpy.array(Rgrid)
phigrid= numpy.array(phigrid)
zgrid= numpy.array(zgrid)
# Also need to multiply in distance factors
effsel*= numpy.tile(ds**3.*(distmods[1]-distmods[0]),(effsel.shape[0],1))
return (effsel,Rgrid,phigrid,zgrid)
def _calc_lnprob(loc,nls,nbs,ds,distmods,H0,densfunc):
lcen, bcen= apo.glonGlat(loc)
rad= apo.radius(loc)
ls= numpy.linspace(lcen-rad,lcen+rad,nls)
bs= numpy.linspace(bcen-rad,bcen+rad,nbs)
# Tile these
tls= numpy.tile(ls,(len(ds),len(bs),1))
tbs= numpy.swapaxes(numpy.tile(bs,(len(ds),len(ls),1)),1,2)
tds= numpy.tile(ds,(len(ls),len(bs),1)).T
XYZ= bovy_coords.lbd_to_XYZ(tls.flatten(),
tbs.flatten(),
tds.flatten(),
degree=True)
Rphiz= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],XYZ[:,1],XYZ[:,2],
Xsun=define_rcsample._R0,
Ysun=0.,
Zsun=define_rcsample._Z0)
# Evaluate probability density
tH= numpy.tile(distmods.T,(1,len(ls),len(bs),1))[0].T
for ii in range(tH.shape[1]):
for jj in range(tH.shape[2]):
try:
tH[:,ii,jj]+= dmap(ls[jj],bs[ii],ds)
except (IndexError, TypeError,ValueError):
try:
tH[:,ii,jj]+= dmapg15(ls[jj],bs[ii],ds)
except IndexError: # assume zero outside
pass
tH= tH.flatten()+H0[0]
ps= densfunc(Rphiz[0],Rphiz[1],Rphiz[2])*apo(loc,tH)\
*numpy.fabs(numpy.cos(tbs.flatten()/180.*numpy.pi))\
*tds.flatten()**3.
return numpy.log(numpy.reshape(ps,(len(distmods),nbs,nls))\
+10.**-8.)
def _setup_effvol(locations, effsel, distmods):
# First restore the APOGEE selection function (assumed pre-computed)
selectFile = '../savs/selfunc-nospdata.sav'
if os.path.exists(selectFile):
with open(selectFile, 'rb') as savefile:
apo = pickle.load(savefile)
# Now compute the necessary coordinate transformations
ds = 10.**(distmods / 5 - 2.)
Rgrid, phigrid, zgrid = [], [], []
for loc in locations:
lcen, bcen = apo.glonGlat(loc)
XYZ = bovy_coords.lbd_to_XYZ(lcen * numpy.ones_like(ds),
bcen * numpy.ones_like(ds),
ds,
degree=True)
Rphiz = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2],
Xsun=define_rcsample._R0,
Ysun=0.,
Zsun=define_rcsample._Z0)
Rgrid.append(Rphiz[0])
phigrid.append(Rphiz[1])
zgrid.append(Rphiz[2])
Rgrid = numpy.array(Rgrid)
phigrid = numpy.array(phigrid)
zgrid = numpy.array(zgrid)
# Also need to multiply in distance factors
effsel *= numpy.tile(ds**3. * (distmods[1] - distmods[0]),
(effsel.shape[0], 1))
return (effsel, Rgrid, phigrid, zgrid)
def force_pal5(pot: PotentialType,
dpal5: float,
ro: float = REFR0,
vo: float = REFV0) -> Tuple[float]:
"""Return the force at Pal5.
Parameters
----------
pot: Potential, list
dpal5: float
ro, vo: float
Return
------
force: tuple
[fx, fy, fz]
"""
from galpy import potential
from galpy.util import bovy_coords
# First compute the location based on the distance
l5, b5 = bovy_coords.radec_to_lb(229.018, -0.124, degree=True)
X5, Y5, Z5 = bovy_coords.lbd_to_XYZ(l5, b5, dpal5, degree=True)
R5, p5, Z5 = bovy_coords.XYZ_to_galcencyl(X5, Y5, Z5, Xsun=ro, Zsun=0.025)
args: list = [pot, R5 / ro, Z5 / ro]
kws: dict = {"phi": p5, "use_physical": True, "ro": ro, "vo": vo}
return (
potential.evaluateRforces(*args, **kws),
potential.evaluatezforces(*args, **kws),
potential.evaluatephiforces(*args, **kws),
)
def read_mgiant(self):
dpath = "/Users/htian/Documents/GitHub/rothalo/data/dr4_mgiant.csv"
ra, dec, rv, dist, sn, feh = np.loadtxt(dpath,
skiprows=1,
usecols=(0, 1, 2, 9, 10, 11),
delimiter=',',
unpack=True)
ind_o = (rv > -10000000) & (sn > 10) & (feh > self.min_feh) & (
feh < self.max_feh) & (dist > -1000)
print(len(sn[sn < 10]), len(sn))
print("there are ", len(ra[ind_o]), " stars readout!")
# ra_o = data_halo[ind_o, 1]
# dec_o = data_halo[ind_o, 2]
lb = gub.radec_to_lb(ra, dec, degree=True)
l = lb[:, 0]
b = lb[:, 1]
xyz = gub.lbd_to_XYZ(l, b, dist, degree=True)
self.l_o = l[ind_o]
self.b_o = b[ind_o]
self.feh_o = feh[ind_o]
self.rv_o = rv[ind_o]
self.dist_o = dist[ind_o]
self.Z_o = xyz[ind_o, 2]
self.R_o = np.sqrt((8 - xyz[ind_o, 0])**2 + xyz[ind_o, 1]**2)
self.name = "DR4_mgiant"
def get_rcsample():
"""
NAME:
get_rcsample
PURPOSE:
get the RC sample
INPUT:
None so far
OUTPUT:
sample
HISTORY:
2015-02-10 - Started - Bovy (IAS@KITP)
"""
data= apread.rcsample()
# Cut to statistical sample
data= data[data['STAT'] == 1]
# Add the M_H-based distances
data= esutil.numpy_util.add_fields(data,[('RC_DIST_H', float),
('RC_DM_H', float),
('RC_GALR_H', float),
('RC_GALPHI_H', float),
('RC_GALZ_H', float)])
rcd= rcdist()
jk= data['J0']-data['K0']
z= isodist.FEH2Z(data['METALS'],zsolar=0.017)
data['RC_DIST_H']= rcd(jk,z,appmag=data['H0'],mh=True)
data['RC_DM_H']= 5.*numpy.log10(data['RC_DIST_H'])+10.
XYZ= bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['RC_DIST_H'],
degree=True)
R,phi,Z= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],
XYZ[:,1],
XYZ[:,2],
Xsun=8.,Zsun=0.025)
data['RC_GALR_H']= R
data['RC_GALPHI_H']= phi
data['RC_GALZ_H']= Z
# Add the average alpha/Fe
data= esutil.numpy_util.add_fields(data,[('AVG_ALPHAFE', float)])
data['AVG_ALPHAFE']= avg_alphafe(data)
# Apply -0.1 offset in [Fe/H]
data[_FEHTAG]+= -0.10
# Remove locations outside of the Pan-STARRS dust map
# In the Southern hemisphere
data= data[data['LOCATION_ID'] != 4266] #240,-18
data= data[data['LOCATION_ID'] != 4331] #5.5,-14.2
data= data[data['LOCATION_ID'] != 4381] #5.2,-12.2
data= data[data['LOCATION_ID'] != 4332] #1,-4
data= data[data['LOCATION_ID'] != 4329] #0,-5
data= data[data['LOCATION_ID'] != 4351] #0,-2
data= data[data['LOCATION_ID'] != 4353] #358,0
data= data[data['LOCATION_ID'] != 4385] #358.6,1.4
# Close to the ecliptic pole where there's no data (is it the ecliptic pole?
data= data[data['LOCATION_ID'] != 4528] #120,30
data= data[data['LOCATION_ID'] != 4217] #123,22.4
# Remove stars w/ DM < 8.49, because for standard candle RC, these cannot be in the sample
data= data[data['RC_DM_H'] > 8.49]
return data
def glon_wrapper(*args,**kwargs):
if kwargs.pop('glon',False):
XYZ= bovy_coords.lbd_to_XYZ(args[0],args[1],args[2],degree=False)
R,phi,z= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],XYZ[:,1],XYZ[:,2],
Xsun=_R0,Zsun=_Zsun)
else:
R,phi,z= args[0],args[1],args[2]
return func(R,phi,z,*args[3:],**kwargs)
def glon_wrapper(*args,**kwargs):
if kwargs.pop('glon',False):
XYZ= bovy_coords.lbd_to_XYZ(args[0],args[1],args[2],degree=False)
R,phi,z= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],XYZ[:,1],XYZ[:,2],
Xsun=_R0,Zsun=_Zsun)
else:
R,phi,z= args[0],args[1],args[2]
return func(R,phi,z,*args[3:],**kwargs)
def lbd_to_galcencyl(l, b, d, degree=True):
xyz = bovy_coords.lbd_to_XYZ(l, b, d, degree=degree)
Rphiz = bovy_coords.XYZ_to_galcencyl(xyz[:, 0],
xyz[:, 1],
xyz[:, 2],
Xsun=1.,
Zsun=0.)
return (Rphiz[:, 0], Rphiz[:, 1], Rphiz[:, 2])
def test_lbd_to_XYZ():
l,b,d= 90., 30.,1.
XYZ= bovy_coords.lbd_to_XYZ(l,b,d,degree=True)
assert numpy.fabs(XYZ[0]) <10.**-10., 'lbd_to_XYZ conversion does not work as expected'
assert numpy.fabs(XYZ[1]-numpy.sqrt(3.)/2.) < 10.**-10., 'lbd_to_XYZ conversion does not work as expected'
assert numpy.fabs(XYZ[2]-0.5) < 10.**-10., 'lbd_to_XYZ conversion does not work as expected'
# Also test for degree=False
XYZ= bovy_coords.lbd_to_XYZ(l/180.*numpy.pi,b/180.*numpy.pi,d,degree=False)
assert numpy.fabs(XYZ[0]) <10.**-10., 'lbd_to_XYZ conversion does not work as expected'
assert numpy.fabs(XYZ[1]-numpy.sqrt(3.)/2.) < 10.**-10., 'lbd_to_XYZ conversion does not work as expected'
assert numpy.fabs(XYZ[2]-0.5) < 10.**-10., 'lbd_to_XYZ conversion does not work as expected'
# Also test for arrays
os= numpy.ones(2)
XYZ= bovy_coords.lbd_to_XYZ(os*l/180.*numpy.pi,os*b/180.*numpy.pi,
os*d,degree=False)
assert numpy.all(numpy.fabs(XYZ[:,0]) <10.**-10.), 'lbd_to_XYZ conversion does not work as expected'
assert numpy.all(numpy.fabs(XYZ[:,1]-numpy.sqrt(3.)/2.) < 10.**-10.), 'lbd_to_XYZ conversion does not work as expected'
assert numpy.all(numpy.fabs(XYZ[:,2]-0.5) < 10.**-10.), 'lbd_to_XYZ conversion does not work as expected'
return None
def cut_indx_vol(gaia, rcut, zcut):
XYZ = bovy_coords.lbd_to_XYZ(gaia['l'],
gaia['b'],
1. / gaia['parallax'],
degree=True)
r_cyl = np.sqrt(XYZ[:, 0]**2. + XYZ[:, 1]**2.)
z_cyl = XYZ[:, 2]
return [(r_cyl < r_cyl_cut) * (np.abs(z_cyl) < z_cyl_cut)]
def measure_kinematics_onepop(tgas,twomass,jk,dm,mj,spii,zbins,options,
csvwriter,csvout,maxcovar=30.):
# Compute XYZ
lb= bovy_coords.radec_to_lb(tgas['ra'],tgas['dec'],degree=True,epoch=None)
XYZ= bovy_coords.lbd_to_XYZ(lb[:,0],lb[:,1],1./tgas['parallax'],
degree=True)
# Generate vradec and projection matrix
vradec= numpy.array([bovy_coords._K/tgas['parallax']*tgas['pmra'],
bovy_coords._K/tgas['parallax']*tgas['pmdec']])
proj= compute_projection(tgas)
# Sample from the joint (parallax,proper motion) uncertainty distribution
# to get the covariance matrix of the vradec, using MC sims
nmc= 10001
vradec_cov= compute_vradec_cov_mc(tgas,nmc)
# Fit each zbin
if spii == options.start:
startz= options.startz
else:
startz= 0
for ii in tqdm.trange(startz,len(zbins)-1):
indx= (XYZ[:,2] > zbins[ii])\
*(XYZ[:,2] <= zbins[ii+1])\
*(numpy.sqrt(XYZ[:,0]**2.+XYZ[:,1]**2.) < 0.2)
nstar= numpy.sum(indx)
if numpy.sum(indx) < 30: continue
# Basic XD fit
ydata= vradec.T[indx]
ycovar= numpy.zeros_like(vradec.T)[indx]
initamp= numpy.random.uniform(size=options.ngauss)
initamp/= numpy.sum(initamp)
m= numpy.zeros(3)
s= numpy.array([40.,40.,20.])
initmean= []
initcovar= []
for jj in range(options.ngauss):
initmean.append(m+numpy.random.normal(size=3)*s)
initcovar.append(4.*s**2.*numpy.diag(numpy.ones(3)))
initcovar= numpy.array(initcovar)
initmean= numpy.array(initmean)
lnL= extreme_deconvolution(ydata,ycovar,initamp,initmean,initcovar,
projection=proj[indx])
sig2z= combined_sig2(initamp,initmean[:,2],initcovar[:,2,2],
maxcovar=maxcovar)
kurtz= combined_k(initamp,initmean[:,2],initcovar[:,2,2],
maxcovar=maxcovar)
sam= bootstrap(options.nboot,
vradec.T[indx],vradec_cov[indx],proj[indx],
ngauss=options.ngauss,maxcovar=maxcovar)
sig2z_err= 1.4826*numpy.median(numpy.fabs(sam[0]-numpy.median(sam[0])))
kurtz_err= 1.4826*numpy.median(numpy.fabs(sam[1]-numpy.median(sam[1])))
sig2kurtz_corr= numpy.corrcoef(sam)[0,1]
csvwriter.writerow([spii,ii,nstar,
sig2z,sig2z_err,kurtz,kurtz_err,sig2kurtz_corr])
csvout.flush()
return None
def xyz(req_dict):
#get heliocentric position
x_hc, y_hc, z_hc = b_c.lbd_to_XYZ(req_dict['l'],
req_dict['b'],
req_dict['dist'],
degree=True)
#get galactocentric position
x_gc, y_gc, z_gc = b_c.XYZ_to_galcenrect(x_hc, y_hc, z_hc, Xsun, Zsun)
return float(x_gc), y_gc, float(z_gc)
def force_pal5(pot,dpal5,ro,vo):
"""Return the force at Pal5"""
# First compute the location based on the distance
l5, b5= bovy_coords.radec_to_lb(229.018,-0.124,degree=True)
X5,Y5,Z5= bovy_coords.lbd_to_XYZ(l5,b5,dpal5,degree=True)
R5,p5,Z5= bovy_coords.XYZ_to_galcencyl(X5,Y5,Z5,Xsun=ro,Zsun=0.025)
return (potential.evaluateRforces(pot,R5/ro,Z5/ro,phi=p5,
use_physical=True,ro=ro,vo=vo),
potential.evaluatezforces(pot,R5/ro,Z5/ro,phi=p5,
use_physical=True,ro=ro,vo=vo),
potential.evaluatephiforces(pot,R5/ro,Z5/ro,phi=p5,
use_physical=True,ro=ro,vo=vo))
def readAndHackHoltz():
alldata = apread.allStar(adddist=True, distredux="v402")
jk = alldata["J0"] - alldata["K0"]
data = alldata[(jk > 0.8) * (alldata["DISO_GAL"] > 0.0)]
# To allow for XY pixelization, we will hack these
data = esutil.numpy_util.add_fields(data, [("RC_GALR", float), ("RC_GALPHI", float), ("RC_GALZ", float)])
XYZ = bovy_coords.lbd_to_XYZ(data["GLON"], data["GLAT"], data["DISO_GAL"], degree=True)
R, phi, Z = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0], XYZ[:, 1], XYZ[:, 2], Xsun=8.0, Zsun=0.025)
data["RC_GALR"] = R
data["RC_GALPHI"] = phi
data["RC_GALZ"] = Z
return data
def test_XYZ_to_lbd():
l,b,d= 90., 30.,1.
XYZ= bovy_coords.lbd_to_XYZ(l,b,d,degree=True)
lt,bt,dt= bovy_coords.XYZ_to_lbd(XYZ[0],XYZ[1],XYZ[2],degree=True)
assert numpy.fabs(lt-l) <10.**-10., 'XYZ_to_lbd conversion does not work as expected'
assert numpy.fabs(bt-b) < 10.**-10., 'XYZ_to_lbd conversion does not work as expected'
assert numpy.fabs(dt-d) < 10.**-10., 'XYZ_to_lbd conversion does not work as expected'
# Also test for degree=False
XYZ= bovy_coords.lbd_to_XYZ(l/180.*numpy.pi,b/180.*numpy.pi,d,degree=False)
lt,bt,dt= bovy_coords.XYZ_to_lbd(XYZ[0],XYZ[1],XYZ[2],degree=False)
assert numpy.fabs(lt-l/180.*numpy.pi) <10.**-10., 'XYZ_to_lbd conversion does not work as expected'
assert numpy.fabs(bt-b/180.*numpy.pi) < 10.**-10., 'XYZ_to_lbd conversion does not work as expected'
assert numpy.fabs(dt-d) < 10.**-10., 'XYZ_to_lbd conversion does not work as expected'
# Also test for arrays
os= numpy.ones(2)
XYZ= bovy_coords.lbd_to_XYZ(os*l/180.*numpy.pi,os*b/180.*numpy.pi,
os*d,degree=False)
lbdt= bovy_coords.XYZ_to_lbd(XYZ[:,0],XYZ[:,1],XYZ[:,2],degree=False)
assert numpy.all(numpy.fabs(lbdt[:,0]-l/180.*numpy.pi) <10.**-10.), 'XYZ_to_lbd conversion does not work as expected'
assert numpy.all(numpy.fabs(lbdt[:,1]-b/180.*numpy.pi) < 10.**-10.), 'XYZ_to_lbd conversion does not work as expected'
assert numpy.all(numpy.fabs(lbdt[:,2]-d) < 10.**-10.), 'XYZ_to_lbd conversion does not work as expected'
return None
def to_space_velocties(self):
"""
Wrapper around galpy, and wrapper to go through steps to calc UVW
"""
self.conv_pmrapmdec_to_pmllpmbb()
self.calc_covar_pmrapmdec()
self.calc_covar_pmllpmbb()
self.XYZ = np.array(bcoords.lbd_to_XYZ(self.get_col('GLON'),
self.get_col('GLAT'),
self.get_col('RC_DIST'),
degree=True))
self.calc_spacevel()
self.calc_spacevel_uncer_var_tensor()
def test_coords():
from galpy.util import bovy_coords
ra, dec, dist = 161., 50., 8.5
pmra, pmdec, vlos = -6.8, -10., -115.
# Convert to Galactic and then to rect. Galactic
ll, bb = bovy_coords.radec_to_lb(ra, dec, degree=True)
pmll, pmbb = bovy_coords.pmrapmdec_to_pmllpmbb(pmra,
pmdec,
ra,
dec,
degree=True)
X, Y, Z = bovy_coords.lbd_to_XYZ(ll, bb, dist, degree=True)
vX, vY, vZ = bovy_coords.vrpmllpmbb_to_vxvyvz(vlos,
pmll,
pmbb,
X,
Y,
Z,
XYZ=True)
# Convert to cylindrical Galactocentric
# Assuming Sun's distance to GC is (8,0.025) in (R,z)
R, phi, z = bovy_coords.XYZ_to_galcencyl(X, Y, Z, Xsun=8., Zsun=0.025)
vR, vT, vz = bovy_coords.vxvyvz_to_galcencyl(vX,
vY,
vZ,
R,
phi,
Z,
vsun=[-10.1, 244., 6.7],
galcen=True)
# 5/12/2016: test weakened, because improved galcen<->heliocen
# transformation has changed these, but still close
print(R, phi, z, vR, vT, vz)
assert numpy.fabs(R - 12.51328515156942
) < 10.**-1., 'Coordinate transformation has changed'
assert numpy.fabs(phi - 0.12177409073433249
) < 10.**-1., 'Coordinate transformation has changed'
assert numpy.fabs(z - 7.1241282354856228
) < 10.**-1., 'Coordinate transformation has changed'
assert numpy.fabs(vR - 78.961682923035966
) < 10.**-1., 'Coordinate transformation has changed'
assert numpy.fabs(vT + 241.49247772351964
) < 10.**-1., 'Coordinate transformation has changed'
assert numpy.fabs(vz + 102.83965442188689
) < 10.**-1., 'Coordinate transformation has changed'
return None
def xyzgrid(apo, distmods):
"""
Generates a grid of x, y, z for each location in apo at the distance moduli supplied
"""
ds = 10**(distmods / 5. - 2.)
xgrid = np.zeros((len(apo._locations), len(ds)))
ygrid = np.zeros((len(apo._locations), len(ds)))
zgrid = np.zeros((len(apo._locations), len(ds)))
for i in range(len(apo._locations)):
glon, glat = apo.glonGlat(apo._locations[i])
glon = np.ones(len(ds)) * glon[0]
glat = np.ones(len(ds)) * glat[0]
xyz = bovy_coords.lbd_to_XYZ(glon, glat, ds, degree=True)
xgrid[i] = xyz[:, 0]
ygrid[i] = xyz[:, 1]
zgrid[i] = xyz[:, 2]
return zgrid, ygrid, zgrid
def Rphizgrid(apo,distmods):
"""
Generates a grid of R, phi, z for each location in apo at the distance moduli supplied
"""
ds = 10**(distmods/5.-2.)
Rgrid = np.zeros((len(apo._locations),len(ds)))
phigrid = np.zeros((len(apo._locations),len(ds)))
zgrid = np.zeros((len(apo._locations),len(ds)))
for i in range(len(apo._locations)):
glon,glat = apo.glonGlat(apo._locations[i])
glon = np.ones(len(ds))*glon[0]
glat = np.ones(len(ds))*glat[0]
xyz = bovy_coords.lbd_to_XYZ(glon,glat,ds, degree=True)
rphiz = bovy_coords.XYZ_to_galcencyl(xyz[:,0], xyz[:,1], xyz[:,2], Xsun=8., Zsun=0.02)
Rgrid[i] = rphiz[:,0]
phigrid[i] = rphiz[:,1]
zgrid[i] = rphiz[:,2]
return Rgrid, phigrid, zgrid
def test_coords():
from galpy.util import bovy_coords
ra, dec, dist= 161., 50., 8.5
pmra, pmdec, vlos= -6.8, -10., -115.
# Convert to Galactic and then to rect. Galactic
ll, bb= bovy_coords.radec_to_lb(ra,dec,degree=True)
pmll, pmbb= bovy_coords.pmrapmdec_to_pmllpmbb(pmra,pmdec,ra,dec,degree=True)
X,Y,Z= bovy_coords.lbd_to_XYZ(ll,bb,dist,degree=True)
vX,vY,vZ= bovy_coords.vrpmllpmbb_to_vxvyvz(vlos,pmll,pmbb,X,Y,Z,XYZ=True)
# Convert to cylindrical Galactocentric
# Assuming Sun's distance to GC is (8,0.025) in (R,z)
R,phi,z= bovy_coords.XYZ_to_galcencyl(X,Y,Z,Xsun=8.,Zsun=0.025)
vR,vT,vz= bovy_coords.vxvyvz_to_galcencyl(vX,vY,vZ,R,phi,Z,vsun=[-10.1,244.,6.7],galcen=True)
assert numpy.fabs(R-12.51328515156942) < 10.**-4., 'Coordinate transformation has changed'
assert numpy.fabs(phi-0.12177409073433249) < 10.**-4., 'Coordinate transformation has changed'
assert numpy.fabs(z-7.1241282354856228) < 10.**-4., 'Coordinate transformation has changed'
assert numpy.fabs(vR-78.961682923035966) < 10.**-4., 'Coordinate transformation has changed'
assert numpy.fabs(vT+241.49247772351964) < 10.**-4., 'Coordinate transformation has changed'
assert numpy.fabs(vz+102.83965442188689) < 10.**-4., 'Coordinate transformation has changed'
return None
def _calc_lnprob(loc, nls, nbs, ds, distmods, H0, densfunc):
lcen, bcen = apo.glonGlat(loc)
rad = apo.radius(loc)
ls = numpy.linspace(lcen - rad, lcen + rad, nls)
bs = numpy.linspace(bcen - rad, bcen + rad, nbs)
# Tile these
tls = numpy.tile(ls, (len(ds), len(bs), 1))
tbs = numpy.swapaxes(numpy.tile(bs, (len(ds), len(ls), 1)), 1, 2)
tds = numpy.tile(ds, (len(ls), len(bs), 1)).T
XYZ = bovy_coords.lbd_to_XYZ(tls.flatten(),
tbs.flatten(),
tds.flatten(),
degree=True)
Rphiz = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2],
Xsun=define_rcsample._R0,
Ysun=0.,
Zsun=define_rcsample._Z0)
# Evaluate probability density
tH = numpy.tile(distmods.T, (1, len(ls), len(bs), 1))[0].T
for ii in range(tH.shape[1]):
for jj in range(tH.shape[2]):
try:
tH[:, ii, jj] += dmap(ls[jj], bs[ii], ds)
except (IndexError, TypeError, ValueError):
try:
tH[:, ii, jj] += dmapg15(ls[jj], bs[ii], ds)
except IndexError: # assume zero outside
pass
tH = tH.flatten() + H0[0]
ps= densfunc(Rphiz[0],Rphiz[1],Rphiz[2])*apo(loc,tH)\
*numpy.fabs(numpy.cos(tbs.flatten()/180.*numpy.pi))\
*tds.flatten()**3.
return numpy.log(numpy.reshape(ps,(len(distmods),nbs,nls))\
+10.**-8.)
def from_radec(cluster, do_order=False, do_key_params=False):
"""Calculate galactocentric coordinates from on-sky position, proper motion, and radial velocity of cluster
Parameters
----------
cluster : class
StarCluster
do_order : bool
sort star by radius after coordinate change (default: False)
do_key_params : bool
call key_params to calculate key parameters after unit change (default: False)
Returns
-------
None
History:
-------
2018 - Written - Webb (UofT)
"""
if cluster.units == "radec" and cluster.origin == "sky":
origin0 = cluster.origin
l, b = bovy_coords.radec_to_lb(cluster.ra, cluster.dec, degree=True).T
x0, y0, z0 = bovy_coords.lbd_to_XYZ(l, b, cluster.dist, degree=True).T
cluster.x, cluster.y, cluster.z = bovy_coords.XYZ_to_galcenrect(
x0, y0, z0, Xsun=8.0, Zsun=0.025).T
pml, pmb = bovy_coords.pmrapmdec_to_pmllpmbb(cluster.pmra,
cluster.pmdec,
cluster.ra,
cluster.dec,
degree=True).T
vx0, vy0, vz0 = bovy_coords.vrpmllpmbb_to_vxvyvz(cluster.vlos,
pml,
pmb,
l,
b,
cluster.dist,
degree=True).T
cluster.vx, cluster.vy, cluster.vz = bovy_coords.vxvyvz_to_galcenrect(
vx0,
vy0,
vz0,
vsun=[0.0, 220.0, 0.0],
Xsun=8.0,
Zsun=0.025,
_extra_rot=True,
).T
l_gc, b_gc = bovy_coords.radec_to_lb(cluster.ra_gc,
cluster.dec_gc,
degree=True)
x0_gc, y0_gc, z0_gc = bovy_coords.lbd_to_XYZ(l_gc,
b_gc,
cluster.dist_gc,
degree=True)
cluster.xgc, cluster.ygc, cluster.zgc = bovy_coords.XYZ_to_galcenrect(
x0_gc, y0_gc, z0_gc, Xsun=8.0, Zsun=0.025)
pml_gc, pmb_gc = bovy_coords.pmrapmdec_to_pmllpmbb(cluster.pmra_gc,
cluster.pmdec_gc,
cluster.ra_gc,
cluster.dec_gc,
degree=True)
vx0_gc, vy0_gc, vz0_gc = bovy_coords.vrpmllpmbb_to_vxvyvz(
cluster.vlos_gc,
pml_gc,
pmb_gc,
l_gc,
b_gc,
cluster.dist_gc,
degree=True)
cluster.vx_gc, cluster.vy_gc, cluster.vz_gc = bovy_coords.vxvyvz_to_galcenrect(
vx0_gc,
vy0_gc,
vz0_gc,
vsun=[0.0, 220.0, 0.0],
Xsun=8.0,
Zsun=0.025,
_extra_rot=True,
)
cluster.origin = "galaxy"
cluster.units = "kpckms"
cluster.rv3d()
if do_key_params:
cluster.key_params(do_order=do_order)
def __init__(self,
vxvv=None,
uvw=False,
lb=False,
radec=False,
vo=235.,
ro=8.5,
zo=0.025,
solarmotion='hogg'):
"""
NAME:
__init__
PURPOSE:
Initialize an Orbit instance
INPUT:
vxvv - initial conditions
3D can be either
1) in Galactocentric cylindrical coordinates [R,vR,vT(,z,vz,phi)]
2) [ra,dec,d,mu_ra, mu_dec,vlos] in [deg,deg,kpc,mas/yr,mas/yr,km/s] (all J2000.0; mu_ra = mu_ra * cos dec)
3) [ra,dec,d,U,V,W] in [deg,deg,kpc,km/s,km/s,kms]
4) (l,b,d,mu_l, mu_b, vlos) in [deg,deg,kpc,mas/yr,mas/yr,km/s) (all J2000.0; mu_l = mu_l * cos b)
5) [l,b,d,U,V,W] in [deg,deg,kpc,km/s,km/s,kms]
4) and 5) also work when leaving out b and mu_b/W
OPTIONAL INPUTS:
radec - if True, input is 2) (or 3) above
uvw - if True, velocities are UVW
lb - if True, input is 4) or 5) above
vo - circular velocity at ro
ro - distance from vantage point to GC (kpc)
zo - offset toward the NGP of the Sun wrt the plane (kpc)
solarmotion - 'hogg' or 'dehnen', or 'schoenrich', or value in
[-U,V,W]
OUTPUT:
instance
HISTORY:
2010-07-20 - Written - Bovy (NYU)
"""
if isinstance(solarmotion, str) and solarmotion.lower() == 'hogg':
vsolar = nu.array([-10.1, 4.0, 6.7]) / vo
elif isinstance(solarmotion, str) and solarmotion.lower() == 'dehnen':
vsolar = nu.array([-10., 5.25, 7.17]) / vo
elif isinstance(solarmotion,str) \
and solarmotion.lower() == 'schoenrich':
vsolar = nu.array([-11.1, 12.24, 7.25]) / vo
else:
vsolar = nu.array(solarmotion) / vo
if radec or lb:
if radec:
l, b = coords.radec_to_lb(vxvv[0], vxvv[1], degree=True)
elif len(vxvv) == 4:
l, b = vxvv[0], 0.
else:
l, b = vxvv[0], vxvv[1]
if uvw:
X, Y, Z = coords.lbd_to_XYZ(l, b, vxvv[2], degree=True)
vx = vxvv[3]
vy = vxvv[4]
vz = vxvv[5]
else:
if radec:
pmll, pmbb = coords.pmrapmdec_to_pmllpmbb(vxvv[3],
vxvv[4],
vxvv[0],
vxvv[1],
degree=True)
d, vlos = vxvv[2], vxvv[5]
elif len(vxvv) == 4:
pmll, pmbb = vxvv[2], 0.
d, vlos = vxvv[1], vxvv[3]
else:
pmll, pmbb = vxvv[3], vxvv[4]
d, vlos = vxvv[2], vxvv[5]
X, Y, Z, vx, vy, vz = coords.sphergal_to_rectgal(l,
b,
d,
vlos,
pmll,
pmbb,
degree=True)
X /= ro
Y /= ro
Z /= ro
vx /= vo
vy /= vo
vz /= vo
vsun = nu.array([
0.,
1.,
0.,
]) + vsolar
R, phi, z = coords.XYZ_to_galcencyl(X, Y, Z, Zsun=zo / ro)
vR, vT, vz = coords.vxvyvz_to_galcencyl(vx,
vy,
vz,
R,
phi,
z,
vsun=vsun,
galcen=True)
if lb and len(vxvv) == 4: vxvv = [R, vR, vT, phi]
else: vxvv = [R, vR, vT, z, vz, phi]
self.vxvv = vxvv
if len(vxvv) == 2:
self._orb = linearOrbit(vxvv=vxvv)
elif len(vxvv) == 3:
self._orb = planarROrbit(vxvv=vxvv)
elif len(vxvv) == 4:
self._orb = planarOrbit(vxvv=vxvv)
elif len(vxvv) == 5:
self._orb = RZOrbit(vxvv=vxvv)
elif len(vxvv) == 6:
self._orb = FullOrbit(vxvv=vxvv)
def action(ra_deg, dec_deg, d_kpc, pm_ra_masyr, pm_dec_masyr, v_los_kms,
verbose=False):
"""
parameters:
----------
ra_deg: (float)
RA in degrees.
dec_deg: (float)
Dec in degress.
d_kpc: (float)
Distance in kpc.
pm_ra_masyr: (float)
RA proper motion in mas/yr.
pm_decmasyr: (float)
Dec proper motion in mas/yr.
v_los_kms: (float)
RV in kms.
returns:
------
R_kpc, phi_rad, z_kpc, vR_kms, vT_kms, vz_kms
jR: (float)
Radial action.
lz: (float)
Vertical ang mom.
jz: (float)
Vertical action.
"""
ra_rad = ra_deg * (np.pi / 180.) # RA [rad]
dec_rad = dec_deg * (np.pi / 180.) # dec [rad]
# Galactocentric position of the Sun:
X_gc_sun_kpc = 8. # [kpc]
Z_gc_sun_kpc = 0.025 # [kpc]
# Galactocentric velocity of the Sun:
vX_gc_sun_kms = -9.58 # = -U [kms]
vY_gc_sun_kms = 10.52 + 220. # = V+v_circ(R_Sun) [kms]
vZ_gc_sun_kms = 7.01 # = W [kms]
# a. convert spatial coordinates (ra,dec,d) to (R,z,phi)
# (ra,dec) --> Galactic coordinates (l,b):
lb = bovy_coords.radec_to_lb(ra_rad, dec_rad, degree=False, epoch=2000.0)
# l_rad = lb[:, 0]
# b_rad = lb[:, 1]
l_rad = lb[0]
b_rad = lb[1]
# (l,b,d) --> Galactocentric cartesian coordinates (x,y,z):
xyz = bovy_coords.lbd_to_XYZ(l_rad, b_rad, d_kpc, degree=False)
# x_kpc = xyz[:, 0]
# y_kpc = xyz[:, 1]
# z_kpc = xyz[:, 2]
x_kpc = xyz[0]
y_kpc = xyz[1]
z_kpc = xyz[2]
# (x,y,z) --> Galactocentric cylindrical coordinates (R,z,phi):
Rzphi = bovy_coords.XYZ_to_galcencyl(x_kpc, y_kpc, z_kpc,
Xsun=X_gc_sun_kpc, Zsun=Z_gc_sun_kpc)
# R_kpc = Rzphi[:, 0]
# phi_rad = Rzphi[:, 1]
# z_kpc = Rzphi[:, 2]
R_kpc = Rzphi[0]
phi_rad = Rzphi[1]
z_kpc = Rzphi[2]
# b. convert velocities (pm_ra,pm_dec,vlos) to (vR,vz,vT)
# (pm_ra,pm_dec) --> (pm_l,pm_b):
pmlpmb = bovy_coords.pmrapmdec_to_pmllpmbb(pm_ra_masyr, pm_dec_masyr,
ra_rad, dec_rad, degree=False,
epoch=2000.0)
# pml_masyr = pmlpmb[:, 0]
# pmb_masyr = pmlpmb[:, 1]
pml_masyr = pmlpmb[0]
pmb_masyr = pmlpmb[1]
# (v_los,pm_l,pm_b) & (l,b,d) --> (vx,vy,vz):
vxvyvz = bovy_coords.vrpmllpmbb_to_vxvyvz(v_los_kms, pml_masyr, pmb_masyr,
l_rad, b_rad, d_kpc, XYZ=False,
degree=False)
# vx_kms = vxvyvz[:, 0]
# vy_kms = vxvyvz[:, 1]
# vz_kms = vxvyvz[:, 2]
vx_kms = vxvyvz[0]
vy_kms = vxvyvz[1]
vz_kms = vxvyvz[2]
# (vx,vy,vz) & (x,y,z) --> (vR,vT,vz):
vRvTvZ = bovy_coords.vxvyvz_to_galcencyl(vx_kms, vy_kms, vz_kms, R_kpc,
phi_rad, z_kpc,
vsun=[vX_gc_sun_kms,
vY_gc_sun_kms,
vZ_gc_sun_kms],
galcen=True)
# vR_kms = vRvTvZ[:, 0]
# vT_kms = vRvTvZ[:, 1]
# vz_kms = vRvTvZ[:, 2]
vR_kms = vRvTvZ[0]
vT_kms = vRvTvZ[1]
vz_kms = vRvTvZ[2]
if verbose:
print("R = ", R_kpc, "\t kpc")
print("phi = ", phi_rad, "\t rad")
print("z = ", z_kpc, "\t kpc")
print("v_R = ", vR_kms, "\t km/s")
print("v_T = ", vT_kms, "\t km/s")
print("v_z = ", vz_kms, "\t km/s")
jR, lz, jz = calc_actions(R_kpc, phi_rad, z_kpc, vR_kms, vT_kms, vz_kms)
return R_kpc, phi_rad, z_kpc, vR_kms, vT_kms, vz_kms, jR, lz, jz
def findfriends(targname,radial_velocity,velocity_limit=5.0,search_radius=25.0,rvcut=5.0,radec=[None,None],output_directory = None,showplots=False,verbose=False,DoGALEX=True,DoWISE=True,DoROSAT=True):
radvel= radial_velocity * u.kilometer / u.second
if output_directory == None:
outdir = './' + targname.replace(" ", "") + '_friends/'
else:
outdir = output_directory
if os.path.isdir(outdir) == True:
print('Output directory ' + outdir +' Already Exists!!')
print('Either Move it, Delete it, or input a different [output_directory] Please!')
return
os.mkdir(outdir)
if velocity_limit < 0.00001 :
print('input velocity_limit is too small, try something else')
print('velocity_limit: ' + str(velocity_limit))
if search_radius < 0.0000001:
print('input search_radius is too small, try something else')
print('search_radius: ' + str(search_radius))
# Search parameters
vlim=velocity_limit * u.kilometer / u.second
searchradpc=search_radius * u.parsec
if (radec[0] != None) & (radec[1] != None):
usera,usedec = radec[0],radec[1]
else: ##use the target name to get simbad ra and dec.
print('Asking Simbad for RA and DEC')
result_table = Simbad.query_object(targname)
usera,usedec = result_table['RA'][0],result_table['DEC'][0]
if verbose == True:
print('Target name: ',targname)
print('Coordinates: ' + str(usera) +' '+str(usedec))
print()
c = SkyCoord( ra=usera , dec=usedec , unit=(u.hourangle, u.deg) , frame='icrs')
if verbose == True: print(c)
# Find precise coordinates and distance from Gaia, define search radius and parallax cutoff
print('Asking Gaia for precise coordinates')
sqltext = "SELECT * FROM gaiaedr3.gaia_source WHERE CONTAINS( \
POINT('ICRS',gaiaedr3.gaia_source.ra,gaiaedr3.gaia_source.dec), \
CIRCLE('ICRS'," + str(c.ra.value) +","+ str(c.dec.value) +","+ str(6.0/3600.0) +"))=1;"
job = Gaia.launch_job_async(sqltext , dump_to_file=False)
Pgaia = job.get_results()
if verbose == True:
print(sqltext)
print()
print(Pgaia['source_id','ra','dec','phot_g_mean_mag','parallax','ruwe'].pprint_all())
print()
minpos = Pgaia['phot_g_mean_mag'].tolist().index(min(Pgaia['phot_g_mean_mag']))
Pcoord = SkyCoord( ra=Pgaia['ra'][minpos]*u.deg , dec=Pgaia['dec'][minpos]*u.deg , \
distance=(1000.0/Pgaia['parallax'][minpos])*u.parsec , frame='icrs' , \
radial_velocity=radvel , \
pm_ra_cosdec=Pgaia['pmra'][minpos]*u.mas/u.year , pm_dec=Pgaia['pmdec'][minpos]*u.mas/u.year )
searchraddeg = np.arcsin(searchradpc/Pcoord.distance).to(u.deg)
minpar = (1000.0 * u.parsec) / (Pcoord.distance + searchradpc) * u.mas
if verbose == True:
print(Pcoord)
print()
print('Search radius in deg: ',searchraddeg)
print('Minimum parallax: ',minpar)
# Query Gaia with search radius and parallax cut
# Note, a cut on parallax_error was added because searches at low galactic latitude
# return an overwhelming number of noisy sources that scatter into the search volume - ALK 20210325
print('Querying Gaia for neighbors')
Pllbb = bc.radec_to_lb(Pcoord.ra.value , Pcoord.dec.value , degree=True)
if ( np.abs(Pllbb[1]) > 10.0): plxcut = max( 0.5 , (1000.0/Pcoord.distance.value/10.0) )
else: plxcut = 0.5
print('Parallax cut: ',plxcut)
if (searchradpc < Pcoord.distance):
sqltext = "SELECT * FROM gaiaedr3.gaia_source WHERE CONTAINS( \
POINT('ICRS',gaiaedr3.gaia_source.ra,gaiaedr3.gaia_source.dec), \
CIRCLE('ICRS'," + str(Pcoord.ra.value) +","+ str(Pcoord.dec.value) +","+ str(searchraddeg.value) +"))\
=1 AND parallax>" + str(minpar.value) + " AND parallax_error<" + str(plxcut) + ";"
if (searchradpc >= Pcoord.distance):
sqltext = "SELECT * FROM gaiaedr3.gaia_source WHERE parallax>" + str(minpar.value) + " AND parallax_error<" + str(plxcut) + ";"
print('Note, using all-sky search')
if verbose == True:
print(sqltext)
print()
job = Gaia.launch_job_async(sqltext , dump_to_file=False)
r = job.get_results()
if verbose == True: print('Number of records: ',len(r['ra']))
# Construct coordinates array for all stars returned in cone search
gaiacoord = SkyCoord( ra=r['ra'] , dec=r['dec'] , distance=(1000.0/r['parallax'])*u.parsec , \
frame='icrs' , \
pm_ra_cosdec=r['pmra'] , pm_dec=r['pmdec'] )
sep = gaiacoord.separation(Pcoord)
sep3d = gaiacoord.separation_3d(Pcoord)
if verbose == True:
print('Printing angular separations in degrees as sanity check')
print(sep.degree)
Pllbb = bc.radec_to_lb(Pcoord.ra.value , Pcoord.dec.value , degree=True)
Ppmllpmbb = bc.pmrapmdec_to_pmllpmbb( Pcoord.pm_ra_cosdec.value , Pcoord.pm_dec.value , \
Pcoord.ra.value , Pcoord.dec.value , degree=True )
Pvxvyvz = bc.vrpmllpmbb_to_vxvyvz(Pcoord.radial_velocity.value , Ppmllpmbb[0] , Ppmllpmbb[1] , \
Pllbb[0] , Pllbb[1] , Pcoord.distance.value/1000.0 , XYZ=False , degree=True)
if verbose == True:
print('Science Target Name: ',targname)
print('Science Target RA/DEC: ',Pcoord.ra.value,Pcoord.dec.value)
print('Science Target Galactic Coordinates: ',Pllbb)
print('Science Target UVW: ',Pvxvyvz)
print()
Gllbb = bc.radec_to_lb(gaiacoord.ra.value , gaiacoord.dec.value , degree=True)
Gxyz = bc.lbd_to_XYZ( Gllbb[:,0] , Gllbb[:,1] , gaiacoord.distance/1000.0 , degree=True)
Gvrpmllpmbb = bc.vxvyvz_to_vrpmllpmbb( \
Pvxvyvz[0]*np.ones(len(Gxyz[:,0])) , Pvxvyvz[1]*np.ones(len(Gxyz[:,1])) , Pvxvyvz[2]*np.ones(len(Gxyz[:,2])) , \
Gxyz[:,0] , Gxyz[:,1] , Gxyz[:,2] , XYZ=True)
Gpmrapmdec = bc.pmllpmbb_to_pmrapmdec( Gvrpmllpmbb[:,1] , Gvrpmllpmbb[:,2] , Gllbb[:,0] , Gllbb[:,1] , degree=True)
# Code in case I want to do chi^2 cuts someday
Gvtanerr = 1.0 * np.ones(len(Gxyz[:,0]))
Gpmerr = Gvtanerr * 206265000.0 * 3.154e7 / (gaiacoord.distance.value * 3.086e13)
Gchi2 = ( (Gpmrapmdec[:,0]-gaiacoord.pm_ra_cosdec.value)**2 + (Gpmrapmdec[:,1]-gaiacoord.pm_dec.value)**2 )**0.5
Gchi2 = Gchi2 / Gpmerr
if verbose == True:
print('Predicted PMs if comoving:')
print(Gpmrapmdec , "\n")
print('Actual PMRAs from Gaia:')
print(gaiacoord.pm_ra_cosdec.value , "\n")
print('Actual PMDECs from Gaia:')
print(gaiacoord.pm_dec.value , "\n")
print('Predicted PM errors:')
print(Gpmerr , "\n")
print('Chi^2 values:')
print(Gchi2)
# Query external list(s) of RVs
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) )
yy = zz[0][np.argsort(sep3d[zz])]
RV = np.empty(np.array(r['ra']).size)
RVerr = np.empty(np.array(r['ra']).size)
RVsrc = np.array([ ' None' for x in range(np.array(r['ra']).size) ])
RV[:] = np.nan
RVerr[:] = np.nan
print('Populating RV table')
for x in range(0 , np.array(yy).size):
if np.isnan(r['dr2_radial_velocity'][yy[x]]) == False: # First copy over DR2 RVs
RV[yy[x]] = r['dr2_radial_velocity'][yy[x]]
RVerr[yy[x]] = r['dr2_radial_velocity_error'][yy[x]]
RVsrc[yy[x]] = 'Gaia DR2'
if os.path.isfile('LocalRV.csv'):
with open('LocalRV.csv') as csvfile: # Now check for a local RV that would supercede
readCSV = csv.reader(csvfile, delimiter=',')
for row in readCSV:
ww = np.where(r['designation'] == row[0])[0]
if (np.array(ww).size == 1):
RV[ww] = row[2]
RVerr[ww] = row[3]
RVsrc[ww] = row[4]
if verbose == True:
print('Using stored RV: ',row)
print(r['ra','dec','phot_g_mean_mag'][ww])
print(RV[ww])
print(RVerr[ww])
print(RVsrc[ww])
# Create Gaia CMD plot
mamajek = np.loadtxt(datapath+'/sptGBpRp.txt')
pleiades = np.loadtxt(datapath+'/PleGBpRp.txt')
tuchor = np.loadtxt(datapath+'/TucGBpRp.txt')
usco = np.loadtxt(datapath+'/UScGBpRp.txt')
chai = np.loadtxt(datapath+'/ChaGBpRp.txt')
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (np.isnan(r['bp_rp']) == False) ) # Note, this causes an error because NaNs
yy = zz[0][np.argsort(sep3d[zz])]
zz2= np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) & \
(r['phot_bp_rp_excess_factor'] < (1.3 + 0.06*r['bp_rp']**2)) & \
(np.isnan(r['bp_rp']) == False) ) # Note, this causes an error because NaNs
yy2= zz2[0][np.argsort((-Gchi2)[zz2])]
figname=outdir + targname.replace(" ", "") + "cmd.png"
if verbose == True: print(figname)
fig,ax1 = plt.subplots(figsize=(12,8))
ax1.axis([ math.floor(min(r['bp_rp'][zz])) , \
math.ceil(max(r['bp_rp'][zz])), \
math.ceil(max((r['phot_g_mean_mag'][zz] - (5.0*np.log10(gaiacoord.distance[zz].value)-5.0))))+1, \
math.floor(min((r['phot_g_mean_mag'][zz] - (5.0*np.log10(gaiacoord.distance[zz].value)-5.0))))-1 ] )
ax1.set_xlabel(r'$B_p-R_p$ (mag)' , fontsize=16)
ax1.set_ylabel(r'$M_G$ (mag)' , fontsize=16)
ax1.tick_params(axis='both',which='major',labelsize=12)
ax2 = ax1.twiny()
ax2.set_xlim(ax1.get_xlim())
spttickvals = np.array([ -0.037 , 0.377 , 0.782 , 0.980 , 1.84 , 2.50 , 3.36 , 4.75 ])
sptticklabs = np.array([ 'A0' , 'F0' , 'G0' , 'K0' , 'M0' , 'M3' , 'M5' , 'M7' ])
xx = np.where( (spttickvals >= math.floor(min(r['bp_rp'][zz]))) & (spttickvals <= math.ceil(max(r['bp_rp'][zz]))) )[0]
ax2.set_xticks(spttickvals[xx])
ax2.set_xticklabels( sptticklabs[xx] )
ax2.set_xlabel('SpT' , fontsize=16, labelpad=15)
ax2.tick_params(axis='both',which='major',labelsize=12)
ax1.plot( chai[:,1] , chai[:,0] , zorder=1 , label='Cha-I (0-5 Myr)')
ax1.plot( usco[:,1] , usco[:,0] , zorder=2 , label='USco (11 Myr)')
ax1.plot( tuchor[:,1] , tuchor[:,0] , zorder=3 , label='Tuc-Hor (40 Myr)')
ax1.plot(pleiades[:,1] , pleiades[:,0] , zorder=4 , label='Pleiades (125 Myr)')
ax1.plot( mamajek[:,2] , mamajek[:,1] , zorder=5 , label='Mamajek MS')
for x in range(0 , np.array(yy2).size):
msize = (17-12.0*(sep3d[yy2[x]].value/searchradpc.value))**2
mcolor = Gchi2[yy2[x]]
medge = 'black'
mzorder= 7
if (r['ruwe'][yy2[x]] < 1.2):
mshape='o'
if (r['ruwe'][yy2[x]] >= 1.2):
mshape='s'
if (np.isnan(rvcut) == False):
if (np.isnan(RV[yy2[x]])==False) & (np.abs(RV[yy2[x]]-Gvrpmllpmbb[yy2[x],0]) > rvcut):
mshape='+'
mcolor='black'
mzorder=6
if (np.isnan(RV[yy2[x]])==False) & (np.abs(RV[yy2[x]]-Gvrpmllpmbb[yy2[x],0]) <= rvcut):
medge='blue'
ccc = ax1.scatter(r['bp_rp'][yy2[x]] , (r['phot_g_mean_mag'][yy2[x]] - (5.0*np.log10(gaiacoord.distance[yy2[x]].value)-5.0)) , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
temp1 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='o' , s=12**2 , label = 'RUWE < 1.2')
temp2 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='s' , s=12**2 , label = 'RUWE >= 1.2')
temp3 = ax1.scatter([] , [] , c='white' , edgecolors='blue' , marker='o' , s=12**2 , label = 'RV Comoving')
temp4 = ax1.scatter([] , [] , c='black' , marker='+' , s=12**2 , label = 'RV Outlier')
ax1.plot(r['bp_rp'][yy[0]] , (r['phot_g_mean_mag'][yy[0]] - (5.0*np.log10(gaiacoord.distance[yy[0]].value)-5.0)) , \
'rx' , markersize=18 , mew=3 , markeredgecolor='red' , zorder=10 , label=targname)
ax1.arrow( 1.3 , 2.5 , 0.374, 0.743 , length_includes_head=True , head_width=0.07 , head_length = 0.10 )
ax1.text( 1.4 , 2.3, r'$A_V=1$' , fontsize=12)
ax1.legend(fontsize=11)
cb = plt.colorbar(ccc , ax=ax1)
cb.set_label(label='Velocity Difference (km/s)',fontsize=14)
plt.savefig(figname , bbox_inches='tight', pad_inches=0.2 , dpi=200)
if showplots == True: plt.show()
plt.close('all')
# Create PM plot
zz2= np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) )
yy2= zz2[0][np.argsort((-Gchi2)[zz2])]
zz3= np.where( (sep3d.value < searchradpc.value) & (sep.degree > 0.00001) )
figname=outdir + targname.replace(" ", "") + "pmd.png"
fig,ax1 = plt.subplots(figsize=(12,8))
ax1.axis([ (max(r['pmra'][zz2]) + 0.05*np.ptp(r['pmra'][zz2]) ) , \
(min(r['pmra'][zz2]) - 0.05*np.ptp(r['pmra'][zz2]) ) , \
(min(r['pmdec'][zz2])- 0.05*np.ptp(r['pmra'][zz2]) ) , \
(max(r['pmdec'][zz2])+ 0.05*np.ptp(r['pmra'][zz2]) ) ] )
ax1.tick_params(axis='both',which='major',labelsize=16)
if ((max(r['pmra'][zz2]) + 0.05*np.ptp(r['pmra'][zz2])) > 0.0) & \
((min(r['pmra'][zz2]) - 0.05*np.ptp(r['pmra'][zz2])) < 0.0) & \
((min(r['pmdec'][zz2])- 0.05*np.ptp(r['pmra'][zz2])) < 0.0) & \
((max(r['pmdec'][zz2])+ 0.05*np.ptp(r['pmra'][zz2])) > 0.0):
ax1.plot( [0.0,0.0] , [-1000.0,1000.0] , 'k--' , linewidth=1 )
ax1.plot( [-1000.0,1000.0] , [0.0,0.0] , 'k--' , linewidth=1 )
ax1.errorbar( (r['pmra'][yy2]) , (r['pmdec'][yy2]) , \
yerr=(r['pmdec_error'][yy2]) , xerr=(r['pmra_error'][yy2]) , fmt='none' , ecolor='k' )
ax1.scatter( (r['pmra'][zz3]) , (r['pmdec'][zz3]) , \
s=(0.5)**2 , marker='o' , c='black' , zorder=2 , label='Field' )
for x in range(0 , np.array(yy2).size):
msize = (17-12.0*(sep3d[yy2[x]].value/searchradpc.value))**2
mcolor = Gchi2[yy2[x]]
medge = 'black'
mzorder= 7
if (r['ruwe'][yy2[x]] < 1.2):
mshape='o'
if (r['ruwe'][yy2[x]] >= 1.2):
mshape='s'
if (np.isnan(rvcut) == False):
if (np.isnan(RV[yy2[x]])==False) & (np.abs(RV[yy2[x]]-Gvrpmllpmbb[yy2[x],0]) > rvcut):
mshape='+'
mcolor='black'
mzorder=6
if (np.isnan(RV[yy2[x]])==False) & (np.abs(RV[yy2[x]]-Gvrpmllpmbb[yy2[x],0]) <= rvcut):
medge='blue'
ccc = ax1.scatter(r['pmra'][yy2[x]] , r['pmdec'][yy2[x]] , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
temp1 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='o' , s=12**2 , label = 'RUWE < 1.2')
temp2 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='s' , s=12**2 , label = 'RUWE >= 1.2')
temp3 = ax1.scatter([] , [] , c='white' , edgecolors='blue' , marker='o' , s=12**2 , label = 'RV Comoving')
temp4 = ax1.scatter([] , [] , c='black' , marker='+' , s=12**2 , label = 'RV Outlier')
ax1.plot( Pgaia['pmra'][minpos] , Pgaia['pmdec'][minpos] , \
'rx' , markersize=18 , mew=3 , markeredgecolor='red' , zorder=3 , label=targname)
ax1.set_xlabel(r'$\mu_{RA}$ (mas/yr)' , fontsize=22 , labelpad=10)
ax1.set_ylabel(r'$\mu_{DEC}$ (mas/yr)' , fontsize=22 , labelpad=10)
ax1.legend(fontsize=12)
cb = plt.colorbar(ccc , ax=ax1)
cb.set_label(label='Tangential Velocity Difference (km/s)',fontsize=18 , labelpad=10)
plt.savefig(figname , bbox_inches='tight', pad_inches=0.2 , dpi=200)
if showplots == True: plt.show()
plt.close('all')
# Create RV plot
zz2= np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) & \
(np.isnan(RV) == False) )
yy2= zz2[0][np.argsort((-Gchi2)[zz2])]
zz3= np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) & \
(np.isnan(RV) == False) & (np.isnan(r['phot_g_mean_mag']) == False) & \
(np.abs(RV-Gvrpmllpmbb[:,0]) < 20.0) ) # Just to set Y axis
fig,ax1 = plt.subplots(figsize=(12,8))
ax1.axis([ -20.0 , +20.0, \
max( np.append( np.array(r['phot_g_mean_mag'][zz3] - (5.0*np.log10(gaiacoord.distance[zz3].value)-5.0)) , 0.0 )) + 0.3 , \
min( np.append( np.array(r['phot_g_mean_mag'][zz3] - (5.0*np.log10(gaiacoord.distance[zz3].value)-5.0)) , 15.0 )) - 0.3 ])
ax1.tick_params(axis='both',which='major',labelsize=16)
ax1.plot( [0.0,0.0] , [-20.0,25.0] , 'k--' , linewidth=1 )
ax1.errorbar( (RV[yy2]-Gvrpmllpmbb[yy2,0]) , \
(r['phot_g_mean_mag'][yy2] - (5.0*np.log10(gaiacoord.distance[yy2].value)-5.0)) , \
yerr=None,xerr=(RVerr[yy2]) , fmt='none' , ecolor='k' )
for x in range(0 , np.array(yy2).size):
msize = (17-12.0*(sep3d[yy2[x]].value/searchradpc.value))**2
mcolor = Gchi2[yy2[x]]
medge = 'black'
mzorder= 2
if (r['ruwe'][yy2[x]] < 1.2):
mshape='o'
if (r['ruwe'][yy2[x]] >= 1.2):
mshape='s'
ccc = ax1.scatter( (RV[yy2[x]]-Gvrpmllpmbb[yy2[x],0]) , \
(r['phot_g_mean_mag'][yy2[x]] - (5.0*np.log10(gaiacoord.distance[yy2[x]].value)-5.0)) , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
temp1 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='o' , s=12**2 , label = 'RUWE < 1.2')
temp2 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='s' , s=12**2 , label = 'RUWE >= 1.2')
temp3 = ax1.scatter([] , [] , c='white' , edgecolors='blue' , marker='o' , s=12**2 , label = 'RV Comoving')
if ( (Pgaia['phot_g_mean_mag'][minpos] - (5.0*np.log10(Pcoord.distance.value)-5.0)) < \
(max( np.append( np.array(r['phot_g_mean_mag'][zz3] - (5.0*np.log10(gaiacoord.distance[zz3].value)-5.0)) , 0.0 )) + 0.3) ):
ax1.plot( [0.0] , (Pgaia['phot_g_mean_mag'][minpos] - (5.0*np.log10(Pcoord.distance.value)-5.0)) , \
'rx' , markersize=18 , mew=3 , markeredgecolor='red' , zorder=3 , label=targname)
ax1.set_ylabel(r'$M_G$ (mag)' , fontsize=22 , labelpad=10)
ax1.set_xlabel(r'$v_{r,obs}-v_{r,pred}$ (km/s)' , fontsize=22 , labelpad=10)
ax1.legend(fontsize=12)
cb = plt.colorbar(ccc , ax=ax1)
cb.set_label(label='Tangential Velocity Difference (km/s)',fontsize=18 , labelpad=10)
figname=outdir + targname.replace(" ", "") + "drv.png"
plt.savefig(figname , bbox_inches='tight', pad_inches=0.2 , dpi=200)
if showplots == True: plt.show()
plt.close('all')
# Create XYZ plot
Pxyz = bc.lbd_to_XYZ( Pllbb[0] , Pllbb[1] , Pcoord.distance.value/1000.0 , degree=True)
fig,axs = plt.subplots(2,2)
fig.set_figheight(16)
fig.set_figwidth(16)
fig.subplots_adjust(hspace=0.03,wspace=0.03)
zz2= np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) )
yy2= zz2[0][np.argsort((-Gchi2)[zz2])]
for x in range(0 , np.array(yy2).size):
msize = (17-12.0*(sep3d[yy2[x]].value/searchradpc.value))**2
mcolor = Gchi2[yy2[x]]
medge = 'black'
mzorder= 3
if (r['ruwe'][yy2[x]] < 1.2):
mshape='o'
if (r['ruwe'][yy2[x]] >= 1.2):
mshape='s'
if (np.isnan(rvcut) == False):
if (np.isnan(RV[yy2[x]])==False) & (np.abs(RV[yy2[x]]-Gvrpmllpmbb[yy2[x],0]) > rvcut):
mshape='+'
mcolor='black'
mzorder=2
if (np.isnan(RV[yy2[x]])==False) & (np.abs(RV[yy2[x]]-Gvrpmllpmbb[yy2[x],0]) <= rvcut):
medge='blue'
ccc = axs[0,0].scatter( 1000.0*Gxyz[yy2[x],0] , 1000.0*Gxyz[yy2[x],1] , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
ccc = axs[0,1].scatter( 1000.0*Gxyz[yy2[x],2] , 1000.0*Gxyz[yy2[x],1] , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
ccc = axs[1,0].scatter( 1000.0*Gxyz[yy2[x],0] , 1000.0*Gxyz[yy2[x],2] , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
temp1 = axs[0,0].scatter([] , [] , c='white' , edgecolors='black', marker='o' , s=12**2 , label = 'RUWE < 1.2')
temp2 = axs[0,0].scatter([] , [] , c='white' , edgecolors='black', marker='s' , s=12**2 , label = 'RUWE >= 1.2')
temp3 = axs[0,0].scatter([] , [] , c='white' , edgecolors='blue' , marker='o' , s=12**2 , label = 'RV Comoving')
temp4 = axs[0,0].scatter([] , [] , c='black' , marker='+' , s=12**2 , label = 'RV Outlier')
axs[0,0].plot( 1000.0*Pxyz[0] , 1000.0*Pxyz[1] , 'rx' , markersize=18 , mew=3 , markeredgecolor='red')
axs[0,1].plot( 1000.0*Pxyz[2] , 1000.0*Pxyz[1] , 'rx' , markersize=18 , mew=3 , markeredgecolor='red')
axs[1,0].plot( 1000.0*Pxyz[0] , 1000.0*Pxyz[2] , 'rx' , markersize=18 , mew=3 , markeredgecolor='red' , zorder=1 , label = targname)
axs[0,0].set_xlim( [1000.0*Pxyz[0]-(search_radius+1.0) , 1000.0*Pxyz[0]+(search_radius+1.0)] )
axs[0,0].set_ylim( [1000.0*Pxyz[1]-(search_radius+1.0) , 1000.0*Pxyz[1]+(search_radius+1.0)] )
axs[0,1].set_xlim( [1000.0*Pxyz[2]-(search_radius+1.0) , 1000.0*Pxyz[2]+(search_radius+1.0)] )
axs[0,1].set_ylim( [1000.0*Pxyz[1]-(search_radius+1.0) , 1000.0*Pxyz[1]+(search_radius+1.0)] )
axs[1,0].set_xlim( [1000.0*Pxyz[0]-(search_radius+1.0) , 1000.0*Pxyz[0]+(search_radius+1.0)] )
axs[1,0].set_ylim( [1000.0*Pxyz[2]-(search_radius+1.0) , 1000.0*Pxyz[2]+(search_radius+1.0)] )
axs[0,0].set_xlabel(r'$X$ (pc)',fontsize=20,labelpad=10)
axs[0,0].set_ylabel(r'$Y$ (pc)',fontsize=20,labelpad=10)
axs[1,0].set_xlabel(r'$X$ (pc)',fontsize=20,labelpad=10)
axs[1,0].set_ylabel(r'$Z$ (pc)',fontsize=20,labelpad=10)
axs[0,1].set_xlabel(r'$Z$ (pc)',fontsize=20,labelpad=10)
axs[0,1].set_ylabel(r'$Y$ (pc)',fontsize=20,labelpad=10)
axs[0,0].xaxis.set_ticks_position('top')
axs[0,1].xaxis.set_ticks_position('top')
axs[0,1].yaxis.set_ticks_position('right')
axs[0,0].xaxis.set_label_position('top')
axs[0,1].xaxis.set_label_position('top')
axs[0,1].yaxis.set_label_position('right')
for aa in [0,1]:
for bb in [0,1]:
axs[aa,bb].tick_params(top=True,bottom=True,left=True,right=True,direction='in',labelsize=18)
fig.delaxes(axs[1][1])
strsize = 26
if (len(targname) > 12.0): strsize = np.floor(24 / (len(targname)/14.5))
fig.legend( bbox_to_anchor=(0.92,0.37) , prop={'size':strsize})
cbaxes = fig.add_axes([0.55,0.14,0.02,0.34])
cb = plt.colorbar( ccc , cax=cbaxes )
cb.set_label( label='Velocity Difference (km/s)' , fontsize=24 , labelpad=20 )
cb.ax.tick_params(labelsize=18)
figname=outdir + targname.replace(" ", "") + "xyz.png"
plt.savefig(figname , bbox_inches='tight', pad_inches=0.2 , dpi=200)
if showplots == True: plt.show()
plt.close('all')
# Create sky map
# Hacked from cartopy.mpl.gridliner
_DEGREE_SYMBOL = u'\u00B0'
def _east_west_formatted(longitude, num_format='g'):
fmt_string = u'{longitude:{num_format}}{degree}'
return fmt_string.format(longitude=(longitude if (longitude >= 0) else (longitude + 360)) , \
num_format=num_format,degree=_DEGREE_SYMBOL)
def _north_south_formatted(latitude, num_format='g'):
fmt_string = u'{latitude:{num_format}}{degree}'
return fmt_string.format(latitude=latitude, num_format=num_format,degree=_DEGREE_SYMBOL)
LONGITUDE_FORMATTER = mticker.FuncFormatter(lambda v, pos:
_east_west_formatted(v))
LATITUDE_FORMATTER = mticker.FuncFormatter(lambda v, pos:
_north_south_formatted(v))
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) )
yy = zz[0][np.argsort((-Gchi2)[zz])]
searchcircle = Pcoord.directional_offset_by( (np.arange(0,360)*u.degree) , searchraddeg*np.ones(360))
circleRA = searchcircle.ra.value
circleDE = searchcircle.dec.value
ww = np.where(circleRA > 180.0)
circleRA[ww] = circleRA[ww] - 360.0
RAlist = gaiacoord.ra[yy].value
DElist = gaiacoord.dec[yy].value
ww = np.where( RAlist > 180.0 )
RAlist[ww] = RAlist[ww] - 360.0
polelat = ((Pcoord.dec.value+90) if (Pcoord.dec.value<0) else (90-Pcoord.dec.value))
polelong= (Pcoord.ra.value if (Pcoord.dec.value<0.0) else (Pcoord.ra.value+180.0))
polelong= (polelong if polelong < 180 else polelong - 360.0)
if verbose == True:
print('Alignment variables: ',polelat,polelong,Pcoord.ra.value)
print(Pcoord.dec.value+searchraddeg.value)
rotated_pole = ccrs.RotatedPole( \
pole_latitude=polelat , \
pole_longitude=polelong , \
central_rotated_longitude=90.0 )#\
# (Pcoord.ra.value if (Pcoord.dec.value > 0.0) else (Pcoord.ra.value+180.0)) )
fig = plt.figure(figsize=(8,8))
ax = fig.add_subplot(1, 1, 1, projection=rotated_pole)
ax.gridlines(draw_labels=True,x_inline=True,y_inline=True, \
xformatter=LONGITUDE_FORMATTER,yformatter=LATITUDE_FORMATTER)
ax.plot( circleRA , circleDE , c="gray" , ls="--" , transform=ccrs.Geodetic())
figname=outdir + targname.replace(" ", "") + "sky.png"
base=plt.cm.get_cmap('cubehelix')
for x in range(0 , np.array(yy).size):
msize = (17-12.0*(sep3d[yy[x]].value/searchradpc.value))
mcolor = base(Gchi2[yy[x]]/vlim.value)
medge = 'black'
mzorder= 3
if (r['ruwe'][yy[x]] < 1.2):
mshape='o'
if (r['ruwe'][yy[x]] >= 1.2):
mshape='s'
if (np.isnan(rvcut) == False):
if (np.isnan(RV[yy[x]])==False) & (np.abs(RV[yy[x]]-Gvrpmllpmbb[yy[x],0]) > rvcut):
mshape='+'
mcolor='black'
mzorder=2
if (np.isnan(RV[yy[x]])==False) & (np.abs(RV[yy[x]]-Gvrpmllpmbb[yy[x],0]) <= rvcut):
medge='blue'
ccc = ax.plot( RAlist[x] , DElist[x] , marker=mshape , \
markeredgecolor=medge , ms = msize , mfc = mcolor , transform=ccrs.Geodetic() )
ax.plot( (Pcoord.ra.value-360.0) , Pcoord.dec.value , \
'rx' , markersize=18 , mew=3 , transform=ccrs.Geodetic())
plt.savefig(figname , bbox_inches='tight', pad_inches=0.2 , dpi=200)
if showplots == True: plt.show()
plt.close('all')
## Query GALEX and 2MASS data
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) )
yy = zz[0][np.argsort((-Gchi2)[zz])]
NUVmag = np.empty(np.array(r['ra']).size)
NUVerr = np.empty(np.array(r['ra']).size)
NUVmag[:] = np.nan
NUVerr[:] = np.nan
print('Searching on neighbors in GALEX')
##suppress the stupid noresultswarning from the catalogs package
warnings.filterwarnings("ignore",category=NoResultsWarning)
for x in range(0 , np.array(yy).size):
querystring=((str(gaiacoord.ra[yy[x]].value) if (gaiacoord.ra[yy[x]].value > 0) \
else str(gaiacoord.ra[yy[x]].value+360.0)) + " " + str(gaiacoord.dec[yy[x]].value))
print('GALEX query ',x,' of ',np.array(yy).size, end='\r')
if verbose == True: print('GALEX query ',x,' of ',np.array(yy).size)
if verbose == True: print(querystring)
if (DoGALEX == True):
galex = Catalogs.query_object(querystring , catalog="Galex" , radius=0.0028 , TIMEOUT=600)
if ((np.where(galex['nuv_magerr'] > 0.0)[0]).size > 0):
ww = np.where( (galex['nuv_magerr'] == min(galex['nuv_magerr'][np.where(galex['nuv_magerr'] > 0.0)])))
NUVmag[yy[x]] = galex['nuv_mag'][ww][0]
NUVerr[yy[x]] = galex['nuv_magerr'][ww][0]
if verbose == True: print(galex['distance_arcmin','ra','nuv_mag','nuv_magerr'][ww])
Jmag = np.empty(np.array(r['ra']).size)
Jerr = np.empty(np.array(r['ra']).size)
Jmag[:] = np.nan
Jerr[:] = np.nan
print('Searching on neighbors in 2MASS')
for x in range(0 , np.array(yy).size):
if ( np.isnan(NUVmag[yy[x]]) == False ):
querycoord = SkyCoord((str(gaiacoord.ra[yy[x]].value) if (gaiacoord.ra[yy[x]].value > 0) else \
str(gaiacoord.ra[yy[x]].value+360.0)) , str(gaiacoord.dec[yy[x]].value) , \
unit=(u.deg,u.deg) , frame='icrs')
print('2MASS query ',x,' of ',np.array(yy).size, end='\r')
if verbose == True: print('2MASS query ',x,' of ',np.array(yy).size)
if verbose == True: print(querycoord)
tmass = []
if (DoGALEX == True):
tmass = Irsa.query_region(querycoord , catalog='fp_psc' , radius='0d0m10s' )
if ((np.where(tmass['j_m'] > -10.0)[0]).size > 0):
ww = np.where( (tmass['j_m'] == min(tmass['j_m'][np.where(tmass['j_m'] > 0.0)])))
Jmag[yy[x]] = tmass['j_m'][ww][0]
Jerr[yy[x]] = tmass['j_cmsig'][ww][0]
if verbose == True: print(tmass['j_m','j_cmsig'][ww])
# Create GALEX plots
mamajek = np.loadtxt(datapath+'/sptGBpRp.txt')
f = interp1d( mamajek[:,2] , mamajek[:,0] , kind='cubic')
zz2 = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) )
yy2 = zz[0][np.argsort(sep3d[zz])]
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) )
yy = zz[0][np.argsort((-Gchi2)[zz])]
fnuvj = (3631.0 * 10**6 * 10**(-0.4 * NUVmag)) / (1594.0 * 10**6 * 10**(-0.4 * Jmag))
spt = f(r['bp_rp'].filled(np.nan))
sptstring = ["nan" for x in range(np.array(r['bp_rp']).size)]
for x in range(0 , np.array(zz2).size):
if (round(spt[yy2[x]],1) >= 17.0) and (round(spt[yy2[x]],1) < 27.0):
sptstring[yy2[x]] = 'M' + ('% 3.1f' % (round(spt[yy2[x]],1)-17.0)).strip()
if (round(spt[yy2[x]],1) >= 16.0) and (round(spt[yy2[x]],1) < 17.0):
sptstring[yy2[x]] = 'K' + ('% 3.1f' % (round(spt[yy2[x]],1)-9.0)).strip()
if (round(spt[yy2[x]],1) >= 10.0) and (round(spt[yy2[x]],1) < 16.0):
sptstring[yy2[x]] = 'K' + ('% 3.1f' % (round(spt[yy2[x]],1)-10.0)).strip()
if (round(spt[yy2[x]],1) >= 0.0) and (round(spt[yy2[x]],1) < 10.0):
sptstring[yy2[x]] = 'G' + ('% 3.1f' % (round(spt[yy2[x]],1)-0.0)).strip()
if (round(spt[yy2[x]],1) >= -10.0) and (round(spt[yy2[x]],1) < 0.0):
sptstring[yy2[x]] = 'F' + ('% 3.1f' % (round(spt[yy2[x]],1)+10.0)).strip()
if (round(spt[yy2[x]],1) >= -20.0) and (round(spt[yy2[x]],1) < -10.0):
sptstring[yy2[x]] = 'A' + ('% 3.1f' % (round(spt[yy2[x]],1)+20.0)).strip()
if (round(spt[yy2[x]],1) >= -30.0) and (round(spt[yy2[x]],1) < -20.0):
sptstring[yy2[x]] = 'B' + ('% 3.1f' % (round(spt[yy2[x]],1)+30.0)).strip()
figname=outdir + targname.replace(" ", "") + "galex.png"
if verbose == True: print(figname)
##Muck with the axis to get two x axes
fig,ax1 = plt.subplots(figsize=(12,8))
ax1.set_yscale('log')
ax1.axis([5.0 , 24.0 , 0.000004 , 0.02])
ax2 = ax1.twiny()
ax2.set_xlim(ax1.get_xlim())
ax1.set_xticks(np.array([5.0 , 10.0 , 15.0 , 17.0 , 22.0 , 24.0]))
ax1.set_xticklabels(['G5','K0','K5','M0','M5','M7'])
ax1.set_xlabel('SpT' , fontsize=20, labelpad=15)
ax1.tick_params(axis='both',which='major',labelsize=16)
ax2.set_xticks(np.array([5.0 , 10.0 , 15.0 , 17.0 , 22.0 , 24.0]))
ax2.set_xticklabels(['0.85','0.98','1.45','1.84','3.36','4.75'])
ax2.set_xlabel(r'$B_p-R_p$ (mag)' , fontsize=20, labelpad=15)
ax2.tick_params(axis='both',which='major',labelsize=16)
ax1.set_ylabel(r'$F_{NUV}/F_{J}$' , fontsize=22, labelpad=0)
##Hyades
hyades = readsav(datapath +'/HYsaved.sav')
hyadesfnuvj = (3631.0 * 10**6 * 10**(-0.4 * hyades['clnuv'])) / (1594.0 * 10**6 * 10**(-0.4 * hyades['clJ']))
ax1.plot(hyades['clspt'] , hyadesfnuvj , 'x' , markersize=4 , mew=1 , markeredgecolor='black' , zorder=1 , label='Hyades' )
for x in range(0 , np.array(yy).size):
msize = (17-12.0*(sep3d[yy[x]].value/searchradpc.value))**2
mcolor = Gchi2[yy[x]]
medge = 'black'
mzorder= 3
if (r['ruwe'][yy[x]] < 1.2):
mshape='o'
if (r['ruwe'][yy[x]] >= 1.2):
mshape='s'
if (np.isnan(rvcut) == False):
if (np.isnan(RV[yy[x]])==False) & (np.abs(RV[yy[x]]-Gvrpmllpmbb[yy[x],0]) > rvcut):
mshape='+'
mcolor='black'
mzorder=2
if (np.isnan(RV[yy[x]])==False) & (np.abs(RV[yy[x]]-Gvrpmllpmbb[yy[x],0]) <= rvcut):
medge='blue'
ccc = ax1.scatter( spt[yy[x]] , fnuvj[yy[x]] , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
temp1 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='o' , s=12**2 , label = 'RUWE < 1.2')
temp2 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='s' , s=12**2 , label = 'RUWE >= 1.2')
temp3 = ax1.scatter([] , [] , c='white' , edgecolors='blue' , marker='o' , s=12**2 , label = 'RV Comoving')
temp4 = ax1.scatter([] , [] , c='black' , marker='+' , s=12**2 , label = 'RV Outlier')
# Plot science target
if (spt[yy[0]] > 5): ax1.plot(spt[yy[0]] , fnuvj[yy[0]] , 'rx' , markersize=18 , mew=3 , markeredgecolor='red' , zorder=3 , label=targname )
ax1.legend(fontsize=16 , loc='lower left')
cb = fig.colorbar(ccc , ax=ax1)
cb.set_label(label='Velocity Offset (km/s)',fontsize=13)
if (DoGALEX == True): plt.savefig(figname , bbox_inches='tight', pad_inches=0.2 , dpi=200)
if showplots == True: plt.show()
plt.close('all')
# Query CatWISE for W1+W2 and AllWISE for W3+W4
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) )
yy = zz[0][np.argsort((-Gchi2)[zz])]
WISEmag = np.empty([np.array(r['ra']).size,4])
WISEerr = np.empty([np.array(r['ra']).size,4])
WISEmag[:] = np.nan
WISEerr[:] = np.nan
print('Searching on neighbors in WISE')
##there's an annoying nan warning here, hide it for now as it's not a problem
warnings.filterwarnings("ignore",category=UserWarning)
for x in range(0 , np.array(yy).size):
querycoord = SkyCoord((str(gaiacoord.ra[yy[x]].value) if (gaiacoord.ra[yy[x]].value > 0) else \
str(gaiacoord.ra[yy[x]].value+360.0)) , str(gaiacoord.dec[yy[x]].value) , \
unit=(u.deg,u.deg) , frame='icrs')
print('WISE query ',x,' of ',np.array(yy).size, end='\r')
if verbose == True: print('WISE query ',x,' of ',np.array(yy).size)
if verbose == True: print(querycoord)
wisecat = []
if (DoWISE == True):
wisecat = Irsa.query_region(querycoord,catalog='catwise_2020' , radius='0d0m10s')
if ((np.where(wisecat['w1mpro'] > -10.0)[0]).size > 0):
ww = np.where( (wisecat['w1mpro'] == min( wisecat['w1mpro'][np.where(wisecat['w1mpro'] > -10.0)]) ))
WISEmag[yy[x],0] = wisecat['w1mpro'][ww][0]
WISEerr[yy[x],0] = wisecat['w1sigmpro'][ww][0]
if ((np.where(wisecat['w2mpro'] > -10.0)[0]).size > 0):
ww = np.where( (wisecat['w2mpro'] == min( wisecat['w2mpro'][np.where(wisecat['w2mpro'] > -10.0)]) ))
WISEmag[yy[x],1] = wisecat['w2mpro'][ww][0]
WISEerr[yy[x],1] = wisecat['w2sigmpro'][ww][0]
if (DoWISE == True):
wisecat = Irsa.query_region(querycoord,catalog='allwise_p3as_psd' , radius='0d0m10s')
if ((np.where(wisecat['w1mpro'] > -10.0)[0]).size > 0):
ww = np.where( (wisecat['w1mpro'] == min( wisecat['w1mpro'][np.where(wisecat['w1mpro'] > -10.0)]) ))
if (np.isnan(WISEmag[yy[x],0]) == True) | (wisecat['w1mpro'][ww][0] < 11.0): # Note, only if CatWISE absent/saturated
WISEmag[yy[x],0] = wisecat['w1mpro'][ww][0]
WISEerr[yy[x],0] = wisecat['w1sigmpro'][ww][0]
if ((np.where(wisecat['w2mpro'] > -10.0)[0]).size > 0):
ww = np.where( (wisecat['w2mpro'] == min( wisecat['w2mpro'][np.where(wisecat['w2mpro'] > -10.0)]) ))
if (np.isnan(WISEmag[yy[x],1]) == True) | (wisecat['w2mpro'][ww][0] < 11.0): # Note, only if CatWISE absent/saturated
WISEmag[yy[x],1] = wisecat['w2mpro'][ww][0]
WISEerr[yy[x],1] = wisecat['w2sigmpro'][ww][0]
if ((np.where(wisecat['w3mpro'] > -10.0)[0]).size > 0):
ww = np.where( (wisecat['w3mpro'] == min( wisecat['w3mpro'][np.where(wisecat['w3mpro'] > -10.0)]) ))
WISEmag[yy[x],2] = wisecat['w3mpro'][ww][0]
WISEerr[yy[x],2] = wisecat['w3sigmpro'][ww][0]
if ((np.where(wisecat['w4mpro'] > -10.0)[0]).size > 0):
ww = np.where( (wisecat['w4mpro'] == min( wisecat['w4mpro'][np.where(wisecat['w4mpro'] > -10.0)]) ))
WISEmag[yy[x],3] = wisecat['w4mpro'][ww][0]
WISEerr[yy[x],3] = wisecat['w4sigmpro'][ww][0]
if verbose == True: print(yy[x],WISEmag[yy[x],:],WISEerr[yy[x],:])
# Create WISE plots
W13 = WISEmag[:,0]-WISEmag[:,2]
W13err = ( WISEerr[:,0]**2 + WISEerr[:,2]**2 )**0.5
zz = np.argwhere( np.isnan(W13err) )
W13[zz] = np.nan
W13err[zz] = np.nan
zz = np.where( (W13err > 0.15) )
W13[zz] = np.nan
W13err[zz] = np.nan
warnings.filterwarnings("default",category=UserWarning)
zz2 = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value))
yy2 = zz[0][np.argsort(sep3d[zz])]
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) & (sep.degree > 0.00001) )
yy = zz[0][np.argsort((-Gchi2)[zz])]
figname=outdir + targname.replace(" ", "") + "wise.png"
if verbose == True: print(figname)
plt.figure(figsize=(12,8))
if (verbose == True) & ((np.where(np.isfinite(W13+W13err))[0]).size > 0): print('Max y value: ' , (max((W13+W13err)[np.isfinite(W13+W13err)])+0.1) )
plt.axis([ 5.0 , 24.0 , \
max( [(min(np.append((W13-W13err)[ np.isfinite(W13-W13err) ],-0.1))-0.1) , -0.3]) , \
max( [(max(np.append((W13+W13err)[ np.isfinite(W13+W13err) ],+0.0))+0.2) , +0.6]) ])
ax1 = plt.gca()
ax2 = ax1.twiny()
ax2.set_xlim(5.0,24.0)
ax1.set_xticks(np.array([5.0 , 10.0 , 15.0 , 17.0 , 22.0 , 24.0]))
ax1.set_xticklabels(['G5','K0','K5','M0','M5','M7'])
ax1.set_xlabel('SpT' , fontsize=20, labelpad=15)
ax1.tick_params(axis='both',which='major',labelsize=16)
ax2.set_xticks(np.array([5.0 , 10.0 , 15.0 , 17.0 , 22.0 , 24.0]))
ax2.set_xticklabels(['0.85','0.98','1.45','1.84','3.36','4.75'])
ax2.set_xlabel(r'$B_p-R_p$ (mag)' , fontsize=20, labelpad=15)
ax2.tick_params(axis='both',which='major',labelsize=16)
ax1.set_ylabel(r'$W1-W3$ (mag)' , fontsize=22, labelpad=0)
# Plot field sequence from Tuc-Hor (Kraus et al. 2014)
fldspt = [ 5 , 7 , 10 , 12 , 15 , 17 , 20 , 22 , 24 ]
fldW13 = [ 0 , 0 , 0 , .02, .06, .12, .27, .40, .60]
plt.plot(fldspt , fldW13 , zorder=0 , label='Photosphere')
# Plot neighbors
ax1.errorbar( spt[yy] , W13[yy] , yerr=W13err[yy] , fmt='none' , ecolor='k')
for x in range(0 , np.array(yy).size):
msize = (17-12.0*(sep3d[yy[x]].value/searchradpc.value))**2
mcolor = Gchi2[yy[x]]
medge = 'black'
mzorder= 3
if (r['ruwe'][yy[x]] < 1.2):
mshape='o'
if (r['ruwe'][yy[x]] >= 1.2):
mshape='s'
if (np.isnan(rvcut) == False):
if (np.isnan(RV[yy[x]])==False) & (np.abs(RV[yy[x]]-Gvrpmllpmbb[yy[x],0]) > rvcut):
mshape='+'
mcolor='black'
mzorder=2
if (np.isnan(RV[yy[x]])==False) & (np.abs(RV[yy[x]]-Gvrpmllpmbb[yy[x],0]) <= rvcut):
medge='blue'
ccc = ax1.scatter( spt[yy[x]] , W13[yy[x]] , \
s=msize , c=mcolor , marker=mshape , edgecolors=medge , zorder=mzorder , \
vmin=0.0 , vmax=vlim.value , cmap='cubehelix' , label='_nolabel' )
temp1 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='o' , s=12**2 , label = 'RUWE < 1.2')
temp2 = ax1.scatter([] , [] , c='white' , edgecolors='black', marker='s' , s=12**2 , label = 'RUWE >= 1.2')
temp3 = ax1.scatter([] , [] , c='white' , edgecolors='blue' , marker='o' , s=12**2 , label = 'RV Comoving')
temp4 = ax1.scatter([] , [] , c='black' , marker='+' , s=12**2 , label = 'RV Outlier')
# Plot science target
if (spt[yy2[0]] > 5):
plt.plot(spt[yy2[0]] , W13[yy2[0]] , 'rx' , markersize=18 , mew=3 , markeredgecolor='red' , zorder=3 , label=targname )
plt.legend(fontsize=16 , loc='upper left')
cb = plt.colorbar(ccc , ax=ax1)
cb.set_label(label='Velocity Offset (km/s)',fontsize=14)
if (DoWISE == True): plt.savefig(figname , bbox_inches='tight', pad_inches=0.2 , dpi=200)
if showplots == True: plt.show()
plt.close('all')
# Cross-reference with ROSAT
v = Vizier(columns=["**", "+_R"] , catalog='J/A+A/588/A103/cat2rxs' )
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) )
yy = zz[0][np.argsort(sep3d[zz])]
ROSATflux = np.empty([np.array(r['ra']).size])
ROSATflux[:] = np.nan
print('Searching on neighbors in ROSAT')
for x in range(0 , np.array(yy).size):
querycoord = SkyCoord((str(gaiacoord.ra[yy[x]].value) if (gaiacoord.ra[yy[x]].value > 0) else \
str(gaiacoord.ra[yy[x]].value+360.0)) , str(gaiacoord.dec[yy[x]].value) , \
unit=(u.deg,u.deg) , frame='icrs')
print('ROSAT query ',x,' of ',np.array(yy).size, end='\r')
if verbose == True: print('ROSAT query ',x,' of ',np.array(yy).size)
if verbose == True: print(querycoord)
if (DoROSAT == True):
rosatcat = v.query_region(querycoord , radius='0d1m0s' )
if (len(rosatcat) > 0):
rosatcat = rosatcat['J/A+A/588/A103/cat2rxs']
if verbose == True: print(rosatcat)
if ((np.where(rosatcat['CRate'] > -999)[0]).size > 0):
ww = np.where( (rosatcat['CRate'] == max(rosatcat['CRate'][np.where(rosatcat['CRate'] > -999)])))
ROSATflux[yy[x]] = rosatcat['CRate'][ww][0]
if verbose == True: print(x,yy[x],ROSATflux[yy[x]])
# Create output table with results
print('Creating Output Tables with Results')
if verbose == True:
print('Reminder, there were this many input entries: ',len(Gxyz[:,0]))
print('The search radius in velocity space is: ',vlim)
print()
zz = np.where( (sep3d.value < searchradpc.value) & (Gchi2 < vlim.value) )
sortlist = np.argsort(sep3d[zz])
yy = zz[0][sortlist]
fmt1 = "%11.7f %11.7f %6.3f %6.3f %11.3f %8.4f %8.4f %8.2f %8.2f %8.2f %8.3f %4s %8.6f %6.2f %7.3f %7.3f %35s"
fmt2 = "%11.7f %11.7f %6.3f %6.3f %11.3f %8.4f %8.4f %8.2f %8.2f %8.2f %8.3f %4s %8.6f %6.2f %7.3f %7.3f %35s"
filename=outdir + targname.replace(" ", "") + ".txt"
warnings.filterwarnings("ignore",category=UserWarning)
if verbose == True:
print('Also creating SIMBAD query table')
print(filename)
print('RA DEC Gmag Bp-Rp Voff(km/s) Sep(deg) 3D(pc) Vr(pred) Vr(obs) Vrerr Plx(mas) SpT FnuvJ W1-W3 RUWE XCrate RVsrc')
with open(filename,'w') as file1:
file1.write('RA DEC Gmag Bp-Rp Voff(km/s) Sep(deg) 3D(pc) Vr(pred) Vr(obs) Vrerr Plx(mas) SpT FnuvJ W1-W3 RUWE XCrate RVsrc \n')
for x in range(0 , np.array(zz).size):
if verbose == True:
print(fmt1 % (gaiacoord.ra[yy[x]].value,gaiacoord.dec[yy[x]].value, \
r['phot_g_mean_mag'][yy[x]], r['bp_rp'][yy[x]] , \
Gchi2[yy[x]] , sep[yy[x]].value , sep3d[yy[x]].value , \
Gvrpmllpmbb[yy[x],0] , RV[yy[x]] , RVerr[yy[x]] , \
r['parallax'][yy[x]], \
sptstring[yy[x]] , fnuvj[yy[x]] , W13[yy[x]] , r['ruwe'][yy[x]] , ROSATflux[yy[x]] , RVsrc[yy[x]]) )
with open(filename,'a') as file1:
file1.write(fmt2 % (gaiacoord.ra[yy[x]].value,gaiacoord.dec[yy[x]].value, \
r['phot_g_mean_mag'][yy[x]], r['bp_rp'][yy[x]] , \
Gchi2[yy[x]],sep[yy[x]].value,sep3d[yy[x]].value , \
Gvrpmllpmbb[yy[x],0] , RV[yy[x]] , RVerr[yy[x]] , \
r['parallax'][yy[x]], \
sptstring[yy[x]] , fnuvj[yy[x]] , W13[yy[x]] , r['ruwe'][yy[x]] , ROSATflux[yy[x]] , RVsrc[yy[x]]) )
file1.write("\n")
filename=outdir + targname.replace(" ", "") + ".csv"
with open(filename,mode='w') as result_file:
wr = csv.writer(result_file)
wr.writerow(['RA','DEC','Gmag','Bp-Rp','Voff(km/s)','Sep(deg)','3D(pc)','Vr(pred)','Vr(obs)','Vrerr','Plx(mas)','SpT','FnuvJ','W1-W3','RUWE','XCrate','RVsrc'])
for x in range(0 , np.array(zz).size):
wr.writerow(( "{0:.7f}".format(gaiacoord.ra[yy[x]].value) , "{0:.7f}".format(gaiacoord.dec[yy[x]].value) , \
"{0:.3f}".format(r['phot_g_mean_mag'][yy[x]]), "{0:.3f}".format(r['bp_rp'][yy[x]]) , \
"{0:.3f}".format(Gchi2[yy[x]]) , "{0:.4f}".format(sep[yy[x]].value) , "{0:.4f}".format(sep3d[yy[x]].value) , \
"{0:.2f}".format(Gvrpmllpmbb[yy[x],0]) , "{0:.2f}".format(RV[yy[x]]) , "{0:.2f}".format(RVerr[yy[x]]) , \
"{0:.3f}".format(r['parallax'][yy[x]]), \
sptstring[yy[x]] , "{0:.6f}".format(fnuvj[yy[x]]) , "{0:.2f}".format(W13[yy[x]]) , \
"{0:.3f}".format(r['ruwe'][yy[x]]) , "{0:.3f}".format(ROSATflux[yy[x]]) , RVsrc[yy[x]].strip()) )
if verbose == True: print('All output can be found in ' + outdir)
return outdir
def make_rcsample(parser):
options, args = parser.parse_args()
savefilename = options.savefilename
if savefilename is None:
#Create savefilename if not given
savefilename = os.path.join(
appath._APOGEE_DATA, 'rcsample_' + appath._APOGEE_REDUX + '.fits')
print("Saving to %s ..." % savefilename)
#Read the base-sample
data = apread.allStar(adddist=_ADDHAYDENDIST, rmdups=options.rmdups)
#Remove a bunch of fields that we do not want to keep
data = esutil.numpy_util.remove_fields(data, [
'TARGET_ID', 'FILE', 'AK_WISE', 'SFD_EBV', 'SYNTHVHELIO_AVG',
'SYNTHVSCATTER', 'SYNTHVERR', 'SYNTHVERR_MED', 'RV_TEFF', 'RV_LOGG',
'RV_FEH', 'RV_ALPHA', 'RV_CARB', 'RV_CCFWHM', 'RV_AUTOFWHM',
'SYNTHSCATTER', 'STABLERV_CHI2', 'STABLERV_RCHI2',
'STABLERV_CHI2_PROB', 'CHI2_THRESHOLD', 'APSTAR_VERSION',
'ASPCAP_VERSION', 'RESULTS_VERSION', 'WASH_M', 'WASH_M_ERR', 'WASH_T2',
'WASH_T2_ERR', 'DDO51', 'DDO51_ERR', 'IRAC_3_6', 'IRAC_3_6_ERR',
'IRAC_4_5', 'IRAC_4_5_ERR', 'IRAC_5_8', 'IRAC_5_8_ERR', 'IRAC_8_0',
'IRAC_8_0_ERR', 'WISE_4_5', 'WISE_4_5_ERR', 'TARG_4_5', 'TARG_4_5_ERR',
'WASH_DDO51_GIANT_FLAG', 'WASH_DDO51_STAR_FLAG', 'REDUCTION_ID',
'SRC_H', 'PM_SRC'
])
if not appath._APOGEE_REDUX.lower() == 'current' \
and not 'l30' in appath._APOGEE_REDUX \
and int(appath._APOGEE_REDUX[1:]) < 500:
data = esutil.numpy_util.remove_fields(data, ['ELEM'])
#Select red-clump stars
jk = data['J0'] - data['K0']
z = isodist.FEH2Z(data['METALS'], zsolar=0.017)
if 'l30' in appath._APOGEE_REDUX:
logg = data['LOGG']
elif appath._APOGEE_REDUX.lower() == 'current' \
or int(appath._APOGEE_REDUX[1:]) > 600:
from apogee.tools import paramIndx
if False:
#Use my custom logg calibration that's correct for the RC
logg = (1. - 0.042) * data['FPARAM'][:, paramIndx('logg')] - 0.213
lowloggindx = data['FPARAM'][:, paramIndx('logg')] < 1.
logg[lowloggindx] = data['FPARAM'][lowloggindx,
paramIndx('logg')] - 0.255
hiloggindx = data['FPARAM'][:, paramIndx('logg')] > 3.8
logg[hiloggindx] = data['FPARAM'][hiloggindx,
paramIndx('logg')] - 0.3726
else:
#Use my custom logg calibration that's correct on average
logg = (1. + 0.03) * data['FPARAM'][:, paramIndx('logg')] - 0.37
lowloggindx = data['FPARAM'][:, paramIndx('logg')] < 1.
logg[lowloggindx] = data['FPARAM'][lowloggindx,
paramIndx('logg')] - 0.34
hiloggindx = data['FPARAM'][:, paramIndx('logg')] > 3.8
logg[hiloggindx] = data['FPARAM'][hiloggindx,
paramIndx('logg')] - 0.256
else:
logg = data['LOGG']
indx= (jk < 0.8)*(jk >= 0.5)\
*(z <= 0.06)\
*(z <= rcmodel.jkzcut(jk,upper=True))\
*(z >= rcmodel.jkzcut(jk))\
*(logg >= rcmodel.loggteffcut(data['TEFF'],z,upper=False))\
*(logg <= rcmodel.loggteffcut(data['TEFF'],z,upper=True))
data = data[indx]
#Add more aggressive flag cut
data = esutil.numpy_util.add_fields(data, [('ADDL_LOGG_CUT', numpy.int32)])
data['ADDL_LOGG_CUT'] = (
(data['TEFF'] - 4800.) / 1000. + 2.75) > data['LOGG']
if options.loggcut:
data = data[data['ADDL_LOGG_CUT'] == 1]
print("Making catalog of %i objects ..." % len(data))
#Add distances
data = esutil.numpy_util.add_fields(data, [('RC_DIST', float),
('RC_DM', float),
('RC_GALR', float),
('RC_GALPHI', float),
('RC_GALZ', float)])
rcd = rcmodel.rcdist()
jk = data['J0'] - data['K0']
z = isodist.FEH2Z(data['METALS'], zsolar=0.017)
data['RC_DIST'] = rcd(jk, z, appmag=data['K0']) * options.distfac
data['RC_DM'] = 5. * numpy.log10(data['RC_DIST']) + 10.
XYZ = bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['RC_DIST'],
degree=True)
R, phi, Z = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2],
Xsun=8.,
Zsun=0.025)
data['RC_GALR'] = R
data['RC_GALPHI'] = phi
data['RC_GALZ'] = Z
#Save
fitsio.write(savefilename, data, clobber=True)
# Add Tycho-2 matches
if options.tyc2:
data = esutil.numpy_util.add_fields(data, [('TYC2MATCH', numpy.int32),
('TYC1', numpy.int32),
('TYC2', numpy.int32),
('TYC3', numpy.int32)])
data['TYC2MATCH'] = 0
data['TYC1'] = -1
data['TYC2'] = -1
data['TYC3'] = -1
# Write positions
posfilename = tempfile.mktemp('.csv', dir=os.getcwd())
resultfilename = tempfile.mktemp('.csv', dir=os.getcwd())
with open(posfilename, 'w') as csvfile:
wr = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA', 'DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'], data[ii]['DEC']])
# Send to CDS for matching
result = open(resultfilename, 'w')
try:
subprocess.check_call([
'curl', '-X', 'POST', '-F', 'request=xmatch', '-F',
'distMaxArcsec=2', '-F', 'RESPONSEFORMAT=csv', '-F',
'cat1=@%s' % os.path.basename(posfilename), '-F', 'colRA1=RA',
'-F', 'colDec1=DEC', '-F', 'cat2=vizier:Tycho2',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'
],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Directly match on input RA
ma = numpy.loadtxt(resultfilename,
delimiter=',',
skiprows=1,
usecols=(1, 2, 7, 8, 9))
iis = numpy.arange(len(data))
mai = [iis[data['RA'] == ma[ii, 0]][0] for ii in range(len(ma))]
data['TYC2MATCH'][mai] = 1
data['TYC1'][mai] = ma[:, 2]
data['TYC2'][mai] = ma[:, 3]
data['TYC3'][mai] = ma[:, 4]
os.remove(posfilename)
os.remove(resultfilename)
if not options.nostat:
#Determine statistical sample and add flag
apo = apogee.select.apogeeSelect()
statIndx = apo.determine_statistical(data)
mainIndx = apread.mainIndx(data)
data = esutil.numpy_util.add_fields(data, [('STAT', numpy.int32),
('INVSF', float)])
data['STAT'] = 0
data['STAT'][statIndx * mainIndx] = 1
for ii in range(len(data)):
if (statIndx * mainIndx)[ii]:
data['INVSF'][ii] = 1. / apo(data['LOCATION_ID'][ii],
data['H'][ii])
else:
data['INVSF'][ii] = -1.
if options.nopm:
fitsio.write(savefilename, data, clobber=True)
return None
#Get proper motions, in a somewhat roundabout way
pmfile = savefilename.split('.')[0] + '_pms.fits'
if os.path.exists(pmfile):
pmdata = fitsio.read(pmfile, 1)
else:
pmdata = numpy.recarray(
len(data),
formats=['f8', 'f8', 'f8', 'f8', 'f8', 'f8', 'i4'],
names=[
'RA', 'DEC', 'PMRA', 'PMDEC', 'PMRA_ERR', 'PMDEC_ERR',
'PMMATCH'
])
# Write positions, again ...
posfilename = tempfile.mktemp('.csv', dir=os.getcwd())
resultfilename = tempfile.mktemp('.csv', dir=os.getcwd())
with open(posfilename, 'w') as csvfile:
wr = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA', 'DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'], data[ii]['DEC']])
# Send to CDS for matching
result = open(resultfilename, 'w')
try:
subprocess.check_call([
'curl', '-X', 'POST', '-F', 'request=xmatch', '-F',
'distMaxArcsec=4', '-F', 'RESPONSEFORMAT=csv', '-F',
'cat1=@%s' % os.path.basename(posfilename), '-F', 'colRA1=RA',
'-F', 'colDec1=DEC', '-F', 'cat2=vizier:UCAC4',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'
],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Match back and only keep the closest one
ma = numpy.loadtxt(resultfilename,
delimiter=',',
skiprows=1,
converters={
15: lambda s: float(s.strip() or -9999),
16: lambda s: float(s.strip() or -9999),
17: lambda s: float(s.strip() or -9999),
18: lambda s: float(s.strip() or -9999)
},
usecols=(4, 5, 15, 16, 17, 18))
h = esutil.htm.HTM()
m1, m2, d12 = h.match(data['RA'],
data['DEC'],
ma[:, 0],
ma[:, 1],
4. / 3600.,
maxmatch=1)
pmdata['PMMATCH'] = 0
pmdata['RA'] = data['RA']
pmdata['DEC'] = data['DEC']
pmdata['PMMATCH'][m1] = 1
pmdata['PMRA'][m1] = ma[m2, 2]
pmdata['PMDEC'][m1] = ma[m2, 3]
pmdata['PMRA_ERR'][m1] = ma[m2, 4]
pmdata['PMDEC_ERR'][m1] = ma[m2, 5]
pmdata['PMMATCH'][(pmdata['PMRA'] == -9999) \
+(pmdata['PMDEC'] == -9999) \
+(pmdata['PMRA_ERR'] == -9999) \
+(pmdata['PMDEC_ERR'] == -9999)]= 0
fitsio.write(pmfile, pmdata, clobber=True)
#To make sure we're using the same format below
pmdata = fitsio.read(pmfile, 1)
os.remove(posfilename)
os.remove(resultfilename)
#Match proper motions
try: #These already exist currently, but may not always exist
data = esutil.numpy_util.remove_fields(data, ['PMRA', 'PMDEC'])
except ValueError:
pass
data = esutil.numpy_util.add_fields(data, [('PMRA', numpy.float),
('PMDEC', numpy.float),
('PMRA_ERR', numpy.float),
('PMDEC_ERR', numpy.float),
('PMMATCH', numpy.int32)])
data['PMMATCH'] = 0
h = esutil.htm.HTM()
m1, m2, d12 = h.match(pmdata['RA'],
pmdata['DEC'],
data['RA'],
data['DEC'],
2. / 3600.,
maxmatch=1)
data['PMRA'][m2] = pmdata['PMRA'][m1]
data['PMDEC'][m2] = pmdata['PMDEC'][m1]
data['PMRA_ERR'][m2] = pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR'][m2] = pmdata['PMDEC_ERR'][m1]
data['PMMATCH'][m2] = pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx = data['PMMATCH'] == 1
data['PMRA'][True - pmindx] = -9999.99
data['PMDEC'][True - pmindx] = -9999.99
data['PMRA_ERR'][True - pmindx] = -9999.99
data['PMDEC_ERR'][True - pmindx] = -9999.99
#Calculate Galactocentric velocities
data = esutil.numpy_util.add_fields(data, [('GALVR', numpy.float),
('GALVT', numpy.float),
('GALVZ', numpy.float)])
lb = bovy_coords.radec_to_lb(data['RA'], data['DEC'], degree=True)
XYZ = bovy_coords.lbd_to_XYZ(lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
pmllpmbb = bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA'],
data['PMDEC'],
data['RA'],
data['DEC'],
degree=True)
vxvyvz = bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:, 0],
pmllpmbb[:, 1],
lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
vR, vT, vZ = bovy_coords.vxvyvz_to_galcencyl(
vxvyvz[:, 0],
vxvyvz[:, 1],
vxvyvz[:, 2],
8. - XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2] + 0.025,
vsun=[-11.1, 30.24 * 8.,
7.25]) #Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR'] = vR
data['GALVT'] = vT
data['GALVZ'] = vZ
data['GALVR'][True - pmindx] = -9999.99
data['GALVT'][True - pmindx] = -9999.99
data['GALVZ'][True - pmindx] = -9999.99
#Get PPMXL proper motions, in a somewhat roundabout way
pmfile = savefilename.split('.')[0] + '_pms_ppmxl.fits'
if os.path.exists(pmfile):
pmdata = fitsio.read(pmfile, 1)
else:
pmdata = numpy.recarray(
len(data),
formats=['f8', 'f8', 'f8', 'f8', 'f8', 'f8', 'i4'],
names=[
'RA', 'DEC', 'PMRA', 'PMDEC', 'PMRA_ERR', 'PMDEC_ERR',
'PMMATCH'
])
# Write positions, again ...
posfilename = tempfile.mktemp('.csv', dir=os.getcwd())
resultfilename = tempfile.mktemp('.csv', dir=os.getcwd())
with open(posfilename, 'w') as csvfile:
wr = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA', 'DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'], data[ii]['DEC']])
# Send to CDS for matching
result = open(resultfilename, 'w')
try:
subprocess.check_call([
'curl', '-X', 'POST', '-F', 'request=xmatch', '-F',
'distMaxArcsec=4', '-F', 'RESPONSEFORMAT=csv', '-F',
'cat1=@%s' % os.path.basename(posfilename), '-F', 'colRA1=RA',
'-F', 'colDec1=DEC', '-F', 'cat2=vizier:PPMXL',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'
],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Match back and only keep the closest one
ma = numpy.loadtxt(resultfilename,
delimiter=',',
skiprows=1,
converters={
15: lambda s: float(s.strip() or -9999),
16: lambda s: float(s.strip() or -9999),
17: lambda s: float(s.strip() or -9999),
18: lambda s: float(s.strip() or -9999)
},
usecols=(4, 5, 15, 16, 19, 20))
h = esutil.htm.HTM()
m1, m2, d12 = h.match(data['RA'],
data['DEC'],
ma[:, 0],
ma[:, 1],
4. / 3600.,
maxmatch=1)
pmdata['PMMATCH'] = 0
pmdata['RA'] = data['RA']
pmdata['DEC'] = data['DEC']
pmdata['PMMATCH'][m1] = 1
pmdata['PMRA'][m1] = ma[m2, 2]
pmdata['PMDEC'][m1] = ma[m2, 3]
pmdata['PMRA_ERR'][m1] = ma[m2, 4]
pmdata['PMDEC_ERR'][m1] = ma[m2, 5]
pmdata['PMMATCH'][(pmdata['PMRA'] == -9999) \
+(pmdata['PMDEC'] == -9999) \
+(pmdata['PMRA_ERR'] == -9999) \
+(pmdata['PMDEC_ERR'] == -9999)]= 0
fitsio.write(pmfile, pmdata, clobber=True)
#To make sure we're using the same format below
pmdata = fitsio.read(pmfile, 1)
os.remove(posfilename)
os.remove(resultfilename)
#Match proper motions to ppmxl
data = esutil.numpy_util.add_fields(data,
[('PMRA_PPMXL', numpy.float),
('PMDEC_PPMXL', numpy.float),
('PMRA_ERR_PPMXL', numpy.float),
('PMDEC_ERR_PPMXL', numpy.float),
('PMMATCH_PPMXL', numpy.int32)])
data['PMMATCH_PPMXL'] = 0
h = esutil.htm.HTM()
m1, m2, d12 = h.match(pmdata['RA'],
pmdata['DEC'],
data['RA'],
data['DEC'],
2. / 3600.,
maxmatch=1)
data['PMRA_PPMXL'][m2] = pmdata['PMRA'][m1]
data['PMDEC_PPMXL'][m2] = pmdata['PMDEC'][m1]
data['PMRA_ERR_PPMXL'][m2] = pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR_PPMXL'][m2] = pmdata['PMDEC_ERR'][m1]
data['PMMATCH_PPMXL'][m2] = pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx = data['PMMATCH_PPMXL'] == 1
data['PMRA_PPMXL'][True - pmindx] = -9999.99
data['PMDEC_PPMXL'][True - pmindx] = -9999.99
data['PMRA_ERR_PPMXL'][True - pmindx] = -9999.99
data['PMDEC_ERR_PPMXL'][True - pmindx] = -9999.99
#Calculate Galactocentric velocities
data = esutil.numpy_util.add_fields(data, [('GALVR_PPMXL', numpy.float),
('GALVT_PPMXL', numpy.float),
('GALVZ_PPMXL', numpy.float)])
lb = bovy_coords.radec_to_lb(data['RA'], data['DEC'], degree=True)
XYZ = bovy_coords.lbd_to_XYZ(lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
pmllpmbb = bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA_PPMXL'],
data['PMDEC_PPMXL'],
data['RA'],
data['DEC'],
degree=True)
vxvyvz = bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:, 0],
pmllpmbb[:, 1],
lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
vR, vT, vZ = bovy_coords.vxvyvz_to_galcencyl(
vxvyvz[:, 0],
vxvyvz[:, 1],
vxvyvz[:, 2],
8. - XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2] + 0.025,
vsun=[-11.1, 30.24 * 8.,
7.25]) #Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR_PPMXL'] = vR
data['GALVT_PPMXL'] = vT
data['GALVZ_PPMXL'] = vZ
data['GALVR_PPMXL'][True - pmindx] = -9999.99
data['GALVT_PPMXL'][True - pmindx] = -9999.99
data['GALVZ_PPMXL'][True - pmindx] = -9999.99
#Save
fitsio.write(savefilename, data, clobber=True)
return None
def generate(locations,
type='exp',
sample='lowlow',
extmap='green15',
nls=101,
nmock=1000,
H0=-1.49,
_dmapg15=None,
ncpu=1):
"""
NAME:
generate
PURPOSE:
generate mock data following a given density
INPUT:
locations - locations to be included in the sample
type= ('exp') type of density profile to sample from
sample= ('lowlow') for selecting mock parameters
extmap= ('green15') extinction map to use ('marshall06' and others use Green15 to fill in unobserved regions)
nls= (101) number of longitude bins to use for each field
nmock= (1000) number of mock data points to generate
H0= (-1.49) absolute magnitude (can be array w/ sampling spread)
ncpu= (1) number of cpus to use to compute the probability
OUTPUT:
mockdata recarray with tags 'RC_GALR_H', 'RC_GALPHI_H', 'RC_GALZ_H'
HISTORY:
2015-04-03 - Written - Bovy (IAS)
"""
if isinstance(H0,float): H0= [H0]
# Setup the density function and its initial parameters
rdensfunc= fitDens._setup_densfunc(type)
mockparams= _setup_mockparams_densfunc(type,sample)
densfunc= lambda x,y,z: rdensfunc(x,y,z,params=mockparams)
# Setup the extinction map
global dmap
global dmapg15
if _dmapg15 is None: dmapg15= mwdust.Green15(filter='2MASS H')
else: dmapg15= _dmapg15
if isinstance(extmap,mwdust.DustMap3D.DustMap3D):
dmap= extmap
elif extmap.lower() == 'green15':
dmap= dmapg15
elif extmap.lower() == 'marshall06':
dmap= mwdust.Marshall06(filter='2MASS H')
elif extmap.lower() == 'sale14':
dmap= mwdust.Sale14(filter='2MASS H')
elif extmap.lower() == 'drimmel03':
dmap= mwdust.Drimmel03(filter='2MASS H')
# Use brute-force rejection sampling to make no approximations
# First need to estimate the max probability to use in rejection;
# Loop through all locations and compute sampling probability on grid in
# (l,b,D)
# First restore the APOGEE selection function (assumed pre-computed)
global apo
selectFile= '../savs/selfunc-nospdata.sav'
if os.path.exists(selectFile):
with open(selectFile,'rb') as savefile:
apo= pickle.load(savefile)
# Now compute the necessary coordinate transformations and evaluate the
# maximum probability
distmods= numpy.linspace(7.,15.5,301)
ds= 10.**(distmods/5-2.)
nbs= nls
lnprobs= numpy.empty((len(locations),len(distmods),nbs,nls))
radii= []
lcens, bcens= [], []
lnprobs= multi.parallel_map(lambda x: _calc_lnprob(locations[x],nls,nbs,
ds,distmods,
H0,
densfunc),
range(len(locations)),
numcores=numpy.amin([len(locations),
multiprocessing.cpu_count(),ncpu]))
lnprobs= numpy.array(lnprobs)
for ll, loc in enumerate(locations):
lcen, bcen= apo.glonGlat(loc)
rad= apo.radius(loc)
radii.append(rad) # save for later
lcens.append(lcen[0])
bcens.append(bcen[0])
maxp= (numpy.exp(numpy.nanmax(lnprobs))-10.**-8.)*1.1 # Just to be sure
# Now generate mock data using rejection sampling
nout= 0
arlocations= numpy.array(locations)
arradii= numpy.array(radii)
arlcens= numpy.array(lcens)
arbcens= numpy.array(bcens)
out= numpy.recarray((nmock,),
dtype=[('RC_DIST_H','f8'),
('RC_DM_H','f8'),
('RC_GALR_H','f8'),
('RC_GALPHI_H','f8'),
('RC_GALZ_H','f8')])
while nout < nmock:
nnew= 2*(nmock-nout)
# nnew new locations
locIndx= numpy.floor(numpy.random.uniform(size=nnew)*len(locations)).astype('int')
newlocations= arlocations[locIndx]
# Point within these locations
newds_coord= numpy.random.uniform(size=nnew)
newds= 10.**((newds_coord*(numpy.amax(distmods)-numpy.amin(distmods))\
+numpy.amin(distmods))/5.-2.)
newdls_coord= numpy.random.uniform(size=nnew)
newdls= newdls_coord*2.*arradii[locIndx]\
-arradii[locIndx]
newdbs_coord= numpy.random.uniform(size=nnew)
newdbs= newdbs_coord*2.*arradii[locIndx]\
-arradii[locIndx]
newr2s= newdls**2.+newdbs**2.
keepIndx= newr2s < arradii[locIndx]**2.
newlocations= newlocations[keepIndx]
newds_coord= newds_coord[keepIndx]
newdls_coord= newdls_coord[keepIndx]
newdbs_coord= newdbs_coord[keepIndx]
newds= newds[keepIndx]
newdls= newdls[keepIndx]
newdbs= newdbs[keepIndx]
newls= newdls+arlcens[locIndx][keepIndx]
newbs= newdbs+arbcens[locIndx][keepIndx]
# Reject?
tps= numpy.zeros_like(newds)
for nloc in list(set(newlocations)):
lindx= newlocations == nloc
pindx= arlocations == nloc
coord= numpy.array([newds_coord[lindx]*(len(distmods)-1.),
newdbs_coord[lindx]*(nbs-1.),
newdls_coord[lindx]*(nls-1.)])
tps[lindx]= \
numpy.exp(ndimage.interpolation.map_coordinates(\
lnprobs[pindx][0],
coord,cval=-10.,
order=1))-10.**-8.
XYZ= bovy_coords.lbd_to_XYZ(newls,newbs,newds,degree=True)
Rphiz= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],XYZ[:,1],XYZ[:,2],
Xsun=define_rcsample._R0,
Ysun=0.,
Zsun=define_rcsample._Z0)
testp= numpy.random.uniform(size=len(newds))*maxp
keepIndx= tps > testp
if numpy.sum(keepIndx) > nmock-nout:
rangeIndx= numpy.zeros(len(keepIndx),dtype='int')
rangeIndx[keepIndx]= numpy.arange(numpy.sum(keepIndx))
keepIndx*= (rangeIndx < nmock-nout)
out['RC_DIST_H'][nout:nout+numpy.sum(keepIndx)]= newds[keepIndx]
out['RC_DM_H'][nout:nout+numpy.sum(keepIndx)]= newds_coord[keepIndx]*(numpy.amax(distmods)-numpy.amin(distmods))\
+numpy.amin(distmods)
out['RC_GALR_H'][nout:nout+numpy.sum(keepIndx)]= Rphiz[0][keepIndx]
out['RC_GALPHI_H'][nout:nout+numpy.sum(keepIndx)]= Rphiz[1][keepIndx]
out['RC_GALZ_H'][nout:nout+numpy.sum(keepIndx)]= Rphiz[2][keepIndx]
nout= nout+numpy.sum(keepIndx)
return (out,lnprobs)
def make_rcsample(parser):
options,args= parser.parse_args()
savefilename= options.savefilename
if savefilename is None:
#Create savefilename if not given
savefilename= os.path.join(appath._APOGEE_DATA,
'rcsample_'+appath._APOGEE_REDUX+'.fits')
print "Saving to %s ..." % savefilename
#Read the base-sample
data= apread.allStar(adddist=_ADDHAYDENDIST,rmdups=options.rmdups)
#Remove a bunch of fields that we do not want to keep
data= esutil.numpy_util.remove_fields(data,
['TARGET_ID',
'FILE',
'AK_WISE',
'SFD_EBV',
'SYNTHVHELIO_AVG',
'SYNTHVSCATTER',
'SYNTHVERR',
'SYNTHVERR_MED',
'RV_TEFF',
'RV_LOGG',
'RV_FEH',
'RV_CCFWHM',
'RV_AUTOFWHM',
'SYNTHSCATTER',
'CHI2_THRESHOLD',
'APSTAR_VERSION',
'ASPCAP_VERSION',
'RESULTS_VERSION',
'REDUCTION_ID',
'SRC_H',
'PM_SRC'])
if not appath._APOGEE_REDUX.lower() == 'current' \
and int(appath._APOGEE_REDUX[1:]) < 500:
data= esutil.numpy_util.remove_fields(data,
['ELEM'])
#Select red-clump stars
jk= data['J0']-data['K0']
z= isodist.FEH2Z(data['METALS'],zsolar=0.017)
if appath._APOGEE_REDUX.lower() == 'current' \
or int(appath._APOGEE_REDUX[1:]) > 600:
from apogee.tools import paramIndx
if False:
#Use my custom logg calibration that's correct for the RC
logg= (1.-0.042)*data['FPARAM'][:,paramIndx('logg')]-0.213
lowloggindx= data['FPARAM'][:,paramIndx('logg')] < 1.
logg[lowloggindx]= data['FPARAM'][lowloggindx,paramIndx('logg')]-0.255
hiloggindx= data['FPARAM'][:,paramIndx('logg')] > 3.8
logg[hiloggindx]= data['FPARAM'][hiloggindx,paramIndx('logg')]-0.3726
else:
#Use my custom logg calibration that's correct on average
logg= (1.+0.03)*data['FPARAM'][:,paramIndx('logg')]-0.37
lowloggindx= data['FPARAM'][:,paramIndx('logg')] < 1.
logg[lowloggindx]= data['FPARAM'][lowloggindx,paramIndx('logg')]-0.34
hiloggindx= data['FPARAM'][:,paramIndx('logg')] > 3.8
logg[hiloggindx]= data['FPARAM'][hiloggindx,paramIndx('logg')]-0.256
else:
logg= data['LOGG']
indx= (jk < 0.8)*(jk >= 0.5)\
*(z <= 0.06)\
*(z <= rcmodel.jkzcut(jk,upper=True))\
*(z >= rcmodel.jkzcut(jk))\
*(logg >= rcmodel.loggteffcut(data['TEFF'],z,upper=False))\
*(logg <= rcmodel.loggteffcut(data['TEFF'],z,upper=True))
data= data[indx]
#Add more aggressive flag cut
data= esutil.numpy_util.add_fields(data,[('ADDL_LOGG_CUT',numpy.int32)])
data['ADDL_LOGG_CUT']= ((data['TEFF']-4800.)/1000.+2.75) > data['LOGG']
if options.loggcut:
data= data[data['ADDL_LOGG_CUT'] == 1]
print "Making catalog of %i objects ..." % len(data)
#Add distances
data= esutil.numpy_util.add_fields(data,[('RC_DIST', float),
('RC_DM', float),
('RC_GALR', float),
('RC_GALPHI', float),
('RC_GALZ', float)])
rcd= rcmodel.rcdist()
jk= data['J0']-data['K0']
z= isodist.FEH2Z(data['METALS'],zsolar=0.017)
data['RC_DIST']= rcd(jk,z,appmag=data['K0'])*options.distfac
data['RC_DM']= 5.*numpy.log10(data['RC_DIST'])+10.
XYZ= bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['RC_DIST'],
degree=True)
R,phi,Z= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],
XYZ[:,1],
XYZ[:,2],
Xsun=8.,Zsun=0.025)
data['RC_GALR']= R
data['RC_GALPHI']= phi
data['RC_GALZ']= Z
#Save
fitsio.write(savefilename,data,clobber=True)
if not options.nostat:
#Determine statistical sample and add flag
apo= apogee.select.apogeeSelect()
statIndx= apo.determine_statistical(data)
mainIndx= apread.mainIndx(data)
data= esutil.numpy_util.add_fields(data,[('STAT',numpy.int32),
('INVSF',float)])
data['STAT']= 0
data['STAT'][statIndx*mainIndx]= 1
for ii in range(len(data)):
if (statIndx*mainIndx)[ii]:
data['INVSF'][ii]= 1./apo(data['LOCATION_ID'][ii],
data['H'][ii])
else:
data['INVSF'][ii]= -1.
if options.nopm:
fitsio.write(savefilename,data,clobber=True)
return None
#Get proper motions
from astroquery.vizier import Vizier
import astroquery
from astropy import units as u
import astropy.coordinates as coord
pmfile= savefilename.split('.')[0]+'_pms.fits'
if os.path.exists(pmfile):
pmdata= fitsio.read(pmfile,1)
else:
pmdata= numpy.recarray(len(data),
formats=['f8','f8','f8','f8','f8','f8','i4'],
names=['RA','DEC','PMRA','PMDEC',
'PMRA_ERR','PMDEC_ERR','PMMATCH'])
rad= u.Quantity(4./3600.,u.degree)
v= Vizier(columns=['RAJ2000','DEJ2000','pmRA','pmDE','e_pmRA','e_pmDE'])
for ii in range(len(data)):
#if ii > 100: break
sys.stdout.write('\r'+"Getting pm data for point %i / %i" % (ii+1,len(data)))
sys.stdout.flush()
pmdata.RA[ii]= data['RA'][ii]
pmdata.DEC[ii]= data['DEC'][ii]
co= coord.ICRS(ra=data['RA'][ii],
dec=data['DEC'][ii],
unit=(u.degree, u.degree))
trying= True
while trying:
try:
tab= v.query_region(co,rad,catalog='I/322') #UCAC-4 catalog
except astroquery.exceptions.TimeoutError:
pass
else:
trying= False
if len(tab) == 0:
pmdata.PMMATCH[ii]= 0
print "Didn't find a match for %i ..." % ii
continue
else:
pmdata.PMMATCH[ii]= len(tab)
if len(tab[0]['pmRA']) > 1:
print "Found more than 1 match for %i ..." % ii
try:
pmdata.PMRA[ii]= float(tab[0]['pmRA'])
except TypeError:
jj= 1
while len(tab[0]['pmRA']) > 1 and jj < 4:
trad= u.Quantity((4.-jj)/3600.,u.degree)
trying= True
while trying:
try:
tab= v.query_region(co,trad,catalog='I/322') #UCAC-4 catalog
except astroquery.exceptions.TimeoutError:
pass
else:
trying= False
jj+= 1
if len(tab) == 0:
pmdata.PMMATCH[ii]= 0
print "Didn't find a unambiguous match for %i ..." % ii
continue
pmdata.PMRA[ii]= float(tab[0]['pmRA'])
pmdata.PMDEC[ii]= float(tab[0]['pmDE'])
pmdata.PMRA_ERR[ii]= float(tab[0]['e_pmRA'])
pmdata.PMDEC_ERR[ii]= float(tab[0]['e_pmDE'])
if numpy.isnan(float(tab[0]['pmRA'])): pmdata.PMMATCH[ii]= 0
sys.stdout.write('\r'+_ERASESTR+'\r')
sys.stdout.flush()
fitsio.write(pmfile,pmdata,clobber=True)
#To make sure we're using the same format below
pmdata= fitsio.read(pmfile,1)
#Match proper motions
try: #These already exist currently, but may not always exist
data= esutil.numpy_util.remove_fields(data,['PMRA','PMDEC'])
except ValueError:
pass
data= esutil.numpy_util.add_fields(data,[('PMRA', numpy.float),
('PMDEC', numpy.float),
('PMRA_ERR', numpy.float),
('PMDEC_ERR', numpy.float),
('PMMATCH',numpy.int32)])
data['PMMATCH']= 0
h=esutil.htm.HTM()
m1,m2,d12 = h.match(pmdata['RA'],pmdata['DEC'],
data['RA'],data['DEC'],
2./3600.,maxmatch=1)
data['PMRA'][m2]= pmdata['PMRA'][m1]
data['PMDEC'][m2]= pmdata['PMDEC'][m1]
data['PMRA_ERR'][m2]= pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR'][m2]= pmdata['PMDEC_ERR'][m1]
data['PMMATCH'][m2]= pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx= data['PMMATCH'] == 1
data['PMRA'][True-pmindx]= -9999.99
data['PMDEC'][True-pmindx]= -9999.99
data['PMRA_ERR'][True-pmindx]= -9999.99
data['PMDEC_ERR'][True-pmindx]= -9999.99
#Calculate Galactocentric velocities
data= esutil.numpy_util.add_fields(data,[('GALVR', numpy.float),
('GALVT', numpy.float),
('GALVZ', numpy.float)])
lb= bovy_coords.radec_to_lb(data['RA'],data['DEC'],degree=True)
XYZ= bovy_coords.lbd_to_XYZ(lb[:,0],lb[:,1],data['RC_DIST'],degree=True)
pmllpmbb= bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA'],data['PMDEC'],
data['RA'],data['DEC'],
degree=True)
vxvyvz= bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:,0],
pmllpmbb[:,1],
lb[:,0],lb[:,1],data['RC_DIST'],
degree=True)
vR, vT, vZ= bovy_coords.vxvyvz_to_galcencyl(vxvyvz[:,0],
vxvyvz[:,1],
vxvyvz[:,2],
8.-XYZ[:,0],
XYZ[:,1],
XYZ[:,2]+0.025,
vsun=[-11.1,30.24*8.,7.25])#Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR']= vR
data['GALVT']= vT
data['GALVZ']= vZ
data['GALVR'][True-pmindx]= -9999.99
data['GALVT'][True-pmindx]= -9999.99
data['GALVZ'][True-pmindx]= -9999.99
#Get proper motions
pmfile= savefilename.split('.')[0]+'_pms_ppmxl.fits'
if os.path.exists(pmfile):
pmdata= fitsio.read(pmfile,1)
else:
pmdata= numpy.recarray(len(data),
formats=['f8','f8','f8','f8','f8','f8','i4'],
names=['RA','DEC','PMRA','PMDEC',
'PMRA_ERR','PMDEC_ERR','PMMATCH'])
rad= u.Quantity(4./3600.,u.degree)
v= Vizier(columns=['RAJ2000','DEJ2000','pmRA','pmDE','e_pmRA','e_pmDE'])
for ii in range(len(data)):
#if ii > 100: break
sys.stdout.write('\r'+"Getting pm data for point %i / %i" % (ii+1,len(data)))
sys.stdout.flush()
pmdata.RA[ii]= data['RA'][ii]
pmdata.DEC[ii]= data['DEC'][ii]
co= coord.ICRS(ra=data['RA'][ii],
dec=data['DEC'][ii],
unit=(u.degree, u.degree))
trying= True
while trying:
try:
tab= v.query_region(co,rad,catalog='I/317') #PPMXL catalog
except astroquery.exceptions.TimeoutError:
pass
else:
trying= False
if len(tab) == 0:
pmdata.PMMATCH[ii]= 0
print "Didn't find a match for %i ..." % ii
continue
else:
pmdata.PMMATCH[ii]= len(tab)
if len(tab[0]['pmRA']) > 1:
pass
#print "Found more than 1 match for %i ..." % ii
try:
pmdata.PMRA[ii]= float(tab[0]['pmRA'])
except TypeError:
#Find nearest
cosdists= numpy.zeros(len(tab[0]['pmRA']))
for jj in range(len(tab[0]['pmRA'])):
cosdists[jj]= cos_sphere_dist(tab[0]['RAJ2000'][jj],
tab[0]['DEJ2000'][jj],
data['RA'][ii],
data['DEC'][ii])
closest= numpy.argmax(cosdists)
pmdata.PMRA[ii]= float(tab[0]['pmRA'][closest])
pmdata.PMDEC[ii]= float(tab[0]['pmDE'][closest])
pmdata.PMRA_ERR[ii]= float(tab[0]['e_pmRA'][closest])
pmdata.PMDEC_ERR[ii]= float(tab[0]['e_pmDE'][closest])
if numpy.isnan(float(tab[0]['pmRA'][closest])): pmdata.PMMATCH[ii]= 0
else:
pmdata.PMDEC[ii]= float(tab[0]['pmDE'])
pmdata.PMRA_ERR[ii]= float(tab[0]['e_pmRA'])
pmdata.PMDEC_ERR[ii]= float(tab[0]['e_pmDE'])
if numpy.isnan(float(tab[0]['pmRA'])): pmdata.PMMATCH[ii]= 0
sys.stdout.write('\r'+_ERASESTR+'\r')
sys.stdout.flush()
fitsio.write(pmfile,pmdata,clobber=True)
#To make sure we're using the same format below
pmdata= fitsio.read(pmfile,1)
#Match proper motions to ppmxl
data= esutil.numpy_util.add_fields(data,[('PMRA_PPMXL', numpy.float),
('PMDEC_PPMXL', numpy.float),
('PMRA_ERR_PPMXL', numpy.float),
('PMDEC_ERR_PPMXL', numpy.float),
('PMMATCH_PPMXL',numpy.int32)])
data['PMMATCH_PPMXL']= 0
h=esutil.htm.HTM()
m1,m2,d12 = h.match(pmdata['RA'],pmdata['DEC'],
data['RA'],data['DEC'],
2./3600.,maxmatch=1)
data['PMRA_PPMXL'][m2]= pmdata['PMRA'][m1]
data['PMDEC_PPMXL'][m2]= pmdata['PMDEC'][m1]
data['PMRA_ERR_PPMXL'][m2]= pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR_PPMXL'][m2]= pmdata['PMDEC_ERR'][m1]
data['PMMATCH_PPMXL'][m2]= pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx= data['PMMATCH_PPMXL'] == 1
data['PMRA_PPMXL'][True-pmindx]= -9999.99
data['PMDEC_PPMXL'][True-pmindx]= -9999.99
data['PMRA_ERR_PPMXL'][True-pmindx]= -9999.99
data['PMDEC_ERR_PPMXL'][True-pmindx]= -9999.99
#Calculate Galactocentric velocities
data= esutil.numpy_util.add_fields(data,[('GALVR_PPMXL', numpy.float),
('GALVT_PPMXL', numpy.float),
('GALVZ_PPMXL', numpy.float)])
lb= bovy_coords.radec_to_lb(data['RA'],data['DEC'],degree=True)
XYZ= bovy_coords.lbd_to_XYZ(lb[:,0],lb[:,1],data['RC_DIST'],degree=True)
pmllpmbb= bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA_PPMXL'],
data['PMDEC_PPMXL'],
data['RA'],data['DEC'],
degree=True)
vxvyvz= bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:,0],
pmllpmbb[:,1],
lb[:,0],lb[:,1],data['RC_DIST'],
degree=True)
vR, vT, vZ= bovy_coords.vxvyvz_to_galcencyl(vxvyvz[:,0],
vxvyvz[:,1],
vxvyvz[:,2],
8.-XYZ[:,0],
XYZ[:,1],
XYZ[:,2]+0.025,
vsun=[-11.1,30.24*8.,7.25])#Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR_PPMXL']= vR
data['GALVT_PPMXL']= vT
data['GALVZ_PPMXL']= vZ
data['GALVR_PPMXL'][True-pmindx]= -9999.99
data['GALVT_PPMXL'][True-pmindx]= -9999.99
data['GALVZ_PPMXL'][True-pmindx]= -9999.99
#Save
fitsio.write(savefilename,data,clobber=True)
return None
def get_rgbsample(loggcut=[1.8, 3.0],
teffcut=[0, 10000],
add_ages=False,
agetype='Martig',
apply_corrections=False,
distance_correction=False,
verbose=False):
"""
Get a clean sample of dr12 APOGEE data with Michael Haydens distances
---
INPUT:
None
OUTPUT:
Clean rgb sample with added distances
HISTORY:
Started - Mackereth 02/06/16
"""
#get the allStar catalogue using apogee python (exlude all bad flags etc)
allStar = apread.allStar(rmcommissioning=True,
exclude_star_bad=True,
exclude_star_warn=True,
main=True,
ak=True,
adddist=False)
#cut to a 'sensible' logg range (giants which are not too high on the RGB)
allStar = allStar[(allStar['LOGG'] > loggcut[0])
& (allStar['LOGG'] < loggcut[1]) &
(allStar['TEFF'] > teffcut[0]) &
(allStar['TEFF'] < teffcut[1])]
if verbose == True:
print str(
len(allStar
)) + ' Stars before Distance catalogue join (after Log(g) cut)'
#load the distance VAC
dists = fits.open(catpath + 'DR12_DIST_R-GC.fits')[1].data
#convert to astropy Table
allStar_tab = Table(data=allStar)
dists_tab = Table(data=dists)
#join table
tab = join(allStar_tab,
dists_tab,
keys='APOGEE_ID',
uniq_col_name='{col_name}{table_name}',
table_names=['', '2'])
data = tab.as_array()
data = esutil.numpy_util.add_fields(data, [('M_J', float), ('M_H', float),
('M_K', float),
('MH50_DIST', float),
('MH50_GALR', float),
('MH50_GALZ', float),
('MH50_GALPHI', float),
('AVG_ALPHAFE', float)])
data['MH50_DIST'] = (10**((data['HAYDEN_DISTMOD_50'] + 5) / 5)) / 1e3
if distance_correction == True:
data['MH50_DIST'] *= 1.05
XYZ = bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['MH50_DIST'],
degree=True)
RphiZ = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2],
Xsun=8.,
Zsun=0.025)
data['MH50_GALR'] = RphiZ[:, 0]
data['MH50_GALPHI'] = RphiZ[:, 1]
data['MH50_GALZ'] = RphiZ[:, 2]
data['M_J'] = data['J0'] - data['HAYDEN_DISTMOD_50']
data['M_H'] = data['H0'] - data['HAYDEN_DISTMOD_50']
data['M_K'] = data['K0'] - data['HAYDEN_DISTMOD_50']
data['AVG_ALPHAFE'] = avg_alphafe_dr12(data)
data[_FEHTAG] += -0.1
#remove locations not in the apogee selection function (FIND OUT WHATS UP HERE)
data = data[np.in1d(data['LOCATION_ID'], apo.list_fields())]
# Remove locations outside of the Pan-STARRS dust map
# In the Southern hemisphere
data = data[data['LOCATION_ID'] != 4266] #240,-18
data = data[data['LOCATION_ID'] != 4331] #5.5,-14.2
data = data[data['LOCATION_ID'] != 4381] #5.2,-12.2
data = data[data['LOCATION_ID'] != 4332] #1,-4
data = data[data['LOCATION_ID'] != 4329] #0,-5
data = data[data['LOCATION_ID'] != 4351] #0,-2
data = data[data['LOCATION_ID'] != 4353] #358,0
data = data[data['LOCATION_ID'] != 4385] #358.6,1.4
# Close to the ecliptic pole where there's no data (is it the ecliptic pole?
data = data[data['LOCATION_ID'] != 4528] #120,30
data = data[data['LOCATION_ID'] != 4217] #123,22.4
#remove any non-finite magnitudes
data = data[np.isfinite(data['M_H'])]
if verbose == True:
print str(len(
data)) + ' Stars with distance measures (and in good fields...)'
if add_ages == True:
if agetype == 'Martig':
ages = fits.open(catpath + 'DR12_martigages_vizier.fits')[1].data
idtag = '2MASS_ID'
if agetype == 'Cannon':
ages = fits.open(catpath + 'RGB_Cannon_Ages.fits')[1].data
ages = esutil.numpy_util.add_fields(ages, [('Age', float)])
ages['Age'] = np.exp(ages['ln_age'])
idtag = 'ID'
ages_tab = Table(data=ages)
ages_tab.rename_column(idtag, 'APOGEE_ID')
tab = join(ages_tab,
data,
keys='APOGEE_ID',
uniq_col_name='{col_name}{table_name}',
table_names=['', '2'])
allStar_full = tab.as_array()
data = allStar_full
if verbose == True:
print str(len(data)) + ' Stars with ages'
if apply_corrections == True:
#martig1 = np.genfromtxt(catpath+'martig2016_table1.txt', dtype=None, names=True, skip_header=2)
martig1 = fits.open(catpath + 'martig_table1.fits')
fit = lowess(np.log10(martig1['Age_out']), np.log10(martig1['Age_in']))
xs = np.linspace(-0.3, 1.2, 100)
xsinterpolate = interp1d(xs, xs)
fys = fit[:, 0] - xsinterpolate(fit[:, 1])
interp = UnivariateSpline(fit[:, 1], fys)
corr_age = np.log10(data['Age']) + (interp(np.log10(data['Age'])))
corr_age = 10**corr_age
data['Age'] = corr_age
return data
def make_rcsample(parser):
options,args= parser.parse_args()
savefilename= options.savefilename
if savefilename is None:
#Create savefilename if not given
savefilename= os.path.join(appath._APOGEE_DATA,
'rcsample_'+appath._APOGEE_REDUX+'.fits')
print("Saving to %s ..." % savefilename)
#Read the base-sample
data= apread.allStar(adddist=_ADDHAYDENDIST,rmdups=options.rmdups)
#Remove a bunch of fields that we do not want to keep
data= esutil.numpy_util.remove_fields(data,
['TARGET_ID',
'FILE',
'AK_WISE',
'SFD_EBV',
'SYNTHVHELIO_AVG',
'SYNTHVSCATTER',
'SYNTHVERR',
'SYNTHVERR_MED',
'RV_TEFF',
'RV_LOGG',
'RV_FEH',
'RV_ALPHA',
'RV_CARB',
'RV_CCFWHM',
'RV_AUTOFWHM',
'SYNTHSCATTER',
'STABLERV_CHI2',
'STABLERV_RCHI2',
'STABLERV_CHI2_PROB',
'CHI2_THRESHOLD',
'APSTAR_VERSION',
'ASPCAP_VERSION',
'RESULTS_VERSION',
'WASH_M',
'WASH_M_ERR',
'WASH_T2',
'WASH_T2_ERR',
'DDO51',
'DDO51_ERR',
'IRAC_3_6',
'IRAC_3_6_ERR',
'IRAC_4_5',
'IRAC_4_5_ERR',
'IRAC_5_8',
'IRAC_5_8_ERR',
'IRAC_8_0',
'IRAC_8_0_ERR',
'WISE_4_5',
'WISE_4_5_ERR',
'TARG_4_5',
'TARG_4_5_ERR',
'WASH_DDO51_GIANT_FLAG',
'WASH_DDO51_STAR_FLAG',
'REDUCTION_ID',
'SRC_H',
'PM_SRC'])
if not appath._APOGEE_REDUX.lower() == 'current' \
and not 'l30' in appath._APOGEE_REDUX \
and int(appath._APOGEE_REDUX[1:]) < 500:
data= esutil.numpy_util.remove_fields(data,
['ELEM'])
#Select red-clump stars
jk= data['J0']-data['K0']
z= isodist.FEH2Z(data['METALS'],zsolar=0.017)
if 'l30' in appath._APOGEE_REDUX:
logg= data['LOGG']
elif appath._APOGEE_REDUX.lower() == 'current' \
or int(appath._APOGEE_REDUX[1:]) > 600:
from apogee.tools import paramIndx
if False:
#Use my custom logg calibration that's correct for the RC
logg= (1.-0.042)*data['FPARAM'][:,paramIndx('logg')]-0.213
lowloggindx= data['FPARAM'][:,paramIndx('logg')] < 1.
logg[lowloggindx]= data['FPARAM'][lowloggindx,paramIndx('logg')]-0.255
hiloggindx= data['FPARAM'][:,paramIndx('logg')] > 3.8
logg[hiloggindx]= data['FPARAM'][hiloggindx,paramIndx('logg')]-0.3726
else:
#Use my custom logg calibration that's correct on average
logg= (1.+0.03)*data['FPARAM'][:,paramIndx('logg')]-0.37
lowloggindx= data['FPARAM'][:,paramIndx('logg')] < 1.
logg[lowloggindx]= data['FPARAM'][lowloggindx,paramIndx('logg')]-0.34
hiloggindx= data['FPARAM'][:,paramIndx('logg')] > 3.8
logg[hiloggindx]= data['FPARAM'][hiloggindx,paramIndx('logg')]-0.256
else:
logg= data['LOGG']
indx= (jk < 0.8)*(jk >= 0.5)\
*(z <= 0.06)\
*(z <= rcmodel.jkzcut(jk,upper=True))\
*(z >= rcmodel.jkzcut(jk))\
*(logg >= rcmodel.loggteffcut(data['TEFF'],z,upper=False))\
*(logg <= rcmodel.loggteffcut(data['TEFF'],z,upper=True))
data= data[indx]
#Add more aggressive flag cut
data= esutil.numpy_util.add_fields(data,[('ADDL_LOGG_CUT',numpy.int32)])
data['ADDL_LOGG_CUT']= ((data['TEFF']-4800.)/1000.+2.75) > data['LOGG']
if options.loggcut:
data= data[data['ADDL_LOGG_CUT'] == 1]
print("Making catalog of %i objects ..." % len(data))
#Add distances
data= esutil.numpy_util.add_fields(data,[('RC_DIST', float),
('RC_DM', float),
('RC_GALR', float),
('RC_GALPHI', float),
('RC_GALZ', float)])
rcd= rcmodel.rcdist()
jk= data['J0']-data['K0']
z= isodist.FEH2Z(data['METALS'],zsolar=0.017)
data['RC_DIST']= rcd(jk,z,appmag=data['K0'])*options.distfac
data['RC_DM']= 5.*numpy.log10(data['RC_DIST'])+10.
XYZ= bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['RC_DIST'],
degree=True)
R,phi,Z= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],
XYZ[:,1],
XYZ[:,2],
Xsun=8.,Zsun=0.025)
data['RC_GALR']= R
data['RC_GALPHI']= phi
data['RC_GALZ']= Z
#Save
fitsio.write(savefilename,data,clobber=True)
# Add Tycho-2 matches
if options.tyc2:
data= esutil.numpy_util.add_fields(data,[('TYC2MATCH',numpy.int32),
('TYC1',numpy.int32),
('TYC2',numpy.int32),
('TYC3',numpy.int32)])
data['TYC2MATCH']= 0
data['TYC1']= -1
data['TYC2']= -1
data['TYC3']= -1
# Write positions
posfilename= tempfile.mktemp('.csv',dir=os.getcwd())
resultfilename= tempfile.mktemp('.csv',dir=os.getcwd())
with open(posfilename,'w') as csvfile:
wr= csv.writer(csvfile,delimiter=',',quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA','DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'],data[ii]['DEC']])
# Send to CDS for matching
result= open(resultfilename,'w')
try:
subprocess.check_call(['curl',
'-X','POST',
'-F','request=xmatch',
'-F','distMaxArcsec=2',
'-F','RESPONSEFORMAT=csv',
'-F','cat1=@%s' % os.path.basename(posfilename),
'-F','colRA1=RA',
'-F','colDec1=DEC',
'-F','cat2=vizier:Tycho2',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Directly match on input RA
ma= numpy.loadtxt(resultfilename,delimiter=',',skiprows=1,
usecols=(1,2,7,8,9))
iis= numpy.arange(len(data))
mai= [iis[data['RA'] == ma[ii,0]][0] for ii in range(len(ma))]
data['TYC2MATCH'][mai]= 1
data['TYC1'][mai]= ma[:,2]
data['TYC2'][mai]= ma[:,3]
data['TYC3'][mai]= ma[:,4]
os.remove(posfilename)
os.remove(resultfilename)
if not options.nostat:
#Determine statistical sample and add flag
apo= apogee.select.apogeeSelect()
statIndx= apo.determine_statistical(data)
mainIndx= apread.mainIndx(data)
data= esutil.numpy_util.add_fields(data,[('STAT',numpy.int32),
('INVSF',float)])
data['STAT']= 0
data['STAT'][statIndx*mainIndx]= 1
for ii in range(len(data)):
if (statIndx*mainIndx)[ii]:
data['INVSF'][ii]= 1./apo(data['LOCATION_ID'][ii],
data['H'][ii])
else:
data['INVSF'][ii]= -1.
if options.nopm:
fitsio.write(savefilename,data,clobber=True)
return None
#Get proper motions, in a somewhat roundabout way
pmfile= savefilename.split('.')[0]+'_pms.fits'
if os.path.exists(pmfile):
pmdata= fitsio.read(pmfile,1)
else:
pmdata= numpy.recarray(len(data),
formats=['f8','f8','f8','f8','f8','f8','i4'],
names=['RA','DEC','PMRA','PMDEC',
'PMRA_ERR','PMDEC_ERR','PMMATCH'])
# Write positions, again ...
posfilename= tempfile.mktemp('.csv',dir=os.getcwd())
resultfilename= tempfile.mktemp('.csv',dir=os.getcwd())
with open(posfilename,'w') as csvfile:
wr= csv.writer(csvfile,delimiter=',',quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA','DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'],data[ii]['DEC']])
# Send to CDS for matching
result= open(resultfilename,'w')
try:
subprocess.check_call(['curl',
'-X','POST',
'-F','request=xmatch',
'-F','distMaxArcsec=4',
'-F','RESPONSEFORMAT=csv',
'-F','cat1=@%s' % os.path.basename(posfilename),
'-F','colRA1=RA',
'-F','colDec1=DEC',
'-F','cat2=vizier:UCAC4',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Match back and only keep the closest one
ma= numpy.loadtxt(resultfilename,delimiter=',',skiprows=1,
converters={15: lambda s: float(s.strip() or -9999),
16: lambda s: float(s.strip() or -9999),
17: lambda s: float(s.strip() or -9999),
18: lambda s: float(s.strip() or -9999)},
usecols=(4,5,15,16,17,18))
h=esutil.htm.HTM()
m1,m2,d12 = h.match(data['RA'],data['DEC'],
ma[:,0],ma[:,1],4./3600.,maxmatch=1)
pmdata['PMMATCH']= 0
pmdata['RA']= data['RA']
pmdata['DEC']= data['DEC']
pmdata['PMMATCH'][m1]= 1
pmdata['PMRA'][m1]= ma[m2,2]
pmdata['PMDEC'][m1]= ma[m2,3]
pmdata['PMRA_ERR'][m1]= ma[m2,4]
pmdata['PMDEC_ERR'][m1]= ma[m2,5]
pmdata['PMMATCH'][(pmdata['PMRA'] == -9999) \
+(pmdata['PMDEC'] == -9999) \
+(pmdata['PMRA_ERR'] == -9999) \
+(pmdata['PMDEC_ERR'] == -9999)]= 0
fitsio.write(pmfile,pmdata,clobber=True)
#To make sure we're using the same format below
pmdata= fitsio.read(pmfile,1)
os.remove(posfilename)
os.remove(resultfilename)
#Match proper motions
try: #These already exist currently, but may not always exist
data= esutil.numpy_util.remove_fields(data,['PMRA','PMDEC'])
except ValueError:
pass
data= esutil.numpy_util.add_fields(data,[('PMRA', numpy.float),
('PMDEC', numpy.float),
('PMRA_ERR', numpy.float),
('PMDEC_ERR', numpy.float),
('PMMATCH',numpy.int32)])
data['PMMATCH']= 0
h=esutil.htm.HTM()
m1,m2,d12 = h.match(pmdata['RA'],pmdata['DEC'],
data['RA'],data['DEC'],
2./3600.,maxmatch=1)
data['PMRA'][m2]= pmdata['PMRA'][m1]
data['PMDEC'][m2]= pmdata['PMDEC'][m1]
data['PMRA_ERR'][m2]= pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR'][m2]= pmdata['PMDEC_ERR'][m1]
data['PMMATCH'][m2]= pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx= data['PMMATCH'] == 1
data['PMRA'][True-pmindx]= -9999.99
data['PMDEC'][True-pmindx]= -9999.99
data['PMRA_ERR'][True-pmindx]= -9999.99
data['PMDEC_ERR'][True-pmindx]= -9999.99
#Calculate Galactocentric velocities
data= esutil.numpy_util.add_fields(data,[('GALVR', numpy.float),
('GALVT', numpy.float),
('GALVZ', numpy.float)])
lb= bovy_coords.radec_to_lb(data['RA'],data['DEC'],degree=True)
XYZ= bovy_coords.lbd_to_XYZ(lb[:,0],lb[:,1],data['RC_DIST'],degree=True)
pmllpmbb= bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA'],data['PMDEC'],
data['RA'],data['DEC'],
degree=True)
vxvyvz= bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:,0],
pmllpmbb[:,1],
lb[:,0],lb[:,1],data['RC_DIST'],
degree=True)
vR, vT, vZ= bovy_coords.vxvyvz_to_galcencyl(vxvyvz[:,0],
vxvyvz[:,1],
vxvyvz[:,2],
8.-XYZ[:,0],
XYZ[:,1],
XYZ[:,2]+0.025,
vsun=[-11.1,30.24*8.,7.25])#Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR']= vR
data['GALVT']= vT
data['GALVZ']= vZ
data['GALVR'][True-pmindx]= -9999.99
data['GALVT'][True-pmindx]= -9999.99
data['GALVZ'][True-pmindx]= -9999.99
#Get PPMXL proper motions, in a somewhat roundabout way
pmfile= savefilename.split('.')[0]+'_pms_ppmxl.fits'
if os.path.exists(pmfile):
pmdata= fitsio.read(pmfile,1)
else:
pmdata= numpy.recarray(len(data),
formats=['f8','f8','f8','f8','f8','f8','i4'],
names=['RA','DEC','PMRA','PMDEC',
'PMRA_ERR','PMDEC_ERR','PMMATCH'])
# Write positions, again ...
posfilename= tempfile.mktemp('.csv',dir=os.getcwd())
resultfilename= tempfile.mktemp('.csv',dir=os.getcwd())
with open(posfilename,'w') as csvfile:
wr= csv.writer(csvfile,delimiter=',',quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA','DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'],data[ii]['DEC']])
# Send to CDS for matching
result= open(resultfilename,'w')
try:
subprocess.check_call(['curl',
'-X','POST',
'-F','request=xmatch',
'-F','distMaxArcsec=4',
'-F','RESPONSEFORMAT=csv',
'-F','cat1=@%s' % os.path.basename(posfilename),
'-F','colRA1=RA',
'-F','colDec1=DEC',
'-F','cat2=vizier:PPMXL',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Match back and only keep the closest one
ma= numpy.loadtxt(resultfilename,delimiter=',',skiprows=1,
converters={15: lambda s: float(s.strip() or -9999),
16: lambda s: float(s.strip() or -9999),
17: lambda s: float(s.strip() or -9999),
18: lambda s: float(s.strip() or -9999)},
usecols=(4,5,15,16,19,20))
h=esutil.htm.HTM()
m1,m2,d12 = h.match(data['RA'],data['DEC'],
ma[:,0],ma[:,1],4./3600.,maxmatch=1)
pmdata['PMMATCH']= 0
pmdata['RA']= data['RA']
pmdata['DEC']= data['DEC']
pmdata['PMMATCH'][m1]= 1
pmdata['PMRA'][m1]= ma[m2,2]
pmdata['PMDEC'][m1]= ma[m2,3]
pmdata['PMRA_ERR'][m1]= ma[m2,4]
pmdata['PMDEC_ERR'][m1]= ma[m2,5]
pmdata['PMMATCH'][(pmdata['PMRA'] == -9999) \
+(pmdata['PMDEC'] == -9999) \
+(pmdata['PMRA_ERR'] == -9999) \
+(pmdata['PMDEC_ERR'] == -9999)]= 0
fitsio.write(pmfile,pmdata,clobber=True)
#To make sure we're using the same format below
pmdata= fitsio.read(pmfile,1)
os.remove(posfilename)
os.remove(resultfilename)
#Match proper motions to ppmxl
data= esutil.numpy_util.add_fields(data,[('PMRA_PPMXL', numpy.float),
('PMDEC_PPMXL', numpy.float),
('PMRA_ERR_PPMXL', numpy.float),
('PMDEC_ERR_PPMXL', numpy.float),
('PMMATCH_PPMXL',numpy.int32)])
data['PMMATCH_PPMXL']= 0
h=esutil.htm.HTM()
m1,m2,d12 = h.match(pmdata['RA'],pmdata['DEC'],
data['RA'],data['DEC'],
2./3600.,maxmatch=1)
data['PMRA_PPMXL'][m2]= pmdata['PMRA'][m1]
data['PMDEC_PPMXL'][m2]= pmdata['PMDEC'][m1]
data['PMRA_ERR_PPMXL'][m2]= pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR_PPMXL'][m2]= pmdata['PMDEC_ERR'][m1]
data['PMMATCH_PPMXL'][m2]= pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx= data['PMMATCH_PPMXL'] == 1
data['PMRA_PPMXL'][True-pmindx]= -9999.99
data['PMDEC_PPMXL'][True-pmindx]= -9999.99
data['PMRA_ERR_PPMXL'][True-pmindx]= -9999.99
data['PMDEC_ERR_PPMXL'][True-pmindx]= -9999.99
#Calculate Galactocentric velocities
data= esutil.numpy_util.add_fields(data,[('GALVR_PPMXL', numpy.float),
('GALVT_PPMXL', numpy.float),
('GALVZ_PPMXL', numpy.float)])
lb= bovy_coords.radec_to_lb(data['RA'],data['DEC'],degree=True)
XYZ= bovy_coords.lbd_to_XYZ(lb[:,0],lb[:,1],data['RC_DIST'],degree=True)
pmllpmbb= bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA_PPMXL'],
data['PMDEC_PPMXL'],
data['RA'],data['DEC'],
degree=True)
vxvyvz= bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:,0],
pmllpmbb[:,1],
lb[:,0],lb[:,1],data['RC_DIST'],
degree=True)
vR, vT, vZ= bovy_coords.vxvyvz_to_galcencyl(vxvyvz[:,0],
vxvyvz[:,1],
vxvyvz[:,2],
8.-XYZ[:,0],
XYZ[:,1],
XYZ[:,2]+0.025,
vsun=[-11.1,30.24*8.,7.25])#Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR_PPMXL']= vR
data['GALVT_PPMXL']= vT
data['GALVZ_PPMXL']= vZ
data['GALVR_PPMXL'][True-pmindx]= -9999.99
data['GALVT_PPMXL'][True-pmindx]= -9999.99
data['GALVZ_PPMXL'][True-pmindx]= -9999.99
#Save
fitsio.write(savefilename,data,clobber=True)
return None
def calc_normalisation(params,
nbin,
iso_grid,
fehbin=[-0.1, 0.0],
agebin=[1., 3.],
loggcut=[1.8, 3.0],
teffcut=[4000, 5000],
type='brokenexpflare',
verbose=True,
fitIndx=None,
weights='padova',
distance_cut=False,
lowermass=None):
#first get the values necessary from the isochrone grid
#make a mask for giant stars (+ J-K cut)
if teffcut == None:
giants = (iso_grid[:, 3] >= loggcut[0]) & (
iso_grid[:, 3] < loggcut[1]) & (iso_grid[:, 5] > 0.5)
else:
giants = (iso_grid[:, 3] >= loggcut[0]) & (
iso_grid[:, 3] < loggcut[1]) & (iso_grid[:, 5] > 0.5) & (
10**iso_grid[:, 7] >= teffcut[0]) & (10**iso_grid[:, 7] <
teffcut[1])
#make a mask for the age and feh bin
if agebin == None:
bin = (10**iso_grid[:,0] >= 0.)&(10**iso_grid[:,0] < 13.)&\
(Z2FEH(iso_grid[:,1]) >= fehbin[0])&(Z2FEH(iso_grid[:,1]) < fehbin[1])
else:
bin = (10**iso_grid[:,0] >= agebin[0])&(10**iso_grid[:,0] < agebin[1])&\
(Z2FEH(iso_grid[:,1]) >= fehbin[0])&(Z2FEH(iso_grid[:,1]) < fehbin[1])
if lowermass != None:
giants *= iso_grid[:, 2] >= lowermass
bin *= iso_grid[:, 2] >= lowermass
if len(iso_grid[:, 0][bin]) < 1:
fehs = np.unique(Z2FEH(iso_grid[:, 1]))
cfehbin = fehbin[0] + ((fehbin[1] - fehbin[0]) / 2)
feh_offsets = np.fabs(fehs - cfehbin)
ind = np.argmin(feh_offsets)
cfeh = fehs[ind]
bin = (10**iso_grid[:,0] >= agebin[0])&(10**iso_grid[:,0] < agebin[1])&\
(Z2FEH(iso_grid[:,1]) == cfeh)
#find the average giant mass
mass = iso_grid[:, 2]
if weights == 'padova':
weight = iso_grid[:, 6] * (10**iso_grid[:, 0] / iso_grid[:, 1])
if weights == 'basti':
weight = iso_grid[:, 6]
av_mass = np.sum(mass[giants & bin] * weight[giants & bin]) / np.sum(
weight[giants & bin])
#find the ratio between giants and the total stellar pop. for this bin
mass_total = mass[bin]
weight_total = weight[bin]
mass_bin = mass[giants & bin]
weight_bin = weight[giants & bin]
m_ratio = np.sum(mass_bin * weight_bin) / np.sum(mass_total * weight_total)
#now compute and sum the rate for this density function
#load the raw selection function
selectFile = '../savs/selfunc-nospdata.sav'
if os.path.exists(selectFile):
with open(selectFile, 'rb') as savefile:
apo = pickle.load(savefile)
#load the effective selection function
if agebin == None:
with open(
'../essf/maps/essf_rgb_green15_modelmh_feh' +
str(round(fehbin[0], 1)) + '.sav', 'rb') as savefile:
locations = pickle.load(savefile)
effsel = pickle.load(savefile)
distmods = pickle.load(savefile)
with open(
'../essf/maps/essf_rgb_marshall06_modelmh_feh' +
str(round(fehbin[0], 1)) + '.sav', 'rb') as savefile:
mlocations = pickle.load(savefile)
meffsel = pickle.load(savefile)
mdistmods = pickle.load(savefile)
if agebin != None:
if agebin[0] < 1.:
with open(
'../essf/maps/essf_rgb_green15_modelmh_feh' +
str(round(fehbin[0], 1)) + '_age' + str(round(1.0, 1)) +
'.sav', 'rb') as savefile:
locations = pickle.load(savefile)
effsel = pickle.load(savefile)
distmods = pickle.load(savefile)
with open(
'../essf/maps/essf_rgb_marshall06_modelmh_feh' +
str(round(fehbin[0], 1)) + '_age' + str(round(1.0, 1)) +
'.sav', 'rb') as savefile:
mlocations = pickle.load(savefile)
meffsel = pickle.load(savefile)
mdistmods = pickle.load(savefile)
if agebin[0] > 0.9:
with open(
'../essf/maps/essf_rgb_green15_modelmh_feh' +
str(round(fehbin[0], 1)) + '_age' +
str(round(agebin[0], 1)) + '.sav', 'rb') as savefile:
locations = pickle.load(savefile)
effsel = pickle.load(savefile)
distmods = pickle.load(savefile)
with open(
'../essf/maps/essf_rgb_marshall06_modelmh_feh' +
str(round(fehbin[0], 1)) + '_age' +
str(round(agebin[0], 1)) + '.sav', 'rb') as savefile:
mlocations = pickle.load(savefile)
meffsel = pickle.load(savefile)
mdistmods = pickle.load(savefile)
# Fill in regions not covered by Marshall map
meffsel[meffsel < -0.5] = effsel[meffsel < -0.5]
if fitIndx is None:
fitIndx = numpy.ones(len(mlocations), dtype='bool') #True-betwDiskIndx
locations, effsel, distmods = np.array(mlocations)[fitIndx], np.array(
meffsel)[fitIndx], mdistmods
#get the density function and set it up to find the normalisation (surfdens=True)
rdensfunc = _setup_densfunc(type)
densfunc = lambda x: rdensfunc(x, None, None, params=params, surfdens=True)
#evaluate surface density at R0 for the density normalisation (always 1. if R_b > R0)
R0 = densprofiles._R0
Rb = np.exp(params[3])
dens_norm = densfunc(densprofiles._R0)
#set up the density function again with surfdens=False for the rate calculation
rdensfunc = _setup_densfunc(type)
densfunc = lambda x, y, z: rdensfunc(
x, y, z, params=params, surfdens=False)
ds = 10.**(distmods / 5. - 2.)
#imply the distance cut if distance_cut == True
if distance_cut == True:
distmods = distmods[ds <= 3.]
ds = ds[ds <= 3.]
effsel = effsel[:, :len(ds)]
#Compute the grid of R, phi and Z for each location
Rgrid, phigrid, zgrid = [], [], []
for loc in locations:
lcen, bcen = apo.glonGlat(loc)
XYZ = bovy_coords.lbd_to_XYZ(lcen * numpy.ones_like(ds),
bcen * numpy.ones_like(ds),
ds,
degree=True)
Rphiz = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2],
Xsun=define_rgbsample._R0,
Zsun=define_rgbsample._Z0)
Rgrid.append(Rphiz[:, 0])
phigrid.append(Rphiz[:, 1])
zgrid.append(Rphiz[:, 2])
Rgrid = numpy.array(Rgrid)
phigrid = numpy.array(phigrid)
zgrid = numpy.array(zgrid)
# Now compute rate(R) for each location and combine
effsel *= numpy.tile(
ds**2. * (distmods[1] - distmods[0]) * (ds * np.log(10) / 5.),
(effsel.shape[0], 1))
tdens = densfunc(Rgrid, phigrid, zgrid) / dens_norm
rate = tdens * effsel
sumrate = np.sum(rate)
#calculate normalisation N(R0)
norm = (nbin / sumrate)
#convert units (Kpc^2 > pc^2, deg > rad etc)
norm *= 1e-6 * (180 / np.pi)**2
#compute mass in bin using values from isochrones
bin_mass = (norm * av_mass) / m_ratio
if verbose == True:
print bin_mass
return bin_mass, norm, m_ratio, (av_mass * 1e-6 *
(180 / np.pi)**2) / (sumrate * m_ratio)
def predict_spacedist(params,
locations,effsel,distmods,
type='exp',
coord='Z'):
"""
NAME:
predict_spacedist
PURPOSE:
predict the spatial distribution
INPUT:
params - parameters of the density profile
locations - locations of the APOGEE effective selection function to consider
effsel - array (nloc,nD) of the effective selection function, includes area of the field
distmods - grid of distance moduli on which the effective selection function is pre-computed
type= ('exp') type of density profile to fit
coord= ('dm', 'X', or 'Z')
OUTPUT:
(R,model(R))
HISTORY:
2015-03-26 - Written - Bovy (IAS)
"""
if coord.lower() == 'x':
# Grid in X
Xs= numpy.linspace(0.,20.,301)
elif coord.lower() == 'z':
# Grid in X
Xs= numpy.linspace(0.,20.,301)
elif coord.lower() == 'dm':
# Grid in X
Xs= numpy.linspace(7.,15.5,301)
# Setup the density function
rdensfunc= _setup_densfunc(type)
densfunc= lambda x,y,z: rdensfunc(x,y,z,params=params)
# Restore the APOGEE selection function (assumed pre-computed)
selectFile= '../savs/selfunc-nospdata.sav'
if os.path.exists(selectFile):
with open(selectFile,'rb') as savefile:
apo= pickle.load(savefile)
# Now compute the necessary coordinate transformations
ds= 10.**(distmods/5-2.)
Rgrid, phigrid, zgrid, Xgrid= [], [], [], []
for loc in locations:
lcen, bcen= apo.glonGlat(loc)
XYZ= bovy_coords.lbd_to_XYZ(lcen*numpy.ones_like(ds),
bcen*numpy.ones_like(ds),
ds,
degree=True)
Rphiz= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],XYZ[:,1],XYZ[:,2],
Xsun=define_rcsample._R0,
Ysun=0.,
Zsun=define_rcsample._Z0)
Rgrid.append(Rphiz[0])
phigrid.append(Rphiz[1])
zgrid.append(Rphiz[2])
Xgrid.append(Rphiz[0]*numpy.cos(Rphiz[1]))
Rgrid= numpy.array(Rgrid)
phigrid= numpy.array(phigrid)
zgrid= numpy.array(zgrid)
Xgrid= numpy.array(Xgrid)
# Now compute rate(R) for each location and combine
effsel*= numpy.tile(ds**3.*(distmods[1]-distmods[0]),(effsel.shape[0],1))
tdens= densfunc(Rgrid,phigrid,zgrid)
rate= tdens*effsel
out= numpy.zeros((len(locations),len(Xs)))
for ii in range(len(locations)):
if coord.lower() == 'x':
# Jacobian
tjac= numpy.fabs((numpy.roll(distmods,-1)-distmods)/\
(numpy.roll(Xgrid[ii],-1)-Xgrid[ii]))
tjac[-1]= tjac[-2]
tXs= Xgrid[ii,rate[ii] > 0.]
elif coord.lower() == 'z':
# Jacobian
tjac= numpy.fabs((numpy.roll(distmods,-1)-distmods)/\
(numpy.roll(zgrid[ii],-1)-zgrid[ii]))
tjac[-1]= tjac[-2]
tXs= zgrid[ii,rate[ii] > 0.]
elif coord.lower() == 'dm':
# Jacobian
tjac= numpy.ones_like(Xs)
tXs= distmods[rate[ii] > 0.]
sindx= numpy.argsort(tXs)
tXs= tXs[sindx]
trate= rate[ii,rate[ii] > 0.][sindx]
tjac= tjac[rate[ii] > 0.][sindx]
ipthis= numpy.log(trate*tjac+10.**-8.)
baseline= numpy.polynomial.Polynomial.fit(tXs,ipthis,4)
ipthis= ipthis/baseline(tXs)
sp= interpolate.InterpolatedUnivariateSpline(tXs,ipthis,k=3)
tindx= (Xs >= numpy.amin(tXs))\
*(Xs <= numpy.amax(tXs))
out[ii,tindx]= (numpy.exp(sp(Xs[tindx])*baseline(Xs[tindx]))-10.**-8.)
out[numpy.isinf(out)]= 0.
return (Xs,out.sum(axis=0))
def _add_proper_motions_gaia(data):
from gaia_tools import xmatch
gaia2_matches, matches_indx = xmatch.cds(data,
colRA='RA',
colDec='DEC',
xcat='vizier:I/345/gaia2')
# Add matches
try: #These already exist currently, but may not always exist
data = esutil.numpy_util.remove_fields(data, ['PMRA', 'PMDEC'])
except ValueError:
pass
data = esutil.numpy_util.add_fields(data, [('PLX', numpy.float),
('PMRA', numpy.float),
('PMDEC', numpy.float),
('PLX_ERR', numpy.float),
('PMRA_ERR', numpy.float),
('PMDEC_ERR', numpy.float),
('PMMATCH', numpy.int32)])
data['PMMATCH'] = 0
data['PMMATCH'][matches_indx] = 1
data['PLX'][matches_indx] = gaia2_matches['parallax']
data['PMRA'][matches_indx] = gaia2_matches['pmra']
data['PMDEC'][matches_indx] = gaia2_matches['pmdec']
data['PLX_ERR'][matches_indx] = gaia2_matches['parallax_error']
data['PMRA_ERR'][matches_indx] = gaia2_matches['pmra_error']
data['PMDEC_ERR'][matches_indx] = gaia2_matches['pmdec_error']
# Set values for those without match to -999
pmindx = data['PMMATCH'] == 1
data['PLX'][True ^ pmindx] = -9999.99
data['PMRA'][True ^ pmindx] = -9999.99
data['PMDEC'][True ^ pmindx] = -9999.99
data['PLX_ERR'][True ^ pmindx] = -9999.99
data['PMRA_ERR'][True ^ pmindx] = -9999.99
data['PMDEC_ERR'][True ^ pmindx] = -9999.99
#Calculate Galactocentric velocities
data = esutil.numpy_util.add_fields(data, [('GALVR', numpy.float),
('GALVT', numpy.float),
('GALVZ', numpy.float)])
lb = bovy_coords.radec_to_lb(data['RA'], data['DEC'], degree=True)
XYZ = bovy_coords.lbd_to_XYZ(lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
pmllpmbb = bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA'],
data['PMDEC'],
data['RA'],
data['DEC'],
degree=True)
vxvyvz = bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:, 0],
pmllpmbb[:, 1],
lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
vRvTvZ = bovy_coords.vxvyvz_to_galcencyl(
vxvyvz[:, 0],
vxvyvz[:, 1],
vxvyvz[:, 2],
8. - XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2] + 0.0208,
vsun=[-11.1, 30.24 * 8.15, 7.25]
) #Assumes proper motion of Sgr A* and R0=8.15 kpc, zo= 20.8 pc (Bennett & Bovy 2019)
data['GALVR'] = vRvTvZ[:, 0]
data['GALVT'] = vRvTvZ[:, 1]
data['GALVZ'] = vRvTvZ[:, 2]
data['GALVR'][True ^ pmindx] = -9999.99
data['GALVT'][True ^ pmindx] = -9999.99
data['GALVZ'][True ^ pmindx] = -9999.99
return data
def fakeDFData(binned,qdf,ii,params,fehs,afes,options,
rmin,rmax,
platelb,
grmin,grmax,
fehrange,
colordist,
fehdist,feh,sf,
mapfehs,mapafes,
ro=None,vo=None,
ndata=None,#If set, supersedes binned, only to be used w/ returnlist=True
returnlist=False): #last one useful for pixelFitDF normintstuff
if ro is None:
ro= get_ro(params,options)
if vo is None:
vo= get_vo(params,options,len(fehs))
thishr= qdf.estimate_hr(1.,z=0.125)*_REFR0*ro #qdf._hr*_REFR0*ro
thishz= qdf.estimate_hz(1.,z=0.125)*_REFR0*ro
if thishr < 0.: thishr= 10. #Probably close to flat
if thishz < 0.1: thishz= 0.2
thissr= qdf._sr*_REFV0*vo
thissz= qdf._sz*_REFV0*vo
thishsr= qdf._hsr*_REFR0*ro
thishsz= qdf._hsz*_REFR0*ro
if True:
if options.aAmethod.lower() == 'staeckel':
#Make everything 10% larger
thishr*= 1.2
thishz*= 1.2
thishsr*= 1.2
thishsz*= 1.2
thissr*= 2.
thissz*= 2.
else:
#Make everything 20% larger
thishr*= 1.2
thishz*= 1.2
thishsr*= 1.2
thishsz*= 1.2
thissr*= 2.
thissz*= 2.
#Find nearest mono-abundance bin that has a measurement
abindx= numpy.argmin((fehs[ii]-mapfehs)**2./0.01 \
+(afes[ii]-mapafes)**2./0.0025)
#Calculate the r-distribution for each plate
nrs= 1001
ngr, nfeh= 11, 11 #BOVY: INCREASE?
tgrs= numpy.linspace(grmin,grmax,ngr)
tfehs= numpy.linspace(fehrange[0]+0.00001,fehrange[1]-0.00001,nfeh)
#Calcuate FeH and gr distriutions
fehdists= numpy.zeros(nfeh)
for jj in range(nfeh): fehdists[jj]= fehdist(tfehs[jj])
fehdists= numpy.cumsum(fehdists)
fehdists/= fehdists[-1]
colordists= numpy.zeros(ngr)
for jj in range(ngr): colordists[jj]= colordist(tgrs[jj])
colordists= numpy.cumsum(colordists)
colordists/= colordists[-1]
rs= numpy.linspace(rmin,rmax,nrs)
rdists= numpy.zeros((len(sf.plates),nrs,ngr,nfeh))
#outlier model that we want to sample (not the one to aid in the sampling)
srhalo= _SRHALO/vo/_REFV0
sphihalo= _SPHIHALO/vo/_REFV0
szhalo= _SZHALO/vo/_REFV0
logoutfrac= numpy.log(get_outfrac(params,ii,options))
loghalodens= numpy.log(ro*outDens(1.,0.,None))
#Calculate surface(R=1.) for relative outlier normalization
logoutfrac+= numpy.log(qdf.surfacemass_z(1.,ngl=options.ngl))
if options.mcout:
fidoutfrac= get_outfrac(params,ii,options)
rdistsout= numpy.zeros((len(sf.plates),nrs,ngr,nfeh))
lagoutfrac= 0.15 #.0000000000000000000000001 #seems good
#Setup density model
use_real_dens= True
if use_real_dens:
#nrs, nzs= 101, 101
nrs, nzs= 64, 64
thisRmin, thisRmax= 4./_REFR0, 15./_REFR0
thiszmin, thiszmax= 0., .8
Rgrid= numpy.linspace(thisRmin,thisRmax,nrs)
zgrid= numpy.linspace(thiszmin,thiszmax,nzs)
surfgrid= numpy.empty((nrs,nzs))
for ll in range(nrs):
for jj in range(nzs):
sys.stdout.write('\r'+"Working on grid-point %i/%i" % (jj+ll*nzs+1,nzs*nrs))
sys.stdout.flush()
surfgrid[ll,jj]= qdf.density(Rgrid[ll],zgrid[jj],
nmc=options.nmcv,
ngl=options.ngl)
sys.stdout.write('\r'+_ERASESTR+'\r')
sys.stdout.flush()
if _SURFSUBTRACTEXPON:
Rs= numpy.tile(Rgrid,(nzs,1)).T
Zs= numpy.tile(zgrid,(nrs,1))
ehr= qdf.estimate_hr(1.,z=0.125)
# ehz= qdf.estimate_hz(1.,zmin=0.5,zmax=0.7)#Get large z behavior right
ehz= qdf.estimate_hz(1.,z=0.125)
surfInterp= interpolate.RectBivariateSpline(Rgrid,zgrid,
numpy.log(surfgrid)
+Rs/ehr+numpy.fabs(Zs)/ehz,
kx=3,ky=3,
s=0.)
# s=10.*float(nzs*nrs))
else:
surfInterp= interpolate.RectBivariateSpline(Rgrid,zgrid,
numpy.log(surfgrid),
kx=3,ky=3,
s=0.)
# s=10.*float(nzs*nrs))
if _SURFSUBTRACTEXPON:
compare_func= lambda x,y,du: numpy.exp(surfInterp.ev(x/ro/_REFR0,numpy.fabs(y)/ro/_REFR0)-x/ro/_REFR0/ehr-numpy.fabs(y)/ehz/ro/_REFR0)
else:
compare_func= lambda x,y,du: numpy.exp(surfInterp.ev(x/ro/_REFR0,numpy.fabs(y)/ro/_REFR0))
else:
compare_func= lambda x,y,z: fidDens(x,y,thishr,thishz,z)
for jj in range(len(sf.plates)):
p= sf.plates[jj]
sys.stdout.write('\r'+"Working on plate %i (%i/%i)" % (p,jj+1,len(sf.plates)))
sys.stdout.flush()
rdists[jj,:,:,:]= _predict_rdist_plate(rs,
compare_func,
None,rmin,rmax,
platelb[jj,0],platelb[jj,1],
grmin,grmax,
fehrange[0],fehrange[1],feh,
colordist,
fehdist,sf,sf.plates[jj],
dontmarginalizecolorfeh=True,
ngr=ngr,nfeh=nfeh)
if options.mcout:
rdistsout[jj,:,:,:]= _predict_rdist_plate(rs,
lambda x,y,z: outDens(x,y,z),
None,rmin,rmax,
platelb[jj,0],platelb[jj,1],
grmin,grmax,
fehrange[0],fehrange[1],feh,
colordist,
fehdist,sf,sf.plates[jj],
dontmarginalizecolorfeh=True,
ngr=ngr,nfeh=nfeh)
sys.stdout.write('\r'+_ERASESTR+'\r')
sys.stdout.flush()
numbers= numpy.sum(rdists,axis=3)
numbers= numpy.sum(numbers,axis=2)
numbers= numpy.sum(numbers,axis=1)
numbers= numpy.cumsum(numbers)
if options.mcout:
totfid= numbers[-1]
numbers/= numbers[-1]
rdists= numpy.cumsum(rdists,axis=1)
for ll in range(len(sf.plates)):
for jj in range(ngr):
for kk in range(nfeh):
rdists[ll,:,jj,kk]/= rdists[ll,-1,jj,kk]
if options.mcout:
numbersout= numpy.sum(rdistsout,axis=3)
numbersout= numpy.sum(numbersout,axis=2)
numbersout= numpy.sum(numbersout,axis=1)
numbersout= numpy.cumsum(numbersout)
totout= fidoutfrac*numbersout[-1]
totnumbers= totfid+totout
totfid/= totnumbers
totout/= totnumbers
if _DEBUG:
print totfid, totout
numbersout/= numbersout[-1]
rdistsout= numpy.cumsum(rdistsout,axis=1)
for ll in range(len(sf.plates)):
for jj in range(ngr):
for kk in range(nfeh):
rdistsout[ll,:,jj,kk]/= rdistsout[ll,-1,jj,kk]
#Now sample
thisout= []
newrs= []
newls= []
newbs= []
newplate= []
newgr= []
newfeh= []
newds= []
newzs= []
newvas= []
newRs= []
newphi= []
newvr= []
newvt= []
newvz= []
newlogratio= []
newfideval= []
newqdfeval= []
newpropeval= []
if ndata is None:
thisdata= binned(fehs[ii],afes[ii])
thisdataIndx= binned.callIndx(fehs[ii],afes[ii])
ndata= len(thisdata)
#First sample from spatial density
for ll in range(ndata):
#First sample a plate
ran= numpy.random.uniform()
kk= 0
while numbers[kk] < ran: kk+= 1
#Also sample a FeH and a color
ran= numpy.random.uniform()
ff= 0
while fehdists[ff] < ran: ff+= 1
ran= numpy.random.uniform()
cc= 0
while colordists[cc] < ran: cc+= 1
#plate==kk, feh=ff,color=cc; now sample from the rdist of this plate
ran= numpy.random.uniform()
jj= 0
if options.mcout and numpy.random.uniform() < totout: #outlier
while rdistsout[kk,jj,cc,ff] < ran: jj+= 1
thisoutlier= True
else:
while rdists[kk,jj,cc,ff] < ran: jj+= 1
thisoutlier= False
#r=jj
newrs.append(rs[jj])
newls.append(platelb[kk,0])
newbs.append(platelb[kk,1])
newplate.append(sf.plates[kk])
newgr.append(tgrs[cc])
newfeh.append(tfehs[ff])
dist= _ivezic_dist(tgrs[cc],rs[jj],tfehs[ff])
newds.append(dist)
#calculate R,z
XYZ= bovy_coords.lbd_to_XYZ(platelb[kk,0],platelb[kk,1],
dist,degree=True)
R= ((_REFR0-XYZ[0])**2.+XYZ[1]**2.)**(0.5)
newRs.append(R)
phi= numpy.arcsin(XYZ[1]/R)
if (_REFR0-XYZ[0]) < 0.:
phi= numpy.pi-phi
newphi.append(phi)
z= XYZ[2]+_ZSUN
newzs.append(z)
newrs= numpy.array(newrs)
newls= numpy.array(newls)
newbs= numpy.array(newbs)
newplate= numpy.array(newplate)
newgr= numpy.array(newgr)
newfeh= numpy.array(newfeh)
newds= numpy.array(newds)
newRs= numpy.array(newRs)
newzs= numpy.array(newzs)
newphi= numpy.array(newphi)
#Add mock velocities
newvr= numpy.empty_like(newrs)
newvt= numpy.empty_like(newrs)
newvz= numpy.empty_like(newrs)
use_sampleV= True
if use_sampleV:
for kk in range(ndata):
newv= qdf.sampleV(newRs[kk]/_REFR0,newzs[kk]/_REFR0,n=1)
newvr[kk]= newv[0,0]*_REFV0*vo
newvt[kk]= newv[0,1]*_REFV0*vo
newvz[kk]= newv[0,2]*_REFV0*vo
else:
accept_v= numpy.zeros(ndata,dtype='bool')
naccept= numpy.sum(accept_v)
sigz= thissz*numpy.exp(-(newRs-_REFR0)/thishsz)
sigr= thissr*numpy.exp(-(newRs-_REFR0)/thishsr)
va= numpy.empty_like(newrs)
sigphi= numpy.empty_like(newrs)
maxqdf= numpy.empty_like(newrs)
nvt= 101
tvt= numpy.linspace(0.1,1.2,nvt)
for kk in range(ndata):
#evaluate qdf for vt
pvt= qdf(newRs[kk]/ro/_REFR0+numpy.zeros(nvt),
numpy.zeros(nvt),
tvt,
newzs[kk]/ro/_REFR0+numpy.zeros(nvt),
numpy.zeros(nvt),log=True)
pvt_maxindx= numpy.argmax(pvt)
va[kk]= (1.-tvt[pvt_maxindx])*_REFV0*vo
if options.aAmethod.lower() == 'adiabaticgrid' and options.flatten >= 0.9:
maxqdf[kk]= pvt[pvt_maxindx]+numpy.log(250.)
elif options.aAmethod.lower() == 'adiabaticgrid' and options.flatten >= 0.8:
maxqdf[kk]= pvt[pvt_maxindx]+numpy.log(250.)
else:
maxqdf[kk]= pvt[pvt_maxindx]+numpy.log(40.)
sigphi[kk]= _REFV0*vo*4.*numpy.sqrt(numpy.sum(numpy.exp(pvt)*tvt**2.)/numpy.sum(numpy.exp(pvt))-(numpy.sum(numpy.exp(pvt)*tvt)/numpy.sum(numpy.exp(pvt)))**2.)
ntries= 0
ngtr1= 0
while naccept < ndata:
sys.stdout.write('\r %i %i %i \r' % (ntries,naccept,ndata))
sys.stdout.flush()
#print ntries, naccept, ndata
ntries+= 1
accept_v_comp= True-accept_v
prop_vr= numpy.random.normal(size=ndata)*sigr
prop_vt= numpy.random.normal(size=ndata)*sigphi+vo*_REFV0-va
prop_vz= numpy.random.normal(size=ndata)*sigz
qoverp= numpy.zeros(ndata)-numpy.finfo(numpy.dtype(numpy.float64)).max
qoverp[accept_v_comp]= (qdf(newRs[accept_v_comp]/ro/_REFR0,
prop_vr[accept_v_comp]/vo/_REFV0,
prop_vt[accept_v_comp]/vo/_REFV0,
newzs[accept_v_comp]/ro/_REFR0,
prop_vz[accept_v_comp]/vo/_REFV0,log=True)
-maxqdf[accept_v_comp] #normalize max to 1
-(-0.5*(prop_vr[accept_v_comp]**2./sigr[accept_v_comp]**2.+prop_vz[accept_v_comp]**2./sigz[accept_v_comp]**2.+(prop_vt[accept_v_comp]-_REFV0*vo+va[accept_v_comp])**2./sigphi[accept_v_comp]**2.)))
if numpy.any(qoverp > 0.):
ngtr1+= numpy.sum((qoverp > 0.))
if ngtr1 > 5:
qindx= (qoverp > 0.)
print naccept, ndata, newRs[qindx], newzs[qindx], prop_vr[qindx], va[qindx], sigphi[qindx], prop_vt[qindx], prop_vz[qindx], qoverp[qindx]
raise RuntimeError("max qoverp = %f > 1, but shouldn't be" % (numpy.exp(numpy.amax(qoverp))))
accept_these= numpy.log(numpy.random.uniform(size=ndata))
#print accept_these, (accept_these < qoverp)
accept_these= (accept_these < qoverp)
newvr[accept_these]= prop_vr[accept_these]
newvt[accept_these]= prop_vt[accept_these]
newvz[accept_these]= prop_vz[accept_these]
accept_v[accept_these]= True
naccept= numpy.sum(accept_v)
sys.stdout.write('\r'+_ERASESTR+'\r')
sys.stdout.flush()
"""
ntot= 0
nsamples= 0
itt= 0
fracsuccess= 0.
fraccomplete= 0.
while fraccomplete < 1.:
if itt == 0:
nthis= numpy.amax([ndata,_NMIN])
else:
nthis= int(numpy.ceil((1-fraccomplete)/fracsuccess*ndata))
itt+= 1
count= 0
while count < nthis:
count+= 1
sigz= thissz*numpy.exp(-(R-_REFR0)/thishsz)
sigr= thissr*numpy.exp(-(R-_REFR0)/thishsr)
sigphi= sigr #/numpy.sqrt(2.) #BOVY: FOR NOW
#Estimate asymmetric drift
va= sigr**2./2./_REFV0/vo\
*(-.5+R*(1./thishr+2./thishsr))+10.*numpy.fabs(z)
newvas.append(va)
if options.mcout and thisoutlier:
#Sample from outlier gaussian
newvz.append(numpy.random.normal()*_SZHALOFAKE*2.)
newvr.append(numpy.random.normal()*_SRHALOFAKE*2.)
newvt.append(numpy.random.normal()*_SPHIHALOFAKE*2.)
elif numpy.random.uniform() < lagoutfrac:
#Sample from lagging gaussian
newvz.append(numpy.random.normal()*_SZHALOFAKE)
newvr.append(numpy.random.normal()*_SRHALOFAKE)
newvt.append(numpy.random.normal()*_SPHIHALOFAKE*2.+_REFV0*vo/4.)
else:
#Sample from disk gaussian
newvz.append(numpy.random.normal()*sigz)
newvr.append(numpy.random.normal()*sigr)
newvt.append(numpy.random.normal()*sigphi+_REFV0*vo-va)
newlogratio= list(newlogratio)
fidlogeval= numpy.log(1.-lagoutfrac)\
-numpy.log(sigr)-numpy.log(sigphi)-numpy.log(sigz)-0.5*(newvr[-1]**2./sigr**2.+newvz[-1]**2./sigz**2.+(newvt[-1]-_REFV0*vo+va)**2./sigphi**2.)
lagoutlogeval= numpy.log(lagoutfrac)\
-numpy.log(_SRHALOFAKE)\
-numpy.log(_SPHIHALOFAKE*2.)\
-numpy.log(_SZHALOFAKE)\
-0.5*(newvr[-1]**2./_SRHALOFAKE**2.+newvz[-1]**2./_SZHALOFAKE**2.+(newvt[-1]-_REFV0*vo/4.)**2./_SPHIHALOFAKE**2./4.)
if use_real_dens:
fidlogeval+= numpy.log(compare_func(R,z,None)[0])
lagoutlogeval+= numpy.log(compare_func(R,z,None)[0])
else:
fidlogeval+= numpy.log(fidDens(R,z,thishr,thishz,None))
lagoutlogeval+= numpy.log(fidDens(R,z,thishr,thishz,None))
newfideval.append(fidlogeval)
if options.mcout:
fidoutlogeval= numpy.log(fidoutfrac)\
+numpy.log(outDens(R,z,None))\
-numpy.log(_SRHALOFAKE*2.)\
-numpy.log(_SPHIHALOFAKE*2.)\
-numpy.log(_SZHALOFAKE*2.)\
-0.5*(newvr[-1]**2./_SRHALOFAKE**2./4.+newvz[-1]**2./_SZHALOFAKE**2./4.+newvt[-1]**2./_SPHIHALOFAKE**2./4.)
newpropeval.append(logsumexp([fidoutlogeval,fidlogeval,
lagoutlogeval]))
else:
newpropeval.append(logsumexp([lagoutlogeval,fidlogeval]))
qdflogeval= qdf(R/ro/_REFR0,newvr[-1]/vo/_REFV0,newvt[-1]/vo/_REFV0,z/ro/_REFR0,newvz[-1]/vo/_REFV0,log=True)
if isinstance(qdflogeval,(list,numpy.ndarray)):
qdflogeval= qdflogeval[0]
if options.mcout:
outlogeval= logoutfrac+loghalodens\
-numpy.log(srhalo)-numpy.log(sphihalo)-numpy.log(szhalo)\
-0.5*((newvr[-1]/vo/_REFV0)**2./srhalo**2.+(newvz[-1]/vo/_REFV0)**2./szhalo**2.+(newvt[-1]/vo/_REFV0)**2./sphihalo**2.)\
-1.5*numpy.log(2.*numpy.pi)
newqdfeval.append(logsumexp([qdflogeval,outlogeval]))
else:
newqdfeval.append(qdflogeval)
newlogratio.append(qdflogeval
-newpropeval[-1])#logsumexp([fidlogeval,fidoutlogeval]))
newlogratio= numpy.array(newlogratio)
thisnewlogratio= copy.copy(newlogratio)
maxnewlogratio= numpy.amax(thisnewlogratio)
if False:
argsort_thisnewlogratio= numpy.argsort(thisnewlogratio)[::-1]
thisnewlogratio-= thisnewlogratio[argsort_thisnewlogratio[2]] #3rd largest
else:
thisnewlogratio-= numpy.amax(thisnewlogratio)
thisnewratio= numpy.exp(thisnewlogratio)
if len(thisnewratio.shape) > 1 and thisnewratio.shape[1] == 1:
thisnewratio= numpy.reshape(thisnewratio,(thisnewratio.shape[0]))
#Rejection sample
accept= numpy.random.uniform(size=len(thisnewratio))
accept= (accept < thisnewratio)
fraccomplete= float(numpy.sum(accept))/ndata
fracsuccess= float(numpy.sum(accept))/len(thisnewratio)
if _DEBUG:
print fraccomplete, fracsuccess, ndata
print numpy.histogram(thisnewratio,bins=16)
indx= numpy.argmax(thisnewratio)
print numpy.array(newvr)[indx], \
numpy.array(newvt)[indx], \
numpy.array(newvz)[indx], \
numpy.array(newrs)[indx], \
numpy.array(newds)[indx], \
numpy.array(newls)[indx], \
numpy.array(newbs)[indx], \
numpy.array(newfideval)[indx]
bovy_plot.bovy_print()
bovy_plot.bovy_plot(numpy.array(newvt),
numpy.exp(numpy.array(newqdfeval)),'b,',
xrange=[-300.,500.],yrange=[0.,1.])
bovy_plot.bovy_plot(newvt,
numpy.exp(numpy.array(newpropeval+maxnewlogratio)),
'g,',
overplot=True)
bovy_plot.bovy_plot(numpy.array(newvt),
numpy.exp(numpy.array(newlogratio-maxnewlogratio)),
'b,',
xrange=[-300.,500.],
# xrange=[0.,20.],
# xrange=[0.,3.],
# xrange=[6.,9.],
yrange=[0.001,1.],semilogy=True)
bovy_plot.bovy_end_print('/home/bovy/public_html/segue-local/test.png')
#Now collect the samples
newrs= numpy.array(newrs)[accept][0:ndata]
newls= numpy.array(newls)[accept][0:ndata]
newbs= numpy.array(newbs)[accept][0:ndata]
newplate= numpy.array(newplate)[accept][0:ndata]
newgr= numpy.array(newgr)[accept][0:ndata]
newfeh= numpy.array(newfeh)[accept][0:ndata]
newvr= numpy.array(newvr)[accept][0:ndata]
newvt= numpy.array(newvt)[accept][0:ndata]
newvz= numpy.array(newvz)[accept][0:ndata]
newphi= numpy.array(newphi)[accept][0:ndata]
newds= numpy.array(newds)[accept][0:ndata]
newqdfeval= numpy.array(newqdfeval)[accept][0:ndata]
"""
vx, vy, vz= bovy_coords.galcencyl_to_vxvyvz(newvr,newvt,newvz,newphi,
vsun=[_VRSUN,_VTSUN,_VZSUN])
vrpmllpmbb= bovy_coords.vxvyvz_to_vrpmllpmbb(vx,vy,vz,newls,newbs,newds,
XYZ=False,degree=True)
pmrapmdec= bovy_coords.pmllpmbb_to_pmrapmdec(vrpmllpmbb[:,1],
vrpmllpmbb[:,2],
newls,newbs,
degree=True)
#Dump everything for debugging the coordinate transformation
from galpy.util import save_pickles
save_pickles('dump.sav',
newds,newls,newbs,newphi,
newvr,newvt,newvz,
vx, vy, vz,
vrpmllpmbb,
pmrapmdec)
if returnlist:
out= []
for ii in range(ndata):
out.append([newrs[ii],
newgr[ii],
newfeh[ii],
newls[ii],
newbs[ii],
newplate[ii],
newds[ii],
False, #outlier?
vrpmllpmbb[ii,0],
vrpmllpmbb[ii,1],
vrpmllpmbb[ii,2]])#,
# newqdfeval[ii]])
return out
#Load into data
binned.data.feh[thisdataIndx]= newfeh
oldgr= thisdata.dered_g-thisdata.dered_r
oldr= thisdata.dered_r
if options.noerrs:
binned.data.dered_r[thisdataIndx]= newrs
else:
binned.data.dered_r[thisdataIndx]= newrs\
+numpy.random.normal(size=numpy.sum(thisdataIndx))\
*ivezic_dist_gr(oldgr,0., #g-r is all that counts
binned.data.feh[thisdataIndx],
dg=binned.data[thisdataIndx].g_err,
dr=binned.data[thisdataIndx].r_err,
dfeh=binned.data[thisdataIndx].feh_err,
return_error=True,
_returndmr=True)
binned.data.dered_r[(binned.data.dered_r >= rmax)]= rmax #tweak to make sure everything stays within the observed range
if False:
binned.data.dered_r[(binned.data.dered_r <= rmin)]= rmin
binned.data.dered_g[thisdataIndx]= oldgr+binned.data[thisdataIndx].dered_r
#Also change plate and l and b
binned.data.plate[thisdataIndx]= newplate
radec= bovy_coords.lb_to_radec(newls,newbs,degree=True)
binned.data.ra[thisdataIndx]= radec[:,0]
binned.data.dec[thisdataIndx]= radec[:,1]
binned.data.l[thisdataIndx]= newls
binned.data.b[thisdataIndx]= newbs
if options.noerrs:
binned.data.vr[thisdataIndx]= vrpmllpmbb[:,0]
binned.data.pmra[thisdataIndx]= pmrapmdec[:,0]
binned.data.pmdec[thisdataIndx]= pmrapmdec[:,1]
else:
binned.data.vr[thisdataIndx]= vrpmllpmbb[:,0]+numpy.random.normal(size=numpy.sum(thisdataIndx))*binned.data.vr_err[thisdataIndx]
binned.data.pmra[thisdataIndx]= pmrapmdec[:,0]+numpy.random.normal(size=numpy.sum(thisdataIndx))*binned.data.pmra_err[thisdataIndx]
binned.data.pmdec[thisdataIndx]= pmrapmdec[:,1]+numpy.random.normal(size=numpy.sum(thisdataIndx))*binned.data.pmdec_err[thisdataIndx]
return binned
def _add_proper_motions_pregaia(data, savefilename):
#Get proper motions, in a somewhat roundabout way
pmfile = savefilename.split('.')[0] + '_pms.fits'
if os.path.exists(pmfile):
pmdata = fitsread(pmfile, 1)
else:
pmdata = numpy.recarray(
len(data),
formats=['f8', 'f8', 'f8', 'f8', 'f8', 'f8', 'i4'],
names=[
'RA', 'DEC', 'PMRA', 'PMDEC', 'PMRA_ERR', 'PMDEC_ERR',
'PMMATCH'
])
# Write positions, again ...
posfilename = tempfile.mktemp('.csv', dir=os.getcwd())
resultfilename = tempfile.mktemp('.csv', dir=os.getcwd())
with open(posfilename, 'w') as csvfile:
wr = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA', 'DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'], data[ii]['DEC']])
# Send to CDS for matching
result = open(resultfilename, 'w')
try:
subprocess.check_call([
'curl', '-X', 'POST', '-F', 'request=xmatch', '-F',
'distMaxArcsec=4', '-F', 'RESPONSEFORMAT=csv', '-F',
'cat1=@%s' % os.path.basename(posfilename), '-F', 'colRA1=RA',
'-F', 'colDec1=DEC', '-F', 'cat2=vizier:UCAC4',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'
],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Match back and only keep the closest one
ma = numpy.loadtxt(resultfilename,
delimiter=',',
skiprows=1,
converters={
15: lambda s: float(s.strip() or -9999),
16: lambda s: float(s.strip() or -9999),
17: lambda s: float(s.strip() or -9999),
18: lambda s: float(s.strip() or -9999)
},
usecols=(4, 5, 15, 16, 17, 18))
h = esutil.htm.HTM()
m1, m2, d12 = h.match(data['RA'],
data['DEC'],
ma[:, 0],
ma[:, 1],
4. / 3600.,
maxmatch=1)
pmdata['PMMATCH'] = 0
pmdata['RA'] = data['RA']
pmdata['DEC'] = data['DEC']
pmdata['PMMATCH'][m1] = 1
pmdata['PMRA'][m1] = ma[m2, 2]
pmdata['PMDEC'][m1] = ma[m2, 3]
pmdata['PMRA_ERR'][m1] = ma[m2, 4]
pmdata['PMDEC_ERR'][m1] = ma[m2, 5]
pmdata['PMMATCH'][(pmdata['PMRA'] == -9999) \
+(pmdata['PMDEC'] == -9999) \
+(pmdata['PMRA_ERR'] == -9999) \
+(pmdata['PMDEC_ERR'] == -9999)]= 0
fitswrite(pmfile, pmdata, clobber=True)
#To make sure we're using the same format below
pmdata = fitsread(pmfile, 1)
os.remove(posfilename)
os.remove(resultfilename)
#Match proper motions
try: #These already exist currently, but may not always exist
data = esutil.numpy_util.remove_fields(data, ['PMRA', 'PMDEC'])
except ValueError:
pass
data = esutil.numpy_util.add_fields(data, [('PMRA', numpy.float),
('PMDEC', numpy.float),
('PMRA_ERR', numpy.float),
('PMDEC_ERR', numpy.float),
('PMMATCH', numpy.int32)])
data['PMMATCH'] = 0
h = esutil.htm.HTM()
m1, m2, d12 = h.match(pmdata['RA'],
pmdata['DEC'],
data['RA'],
data['DEC'],
2. / 3600.,
maxmatch=1)
data['PMRA'][m2] = pmdata['PMRA'][m1]
data['PMDEC'][m2] = pmdata['PMDEC'][m1]
data['PMRA_ERR'][m2] = pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR'][m2] = pmdata['PMDEC_ERR'][m1]
data['PMMATCH'][m2] = pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx = data['PMMATCH'] == 1
data['PMRA'][True ^ pmindx] = -9999.99
data['PMDEC'][True ^ pmindx] = -9999.99
data['PMRA_ERR'][True ^ pmindx] = -9999.99
data['PMDEC_ERR'][True ^ pmindx] = -9999.99
#Calculate Galactocentric velocities
data = esutil.numpy_util.add_fields(data, [('GALVR', numpy.float),
('GALVT', numpy.float),
('GALVZ', numpy.float)])
lb = bovy_coords.radec_to_lb(data['RA'], data['DEC'], degree=True)
XYZ = bovy_coords.lbd_to_XYZ(lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
pmllpmbb = bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA'],
data['PMDEC'],
data['RA'],
data['DEC'],
degree=True)
vxvyvz = bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:, 0],
pmllpmbb[:, 1],
lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
vRvTvZ = bovy_coords.vxvyvz_to_galcencyl(
vxvyvz[:, 0],
vxvyvz[:, 1],
vxvyvz[:, 2],
8. - XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2] + 0.025,
vsun=[-11.1, 30.24 * 8.,
7.25]) #Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR'] = vRvTvZ[:, 0]
data['GALVT'] = vRvTvZ[:, 1]
data['GALVZ'] = vRvTvZ[:, 2]
data['GALVR'][True ^ pmindx] = -9999.99
data['GALVT'][True ^ pmindx] = -9999.99
data['GALVZ'][True ^ pmindx] = -9999.99
#Get HSOY proper motions, in a somewhat roundabout way
pmfile = savefilename.split('.')[0] + '_pms_ppmxl.fits'
if os.path.exists(pmfile):
pmdata = fitsread(pmfile, 1)
else:
pmdata = numpy.recarray(
len(data),
formats=['f8', 'f8', 'f8', 'f8', 'f8', 'f8', 'i4'],
names=[
'RA', 'DEC', 'PMRA', 'PMDEC', 'PMRA_ERR', 'PMDEC_ERR',
'PMMATCH'
])
# Write positions, again ...
posfilename = tempfile.mktemp('.csv', dir=os.getcwd())
resultfilename = tempfile.mktemp('.csv', dir=os.getcwd())
with open(posfilename, 'w') as csvfile:
wr = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA', 'DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'], data[ii]['DEC']])
# Send to CDS for matching
result = open(resultfilename, 'w')
try:
subprocess.check_call([
'curl', '-X', 'POST', '-F', 'request=xmatch', '-F',
'distMaxArcsec=4', '-F', 'RESPONSEFORMAT=csv', '-F',
'cat1=@%s' % os.path.basename(posfilename), '-F', 'colRA1=RA',
'-F', 'colDec1=DEC', '-F', 'cat2=vizier:I/339/hsoy',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'
],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Match back and only keep the closest one
ma = numpy.loadtxt(resultfilename,
delimiter=',',
skiprows=1,
converters={
12: lambda s: float(s.strip() or -9999),
13: lambda s: float(s.strip() or -9999),
14: lambda s: float(s.strip() or -9999),
15: lambda s: float(s.strip() or -9999)
},
usecols=(3, 4, 12, 13, 14, 15))
h = esutil.htm.HTM()
m1, m2, d12 = h.match(data['RA'],
data['DEC'],
ma[:, 0],
ma[:, 1],
4. / 3600.,
maxmatch=1)
pmdata['PMMATCH'] = 0
pmdata['RA'] = data['RA']
pmdata['DEC'] = data['DEC']
pmdata['PMMATCH'][m1] = 1
pmdata['PMRA'][m1] = ma[m2, 2]
pmdata['PMDEC'][m1] = ma[m2, 3]
pmdata['PMRA_ERR'][m1] = ma[m2, 4]
pmdata['PMDEC_ERR'][m1] = ma[m2, 5]
pmdata['PMMATCH'][(pmdata['PMRA'] == -9999) \
+(pmdata['PMDEC'] == -9999) \
+(pmdata['PMRA_ERR'] == -9999) \
+(pmdata['PMDEC_ERR'] == -9999)]= 0
fitswrite(pmfile, pmdata, clobber=True)
#To make sure we're using the same format below
pmdata = fitsread(pmfile, 1)
os.remove(posfilename)
os.remove(resultfilename)
#Match proper motions to ppmxl/HSOY
data = esutil.numpy_util.add_fields(data, [('PMRA_HSOY', numpy.float),
('PMDEC_HSOY', numpy.float),
('PMRA_ERR_HSOY', numpy.float),
('PMDEC_ERR_HSOY', numpy.float),
('PMMATCH_HSOY', numpy.int32)])
data['PMMATCH_HSOY'] = 0
h = esutil.htm.HTM()
m1, m2, d12 = h.match(pmdata['RA'],
pmdata['DEC'],
data['RA'],
data['DEC'],
2. / 3600.,
maxmatch=1)
data['PMRA_HSOY'][m2] = pmdata['PMRA'][m1]
data['PMDEC_HSOY'][m2] = pmdata['PMDEC'][m1]
data['PMRA_ERR_HSOY'][m2] = pmdata['PMRA_ERR'][m1]
data['PMDEC_ERR_HSOY'][m2] = pmdata['PMDEC_ERR'][m1]
data['PMMATCH_HSOY'][m2] = pmdata['PMMATCH'][m1].astype(numpy.int32)
pmindx = data['PMMATCH_HSOY'] == 1
data['PMRA_HSOY'][True ^ pmindx] = -9999.99
data['PMDEC_HSOY'][True ^ pmindx] = -9999.99
data['PMRA_ERR_HSOY'][True ^ pmindx] = -9999.99
data['PMDEC_ERR_HSOY'][True ^ pmindx] = -9999.99
#Calculate Galactocentric velocities
data = esutil.numpy_util.add_fields(data, [('GALVR_HSOY', numpy.float),
('GALVT_HSOY', numpy.float),
('GALVZ_HSOY', numpy.float)])
lb = bovy_coords.radec_to_lb(data['RA'], data['DEC'], degree=True)
XYZ = bovy_coords.lbd_to_XYZ(lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
pmllpmbb = bovy_coords.pmrapmdec_to_pmllpmbb(data['PMRA_HSOY'],
data['PMDEC_HSOY'],
data['RA'],
data['DEC'],
degree=True)
vxvyvz = bovy_coords.vrpmllpmbb_to_vxvyvz(data['VHELIO_AVG'],
pmllpmbb[:, 0],
pmllpmbb[:, 1],
lb[:, 0],
lb[:, 1],
data['RC_DIST'],
degree=True)
vRvTvZ = bovy_coords.vxvyvz_to_galcencyl(
vxvyvz[:, 0],
vxvyvz[:, 1],
vxvyvz[:, 2],
8. - XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2] + 0.025,
vsun=[-11.1, 30.24 * 8.,
7.25]) #Assumes proper motion of Sgr A* and R0=8 kpc, zo= 25 pc
data['GALVR_HSOY'] = vRvTvZ[:, 0]
data['GALVT_HSOY'] = vRvTvZ[:, 1]
data['GALVZ_HSOY'] = vRvTvZ[:, 2]
data['GALVR_HSOY'][True ^ pmindx] = -9999.99
data['GALVT_HSOY'][True ^ pmindx] = -9999.99
data['GALVZ_HSOY'][True ^ pmindx] = -9999.99
#Return
return data
return None
def lbd_to_galcencyl(l,b,d,degree=True):
xyz=bovy_coords.lbd_to_XYZ(l,b,d,degree=degree) ## These are in physical units, DUMB DUMB DUMB!!!
Rphiz=bovy_coords.XYZ_to_galcencyl(xyz[:,0]/ro,xyz[:,1]/ro,xyz[:,2]/ro,Xsun=1.,Zsun=0.)
return (Rphiz[:,0]*ro,Rphiz[:,1],Rphiz[:,2]*ro)
def scatterData(options,args):
if options.png: ext= 'png'
else: ext= 'ps'
#Load sf
sf= segueSelect.segueSelect(sample=options.sample,sn=True,
type_bright='sharprcut',
type_faint='sharprcut')
if options.fake:
fakefile= open(options.fakefile,'rb')
fakedata= pickle.load(fakefile)
fakefile.close()
#Calculate distance
ds, ls, bs, rs, grs, fehs= [], [], [], [], [], []
for ii in range(len(fakedata)):
ds.append(_ivezic_dist(fakedata[ii][1],fakedata[ii][0],fakedata[ii][2]))
ls.append(fakedata[ii][3]+(2*numpy.random.uniform()-1.)\
*1.49)
bs.append(fakedata[ii][4]+(2*numpy.random.uniform()-1.)\
*1.49)
rs.append(fakedata[ii][0])
grs.append(fakedata[ii][1])
fehs.append(fakedata[ii][2])
ds= numpy.array(ds)
ls= numpy.array(ls)
bs= numpy.array(bs)
rs= numpy.array(rs)
grs= numpy.array(grs)
fehs= numpy.array(fehs)
XYZ= bovy_coords.lbd_to_XYZ(ls,bs,ds,degree=True)
else:
#Load data
XYZ,vxvyvz,cov_vxvyvz,data= readData(metal=options.metal,
select=options.select,
sample=options.sample)
#Cut out bright stars on faint plates and vice versa
indx= []
for ii in range(len(data.feh)):
if sf.platebright[str(data[ii].plate)] and data[ii].dered_r >= 17.8:
indx.append(False)
elif not sf.platebright[str(data[ii].plate)] and data[ii].dered_r < 17.8:
indx.append(False)
else:
indx.append(True)
indx= numpy.array(indx,dtype='bool')
data= data[indx]
XYZ= XYZ[indx,:]
vxvyvz= vxvyvz[indx,:]
cov_vxvyvz= cov_vxvyvz[indx,:]
R= ((8.-XYZ[:,0])**2.+XYZ[:,1]**2.)**0.5
bovy_plot.bovy_print()
if options.type.lower() == 'dataxy':
bovy_plot.bovy_plot(XYZ[:,0],XYZ[:,1],'k,',
xlabel=r'$X\ [\mathrm{kpc}]$',
ylabel=r'$Y\ [\mathrm{kpc}]$',
xrange=[5,-5],yrange=[5,-5],
onedhists=True)
elif options.type.lower() == 'datarz':
bovy_plot.bovy_plot(R,XYZ[:,2],'k,',
xlabel=r'$R\ [\mathrm{kpc}]$',
ylabel=r'$Z\ [\mathrm{kpc}]$',
xrange=[5,14],
yrange=[-4,4],
onedhists=True)
if options.fake:
bovy_plot.bovy_end_print(os.path.join(args[0],options.type+'_'
+'fake_'+
options.sample+'_'+
options.metal+'.'+ext))
else:
bovy_plot.bovy_end_print(os.path.join(args[0],options.type+'_'
+options.sample+'_'+
options.metal+'.'+ext))
def volume(self,
vol_func,
xyz=False,
MJ=None,
JK=None,
ndists=101,
linearDist=False,
relative=False,
ncpu=None):
"""
NAME:
volume
PURPOSE:
Compute the effective volume of a spatial volume under this effective selection function
INPUT:
vol_func - function of
(a) (ra/deg,dec/deg,dist/kpc)
(b) heliocentric Galactic X,Y,Z if xyz
that returns 1. inside the spatial volume under consideration and 0. outside of it, should be able to take array input of a certain shape and return an array with the same shape
xyz= (False) if True, vol_func is a function of X,Y,Z (see above)
MJ= (object-wide default) absolute magnitude in J or an array of samples of absolute magnitudes in J for the tracer population
JK= (object-wide default) J-Ks color or an array of samples of the J-Ks color
relative= (False) if True, compute the effective volume completeness = effective volume / true volume; computed using the same integration grid, so will be more robust against integration errors (especially due to the finite HEALPix grid for the angular integration). For simple volumes, a more precise effective volume can be computed by using relative=True and multiplying in the correct true volume
ndists= (101) number of distances to use in the distance integration
linearDist= (False) if True, integrate in distance rather than distance modulus
ncpu= (None) if set to an integer, use this many CPUs to compute the effective selection function (only for non-zero extinction)
OUTPUT
effective volume
HISTORY:
2017-01-18 - Written - Bovy (UofT/CCA)
"""
# Pre-compute coordinates for integrand evaluation
if not hasattr(self,'_ra_cen_4vol') or \
(hasattr(self,'_ndists_4vol') and
(ndists != self._ndists_4vol or
linearDist != self._linearDist_4vol)):
theta,phi= healpy.pix2ang(\
_BASE_NSIDE,numpy.arange(_BASE_NPIX)\
[True^self._tgasSel._exclude_mask_skyonly],nest=True)
self._ra_cen_4vol = 180. / numpy.pi * phi
self._dec_cen_4vol = 90. - 180. / numpy.pi * theta
if linearDist:
dists = numpy.linspace(0.001, 10., ndists)
dms = 5. * numpy.log10(dists) + 10.
self._deltadm_4vol = dists[1] - dists[0]
else:
dms = numpy.linspace(0., 18., ndists)
self._deltadm_4vol = (dms[1] - dms[0]) * numpy.log(10.) / 5.
self._dists_4vol = 10.**(0.2 * dms - 2.)
self._tiled_dists3_4vol= numpy.tile(\
self._dists_4vol**(3.-linearDist),(len(self._ra_cen_4vol),1))
self._tiled_ra_cen_4vol = numpy.tile(self._ra_cen_4vol,
(len(self._dists_4vol), 1)).T
self._tiled_dec_cen_4vol = numpy.tile(self._dec_cen_4vol,
(len(self._dists_4vol), 1)).T
lb = bovy_coords.radec_to_lb(phi, numpy.pi / 2. - theta)
l = numpy.tile(lb[:, 0], (len(self._dists_4vol), 1)).T.flatten()
b = numpy.tile(lb[:, 1], (len(self._dists_4vol), 1)).T.flatten()
XYZ_4vol= \
bovy_coords.lbd_to_XYZ(l,b,
numpy.tile(self._dists_4vol,
(len(self._ra_cen_4vol),1)).flatten())
self._X_4vol = numpy.reshape(
XYZ_4vol[:,
0], (len(self._ra_cen_4vol), len(self._dists_4vol)))
self._Y_4vol = numpy.reshape(
XYZ_4vol[:,
1], (len(self._ra_cen_4vol), len(self._dists_4vol)))
self._Z_4vol = numpy.reshape(
XYZ_4vol[:,
2], (len(self._ra_cen_4vol), len(self._dists_4vol)))
# Cache effective-selection function
MJ, JK = self._parse_mj_jk(MJ, JK)
new_hash = hashlib.md5(numpy.array([MJ, JK])).hexdigest()
if not hasattr(self,'_vol_MJ_hash') or new_hash != self._vol_MJ_hash \
or (hasattr(self,'_ndists_4vol') and
(ndists != self._ndists_4vol or
linearDist != self._linearDist_4vol)):
# Need to update the effective-selection function
if isinstance(self._dmap3d, mwdust.Zero): #easy bc same everywhere
effsel_4vol = self(self._dists_4vol,
self._ra_cen_4vol[0],
self._dec_cen_4vol[0],
MJ=MJ,
JK=JK)
self._effsel_4vol = numpy.tile(effsel_4vol,
(len(self._ra_cen_4vol), 1))
else: # Need to treat each los separately
if ncpu is None:
self._effsel_4vol = numpy.empty(
(len(self._ra_cen_4vol), len(self._dists_4vol)))
for ii,(ra_cen, dec_cen) \
in enumerate(tqdm.tqdm(zip(self._ra_cen_4vol,
self._dec_cen_4vol))):
self._effsel_4vol[ii] = self(self._dists_4vol,
ra_cen,
dec_cen,
MJ=MJ,
JK=JK)
else:
multiOut= multi.parallel_map(\
lambda x: self(self._dists_4vol,
self._ra_cen_4vol[x],
self._dec_cen_4vol[x],MJ=MJ,JK=JK),
range(len(self._ra_cen_4vol)),
numcores=ncpu)
self._effsel_4vol = numpy.array(multiOut)
self._vol_MJ_hash = new_hash
self._ndists_4vol = ndists
self._linearDist_4vol = linearDist
out = 0.
if xyz:
out= numpy.sum(\
self._effsel_4vol\
*vol_func(self._X_4vol,self._Y_4vol,self._Z_4vol)\
*self._tiled_dists3_4vol)
else:
out= numpy.sum(\
self._effsel_4vol\
*vol_func(self._ra_cen_4vol,self._dec_cen_4vol,
self._dists_4vol)\
*self._tiled_dists3_4vol)
if relative:
if not hasattr(self, '_tgasEffSelUniform'):
tgasSelUniform = tgasSelectUniform(comp=1.)
self._tgasEffSelUniform = tgasEffectiveSelect(tgasSelUniform)
true_volume = self._tgasEffSelUniform.volume(vol_func,
xyz=xyz,
ndists=ndists,
linearDist=linearDist,
relative=False)
else:
true_volume = 1.
return out*healpy.nside2pixarea(_BASE_NSIDE)*self._deltadm_4vol\
/true_volume
def make_rcsample(parser):
options, args = parser.parse_args()
savefilename = options.savefilename
if savefilename is None:
#Create savefilename if not given
savefilename = os.path.join(
appath._APOGEE_DATA, 'rcsample_' + appath._APOGEE_REDUX + '.fits')
print("Saving to %s ..." % savefilename)
#Read the base-sample
data = apread.allStar(adddist=_ADDHAYDENDIST, rmdups=options.rmdups)
#Remove a bunch of fields that we do not want to keep
data = esutil.numpy_util.remove_fields(data, [
'TARGET_ID', 'FILE', 'AK_WISE', 'SFD_EBV', 'SYNTHVHELIO_AVG',
'SYNTHVSCATTER', 'SYNTHVERR', 'SYNTHVERR_MED', 'RV_TEFF', 'RV_LOGG',
'RV_FEH', 'RV_ALPHA', 'RV_CARB', 'RV_CCFWHM', 'RV_AUTOFWHM',
'SYNTHSCATTER', 'STABLERV_CHI2', 'STABLERV_RCHI2',
'STABLERV_CHI2_PROB', 'CHI2_THRESHOLD', 'APSTAR_VERSION',
'ASPCAP_VERSION', 'RESULTS_VERSION', 'WASH_M', 'WASH_M_ERR', 'WASH_T2',
'WASH_T2_ERR', 'DDO51', 'DDO51_ERR', 'IRAC_3_6', 'IRAC_3_6_ERR',
'IRAC_4_5', 'IRAC_4_5_ERR', 'IRAC_5_8', 'IRAC_5_8_ERR', 'IRAC_8_0',
'IRAC_8_0_ERR', 'WISE_4_5', 'WISE_4_5_ERR', 'TARG_4_5', 'TARG_4_5_ERR',
'WASH_DDO51_GIANT_FLAG', 'WASH_DDO51_STAR_FLAG', 'REDUCTION_ID',
'SRC_H', 'PM_SRC'
])
# More
if appath._APOGEE_REDUX.lower() == 'l33':
data = esutil.numpy_util.remove_fields(data, [
'GAIA_SOURCE_ID', 'GAIA_PARALLAX', 'GAIA_PARALLAX_ERROR',
'GAIA_PMRA', 'GAIA_PMRA_ERROR', 'GAIA_PMDEC', 'GAIA_PMDEC_ERROR',
'GAIA_PHOT_G_MEAN_MAG', 'GAIA_PHOT_BP_MEAN_MAG',
'GAIA_PHOT_RP_MEAN_MAG', 'GAIA_RADIAL_VELOCITY',
'GAIA_RADIAL_VELOCITY_ERROR', 'GAIA_R_EST', 'GAIA_R_LO',
'GAIA_R_HI', 'TEFF_SPEC', 'LOGG_SPEC'
])
if not appath._APOGEE_REDUX.lower() == 'current' \
and not 'l3' in appath._APOGEE_REDUX \
and int(appath._APOGEE_REDUX[1:]) < 500:
data = esutil.numpy_util.remove_fields(data, ['ELEM'])
#Select red-clump stars
jk = data['J0'] - data['K0']
z = isodist.FEH2Z(data['METALS'], zsolar=0.017)
if 'l31' in appath._APOGEE_REDUX:
logg = data['LOGG']
elif 'l30' in appath._APOGEE_REDUX:
logg = data['LOGG']
elif appath._APOGEE_REDUX.lower() == 'current' \
or int(appath._APOGEE_REDUX[1:]) > 600:
if False:
#Use my custom logg calibration that's correct for the RC
logg = (1. - 0.042) * data['FPARAM'][:, paramIndx('logg')] - 0.213
lowloggindx = data['FPARAM'][:, paramIndx('logg')] < 1.
logg[lowloggindx] = data['FPARAM'][lowloggindx,
paramIndx('logg')] - 0.255
hiloggindx = data['FPARAM'][:, paramIndx('logg')] > 3.8
logg[hiloggindx] = data['FPARAM'][hiloggindx,
paramIndx('logg')] - 0.3726
else:
#Use my custom logg calibration that's correct on average
logg = (1. + 0.03) * data['FPARAM'][:, paramIndx('logg')] - 0.37
lowloggindx = data['FPARAM'][:, paramIndx('logg')] < 1.
logg[lowloggindx] = data['FPARAM'][lowloggindx,
paramIndx('logg')] - 0.34
hiloggindx = data['FPARAM'][:, paramIndx('logg')] > 3.8
logg[hiloggindx] = data['FPARAM'][hiloggindx,
paramIndx('logg')] - 0.256
else:
logg = data['LOGG']
indx= (jk < 0.8)*(jk >= 0.5)\
*(z <= 0.06)\
*(z <= rcmodel.jkzcut(jk,upper=True))\
*(z >= rcmodel.jkzcut(jk))\
*(logg >= rcmodel.loggteffcut(data['TEFF'],z,upper=False))\
*(logg+0.1*('l31' in appath._APOGEE_REDUX
or 'l33' in appath._APOGEE_REDUX) \
<= rcmodel.loggteffcut(data['TEFF'],z,upper=True))
data = data[indx]
#Add more aggressive flag cut
data = esutil.numpy_util.add_fields(data, [('ADDL_LOGG_CUT', numpy.int32)])
data['ADDL_LOGG_CUT'] = (
(data['TEFF'] - 4800.) / 1000. + 2.75) > data['LOGG']
if options.loggcut:
data = data[data['ADDL_LOGG_CUT'] == 1]
print("Making catalog of %i objects ..." % len(data))
#Add distances
data = esutil.numpy_util.add_fields(data, [('RC_DIST', float),
('RC_DM', float),
('RC_GALR', float),
('RC_GALPHI', float),
('RC_GALZ', float)])
rcd = rcmodel.rcdist()
jk = data['J0'] - data['K0']
z = isodist.FEH2Z(data['METALS'], zsolar=0.017)
data['RC_DIST'] = rcd(jk, z, appmag=data['K0']) * options.distfac
data['RC_DM'] = 5. * numpy.log10(data['RC_DIST']) + 10.
XYZ = bovy_coords.lbd_to_XYZ(data['GLON'],
data['GLAT'],
data['RC_DIST'],
degree=True)
RphiZ = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0],
XYZ[:, 1],
XYZ[:, 2],
Xsun=8.15,
Zsun=0.0208)
R = RphiZ[:, 0]
phi = RphiZ[:, 1]
Z = RphiZ[:, 2]
data['RC_GALR'] = R
data['RC_GALPHI'] = phi
data['RC_GALZ'] = Z
#Save
fitswrite(savefilename, data, clobber=True)
# Add Tycho-2 matches
if options.tyc2:
data = esutil.numpy_util.add_fields(data, [('TYC2MATCH', numpy.int32),
('TYC1', numpy.int32),
('TYC2', numpy.int32),
('TYC3', numpy.int32)])
data['TYC2MATCH'] = 0
data['TYC1'] = -1
data['TYC2'] = -1
data['TYC3'] = -1
# Write positions
posfilename = tempfile.mktemp('.csv', dir=os.getcwd())
resultfilename = tempfile.mktemp('.csv', dir=os.getcwd())
with open(posfilename, 'w') as csvfile:
wr = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
wr.writerow(['RA', 'DEC'])
for ii in range(len(data)):
wr.writerow([data[ii]['RA'], data[ii]['DEC']])
# Send to CDS for matching
result = open(resultfilename, 'w')
try:
subprocess.check_call([
'curl', '-X', 'POST', '-F', 'request=xmatch', '-F',
'distMaxArcsec=2', '-F', 'RESPONSEFORMAT=csv', '-F',
'cat1=@%s' % os.path.basename(posfilename), '-F', 'colRA1=RA',
'-F', 'colDec1=DEC', '-F', 'cat2=vizier:Tycho2',
'http://cdsxmatch.u-strasbg.fr/xmatch/api/v1/sync'
],
stdout=result)
except subprocess.CalledProcessError:
os.remove(posfilename)
if os.path.exists(resultfilename):
result.close()
os.remove(resultfilename)
result.close()
# Directly match on input RA
ma = numpy.loadtxt(resultfilename,
delimiter=',',
skiprows=1,
usecols=(1, 2, 7, 8, 9))
iis = numpy.arange(len(data))
mai = [iis[data['RA'] == ma[ii, 0]][0] for ii in range(len(ma))]
data['TYC2MATCH'][mai] = 1
data['TYC1'][mai] = ma[:, 2]
data['TYC2'][mai] = ma[:, 3]
data['TYC3'][mai] = ma[:, 4]
os.remove(posfilename)
os.remove(resultfilename)
if not options.nostat:
#Determine statistical sample and add flag
apo = apogee.select.apogeeSelect()
statIndx = apo.determine_statistical(data)
mainIndx = apread.mainIndx(data)
data = esutil.numpy_util.add_fields(data, [('STAT', numpy.int32),
('INVSF', float)])
data['STAT'] = 0
data['STAT'][statIndx * mainIndx] = 1
for ii in range(len(data)):
if (statIndx * mainIndx)[ii]:
data['INVSF'][ii] = 1. / apo(data['LOCATION_ID'][ii],
data['H'][ii])
else:
data['INVSF'][ii] = -1.
if options.nopm:
fitswrite(savefilename, data, clobber=True)
return None
data = _add_proper_motions(data, savefilename)
# Save
fitswrite(savefilename, data, clobber=True)
return None
def __init__(self,vxvv=None,uvw=False,lb=False,
radec=False,vo=235.,ro=8.5,zo=0.025,
solarmotion='hogg'):
"""
NAME:
__init__
PURPOSE:
Initialize an Orbit instance
INPUT:
vxvv - initial conditions
3D can be either
1) in Galactocentric cylindrical coordinates [R,vR,vT(,z,vz,phi)]
2) [ra,dec,d,mu_ra, mu_dec,vlos] in [deg,deg,kpc,mas/yr,mas/yr,km/s] (all J2000.0; mu_ra = mu_ra * cos dec)
3) [ra,dec,d,U,V,W] in [deg,deg,kpc,km/s,km/s,kms]
4) (l,b,d,mu_l, mu_b, vlos) in [deg,deg,kpc,mas/yr,mas/yr,km/s) (all J2000.0; mu_l = mu_l * cos b)
5) [l,b,d,U,V,W] in [deg,deg,kpc,km/s,km/s,kms]
4) and 5) also work when leaving out b and mu_b/W
OPTIONAL INPUTS:
radec - if True, input is 2) (or 3) above
uvw - if True, velocities are UVW
lb - if True, input is 4) or 5) above
vo - circular velocity at ro
ro - distance from vantage point to GC (kpc)
zo - offset toward the NGP of the Sun wrt the plane (kpc)
solarmotion - 'hogg' or 'dehnen', or 'schoenrich', or value in
[-U,V,W]
OUTPUT:
instance
HISTORY:
2010-07-20 - Written - Bovy (NYU)
"""
if isinstance(solarmotion,str) and solarmotion.lower() == 'hogg':
vsolar= nu.array([-10.1,4.0,6.7])/vo
elif isinstance(solarmotion,str) and solarmotion.lower() == 'dehnen':
vsolar= nu.array([-10.,5.25,7.17])/vo
elif isinstance(solarmotion,str) \
and solarmotion.lower() == 'schoenrich':
vsolar= nu.array([-11.1,12.24,7.25])/vo
else:
vsolar= nu.array(solarmotion)/vo
if radec or lb:
if radec:
l,b= coords.radec_to_lb(vxvv[0],vxvv[1],degree=True)
elif len(vxvv) == 4:
l, b= vxvv[0], 0.
else:
l,b= vxvv[0],vxvv[1]
if uvw:
X,Y,Z= coords.lbd_to_XYZ(l,b,vxvv[2],degree=True)
vx= vxvv[3]
vy= vxvv[4]
vz= vxvv[5]
else:
if radec:
pmll, pmbb= coords.pmrapmdec_to_pmllpmbb(vxvv[3],vxvv[4],
vxvv[0],vxvv[1],
degree=True)
d, vlos= vxvv[2], vxvv[5]
elif len(vxvv) == 4:
pmll, pmbb= vxvv[2], 0.
d, vlos= vxvv[1], vxvv[3]
else:
pmll, pmbb= vxvv[3], vxvv[4]
d, vlos= vxvv[2], vxvv[5]
X,Y,Z,vx,vy,vz= coords.sphergal_to_rectgal(l,b,d,
vlos,pmll, pmbb,
degree=True)
X/= ro
Y/= ro
Z/= ro
vx/= vo
vy/= vo
vz/= vo
vsun= nu.array([0.,1.,0.,])+vsolar
R, phi, z= coords.XYZ_to_galcencyl(X,Y,Z,Zsun=zo/ro)
vR, vT,vz= coords.vxvyvz_to_galcencyl(vx,vy,vz,
R,phi,z,
vsun=vsun,galcen=True)
if lb and len(vxvv) == 4: vxvv= [R,vR,vT,phi]
else: vxvv= [R,vR,vT,z,vz,phi]
self.vxvv= vxvv
if len(vxvv) == 2:
self._orb= linearOrbit(vxvv=vxvv)
elif len(vxvv) == 3:
self._orb= planarROrbit(vxvv=vxvv)
elif len(vxvv) == 4:
self._orb= planarOrbit(vxvv=vxvv)
elif len(vxvv) == 5:
self._orb= RZOrbit(vxvv=vxvv)
elif len(vxvv) == 6:
self._orb= FullOrbit(vxvv=vxvv)
def calc_actions(ra_deg, dec_deg, d_kpc, pm_ra_masyr, pm_dec_masyr, v_los_kms):
ra_rad = ra_deg * (np.pi / 180.) # RA [rad]
dec_rad = dec_deg * (np.pi / 180.) # dec [rad]
# Galactocentric position of the Sun:
X_gc_sun_kpc = 8. # [kpc]
Z_gc_sun_kpc = 0.025 # [kpc]
# Galactocentric velocity of the Sun:
vX_gc_sun_kms = -9.58 # = -U [kms]
vY_gc_sun_kms = 10.52 + 220. # = V+v_circ(R_Sun) [kms]
vZ_gc_sun_kms = 7.01 # = W [kms]
# a. convert spatial coordinates (ra,dec,d) to (R,z,phi)
# (ra,dec) --> Galactic coordinates (l,b):
lb = bovy_coords.radec_to_lb(ra_rad, dec_rad, degree=False, epoch=2000.0)
l_rad = lb[:, 0]
b_rad = lb[:, 1]
# (l,b,d) --> Galactocentric cartesian coordinates (x,y,z):
xyz = bovy_coords.lbd_to_XYZ(l_rad, b_rad, d_kpc, degree=False)
x_kpc = xyz[:, 0]
y_kpc = xyz[:, 1]
z_kpc = xyz[:, 2]
# (x,y,z) --> Galactocentric cylindrical coordinates (R,z,phi):
Rzphi = bovy_coords.XYZ_to_galcencyl(x_kpc,
y_kpc,
z_kpc,
Xsun=X_gc_sun_kpc,
Zsun=Z_gc_sun_kpc)
R_kpc = Rzphi[:, 0]
phi_rad = Rzphi[:, 1]
z_kpc = Rzphi[:, 2]
# b. convert velocities (pm_ra,pm_dec,vlos) to (vR,vz,vT)
# (pm_ra,pm_dec) --> (pm_l,pm_b):
pmlpmb = bovy_coords.pmrapmdec_to_pmllpmbb(pm_ra_masyr,
pm_dec_masyr,
ra_rad,
dec_rad,
degree=False,
epoch=2000.0)
pml_masyr = pmlpmb[:, 0]
pmb_masyr = pmlpmb[:, 1]
# (v_los,pm_l,pm_b) & (l,b,d) --> (vx,vy,vz):
vxvyvz = bovy_coords.vrpmllpmbb_to_vxvyvz(v_los_kms,
pml_masyr,
pmb_masyr,
l_rad,
b_rad,
d_kpc,
XYZ=False,
degree=False)
vx_kms = vxvyvz[:, 0]
vy_kms = vxvyvz[:, 1]
vz_kms = vxvyvz[:, 2]
# (vx,vy,vz) & (x,y,z) --> (vR,vT,vz):
vRvTvZ = bovy_coords.vxvyvz_to_galcencyl(
vx_kms,
vy_kms,
vz_kms,
R_kpc,
phi_rad,
z_kpc,
vsun=[vX_gc_sun_kms, vY_gc_sun_kms, vZ_gc_sun_kms],
galcen=True)
vR_kms = vRvTvZ[:, 0]
vT_kms = vRvTvZ[:, 1]
vz_kms = vRvTvZ[:, 2]
print("R = ", R_kpc, "\t kpc")
print("phi = ", phi_rad, "\t rad")
print("z = ", z_kpc, "\t kpc")
print("v_R = ", vR_kms, "\t km/s")
print("v_T = ", vT_kms, "\t km/s")
print("v_z = ", vz_kms, "\t km/s")
return vz_kms
def comove_coords(t, lit_gaia):
###could add other outputs like Vr, pred, in addition to sep,sep3d,and Vtan off
ra = t.target_df.squeeze()['ra'] * u.deg
dec = t.target_df.squeeze()['dec'] * u.deg
distance = (1000.0 / t.target_df.squeeze()['parallax']) * u.pc
radvel = t.target_df.squeeze(
)['dr2_radial_velocity'] * u.kilometer / u.second
pmra = t.target_df.squeeze()['pmra'] * u.mas / u.year
pmdec = t.target_df.squeeze()['pmdec'] * u.mas / u.year
Pcoord = SkyCoord( ra=ra, dec=dec, \
distance=distance, frame='icrs' , \
radial_velocity=radvel , \
pm_ra_cosdec= pmra , pm_dec= pmdec )
# # Query Gaia with search radius and parallax cut
# # Note, a cut on parallax_error was added because searches at low galactic latitude
# # return an overwhelming number of noisy sources that scatter into the search volume - ALK 20210325
# print('Querying Gaia for neighbors')
# if (searchradpc < Pcoord.distance):
# sqltext = "SELECT * FROM gaiaedr3.gaia_source WHERE CONTAINS( \
# POINT('ICRS',gaiaedr3.gaia_source.ra,gaiaedr3.gaia_source.dec), \
# CIRCLE('ICRS'," + str(Pcoord.ra.value) +","+ str(Pcoord.dec.value) +","+ str(searchraddeg.value) +"))\
# =1 AND parallax>" + str(minpar.value) + " AND parallax_error<0.5;"
# if (searchradpc >= Pcoord.distance):
# sqltext = "SELECT * FROM gaiaedr3.gaia_source WHERE parallax>" + str(minpar.value) + " AND parallax_error<0.5;"
# print('Note, using all-sky search')
# if verbose == True:
# print(sqltext)
# print()
# job = Gaia.launch_job_async(sqltext , dump_to_file=False)
# r = job.get_results()
# if verbose == True: print('Number of records: ',len(r['ra']))
# # Construct coordinates array for all stars returned in cone search
# gaiacoord = SkyCoord( ra=r['ra'] , dec=r['dec'] , distance=(1000.0/r['parallax'])*u.parsec , \
# frame='icrs' , \
# pm_ra_cosdec=r['pmra'] , pm_dec=r['pmdec'] )
lit_sc = SkyCoord(
ra=lit_gaia.ra.to_numpy(dtype='float') * u.deg,
dec=lit_gaia.dec.to_numpy(dtype='float') * u.deg,
pm_ra_cosdec=lit_gaia.pmra.to_numpy(dtype='float') * u.mas / u.yr,
pm_dec=lit_gaia.pmdec.to_numpy(dtype='float') * u.mas / u.yr,
distance=u.pc * (1000. / lit_gaia.parallax.to_numpy(dtype='float')))
sep = lit_sc.separation(Pcoord) #in degrees
sep3d = lit_sc.separation_3d(Pcoord) #in parsec
Pllbb = bc.radec_to_lb(Pcoord.ra.value, Pcoord.dec.value, degree=True)
Ppmllpmbb = bc.pmrapmdec_to_pmllpmbb( Pcoord.pm_ra_cosdec.value , Pcoord.pm_dec.value , \
Pcoord.ra.value , Pcoord.dec.value , degree=True )
Pvxvyvz = bc.vrpmllpmbb_to_vxvyvz(Pcoord.radial_velocity.value , Ppmllpmbb[0] , Ppmllpmbb[1] , \
Pllbb[0] , Pllbb[1] , Pcoord.distance.value/1000.0 , XYZ=False , degree=True)
Gllbb = bc.radec_to_lb(lit_sc.ra.value, lit_sc.dec.value, degree=True)
Gxyz = bc.lbd_to_XYZ(Gllbb[:, 0],
Gllbb[:, 1],
lit_sc.distance / 1000.0,
degree=True)
Gvrpmllpmbb = bc.vxvyvz_to_vrpmllpmbb( \
Pvxvyvz[0]*np.ones(len(Gxyz[:,0])) , Pvxvyvz[1]*np.ones(len(Gxyz[:,1])) , Pvxvyvz[2]*np.ones(len(Gxyz[:,2])) , \
Gxyz[:,0] , Gxyz[:,1] , Gxyz[:,2] , XYZ=True)
Gpmrapmdec = bc.pmllpmbb_to_pmrapmdec(Gvrpmllpmbb[:, 1],
Gvrpmllpmbb[:, 2],
Gllbb[:, 0],
Gllbb[:, 1],
degree=True)
# Code in case I want to do chi^2 cuts someday
Gvtanerr = 1.0 * np.ones(len(Gxyz[:, 0]))
Gpmerr = Gvtanerr * 206265000.0 * 3.154e7 / (lit_sc.distance.value *
3.086e13)
Gchi2 = ((Gpmrapmdec[:, 0] - lit_sc.pm_ra_cosdec.value)**2 +
(Gpmrapmdec[:, 1] - lit_sc.pm_dec.value)**2)**0.5
vtanoff = Gchi2 / Gpmerr #this is reported Vtan,off(km/s)
##vr pred
vr_pred = Gvrpmllpmbb[:, 0]
#create results dataframe
res = pd.DataFrame(
data={
'tic': lit_gaia.tic.to_numpy(dtype='str'),
'designation': lit_gaia.designation.to_numpy(dtype='str'),
'ra': lit_sc.ra.value,
'dec': lit_sc.dec.value,
'sep2D(deg)': sep.value,
'sep3D(pc)': sep3d.value,
'Vtan,off(km/s)': vtanoff,
'Vr,pred(km/s)': vr_pred
})
return (res)
print("optical cut completed!")
radeg = stars_categorized['ra']
decdeg = stars_categorized['dec']
pmra = stars_categorized['pmra']
pmdec = stars_categorized['pmdec']
pml, pmb = ProperMotionTransform(radeg, decdeg, pmra, pmdec)
hipID = stars_categorized['hip']
ldeg = stars_categorized['l']
bdeg = stars_categorized['b']
plx = stars_categorized['parallax']
e_plx = stars_categorized['parallax_error']
XYZ = bovy_coords.lbd_to_XYZ(ldeg, bdeg, 1. / plx, degree=True)
z_cyl = XYZ[:, 2]
z_pc = XYZ[:, 2] * 1000.
zRangeList_upper = zRangeList + zStepWidth / 2
zRangeList_lower = zRangeList - zStepWidth / 2
evfs_weight = np.array([])
for i, z_i in enumerate(z_cyl):
zPosition = (z_i < zRangeList_upper) * (z_i >= zRangeList_lower)
if np.sum(zPosition) == 0:
print((z_i < zRangeList_upper), (z_i >= zRangeList_lower))
evfs_weight = np.append(evfs_weight, 1. / evfs_out[zPosition])
if len(evfs_weight) != len(z_cyl):
print("Need a more inclusive evfs volumn! (larger z evfs range)")
