def _load(self, filename):
raw = Vizier.get_catalogs('VII/26D')[0]
if FILTER_DWARFS:
raw = raw[raw['UGC'] != 10822] # Draco (UGC 10822)
raw = raw[raw['UGC'] != 9749] # Ursa Minor (UGC 9749)
raw = raw[raw['UGC'] != 5470] # Leo I (UGC 5470)
raw = raw[raw['UGC'] != 6253] # Leo II (UGC 6253)
self.data.resize(len(raw))
self.data['name'] = np.char.mod('UGC %s', raw['UGC'])
ra = np.array([map(float, hms.split()) for hms in raw['RA1950']])
dec = np.array([map(float, dms.split()) for dms in raw['DE1950']])
ra = np.vstack([ra.T, np.zeros(len(raw))]).T
dec = np.vstack([dec.T, np.zeros(len(raw))]).T
ra1950 = ugali.utils.projector.hms2dec(ra)
dec1950 = ugali.utils.projector.dms2dec(dec)
ra2000, dec2000 = ugali.utils.idl.jprecess(ra1950, dec1950)
self.data['ra'] = ra2000
self.data['dec'] = dec2000
self.data[
'radius'] = raw['MajAxis'] / 60.0 # Major axis on POSS blue print
# Could also use minor axis 'MinAxis' (no position angle given)
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def _parse_coords(self, opts):
""" Parse target coordinates in various ways...
"""
# The coordinates are mutually exclusive, so
# shouldn't have to worry about over-writing them.
if 'coords' in vars(opts): return
radius = vars(opts).get('radius', 0)
gal = None
if vars(opts).get('gal') is not None:
gal = opts.gal
elif vars(opts).get('cel') is not None:
gal = cel2gal(*opts.cel)
elif vars(opts).get('hpx') is not None:
gal = pix2ang(*opts.hpx)
if gal is not None:
opts.coords = [(gal[0], gal[1], radius)]
opts.names = [vars(opts).get('name', '')]
else:
opts.coords = None
opts.names = None
if vars(opts).get('targets') is not None:
opts.names, opts.coords = self.parse_targets(opts.targets)
if vars(opts).get('radius') is not None:
opts.coords['radius'] = vars(opts).get('radius')
def _load(self,filename):
kwargs = dict(delimiter=[1,1,4,15,3,3,8,3,3,7],usecols=[1,2]+list(range(4,10)),dtype=['S1']+[int]+6*[float])
if filename is None:
raw = []
for basename in ['VII_239A/ngcpos.dat','VII_239A/icpos.dat']:
filename = os.path.join(self.DATADIR,basename)
raw.append(np.genfromtxt(filename,**kwargs))
raw = np.concatenate(raw)
else:
raw = np.genfromtxt(filename,**kwargs)
self.filename = filename
# Some entries are missing...
raw['f4'] = np.where(np.isnan(raw['f4']),0,raw['f4'])
raw['f7'] = np.where(np.isnan(raw['f7']),0,raw['f7'])
self.data.resize(len(raw))
names = np.where(raw['f0'] == 'N', 'NGC %04i', 'IC %04i')
self.data['name'] = np.char.mod(names,raw['f1'])
ra = raw[['f2','f3','f4']].view(float).reshape(len(raw),-1)
dec = raw[['f5','f6','f7']].view(float).reshape(len(raw),-1)
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
glon,glat = cel2gal(self.data['ra'],self.data['dec'])
self.data['glon'],self.data['glat'] = glon,glat
def pixelizeCatalog(infiles, config, force=False):
"""
Break catalog up into a set of healpix files.
"""
nside_catalog = config['coords']['nside_catalog']
nside_pixel = config['coords']['nside_pixel']
outdir = mkdir(config['catalog']['dirname'])
filenames = config.getFilenames()
for ii,infile in enumerate(infiles):
logger.info('(%i/%i) %s'%(ii+1, len(infiles), infile))
f = pyfits.open(infile)
data = f[1].data
header = f[1].header
logger.info("%i objects found"%len(data))
if not len(data): continue
glon,glat = cel2gal(data['RA'],data['DEC'])
catalog_pix = ang2pix(nside_catalog,glon,glat,coord='GAL')
pixel_pix = ang2pix(nside_pixel,glon,glat,coord='GAL')
names = [n.upper() for n in data.columns.names]
ra_idx = names.index('RA'); dec_idx = names.index('DEC')
idx = ra_idx if ra_idx > dec_idx else dec_idx
catalog_pix_name = 'PIX%i'%nside_catalog
pixel_pix_name = 'PIX%i'%nside_pixel
coldefs = pyfits.ColDefs(
[pyfits.Column(name='GLON',format='1D',array=glon),
pyfits.Column(name='GLAT',format='1D',array=glat),
pyfits.Column(name=catalog_pix_name,format='1J',array=catalog_pix),
pyfits.Column(name=pixel_pix_name ,format='1J',array=pixel_pix)]
)
hdu = pyfits.new_table(data.columns[:idx+1]+coldefs+data.columns[idx+1:])
table = hdu.data
for pix in numpy.unique(catalog_pix):
logger.debug("Processing pixel %s"%pix)
outfile = filenames.data['catalog'][pix]
if not os.path.exists(outfile):
logger.debug("Creating %s"%outfile)
names = [n.upper() for n in table.columns.names]
formats = table.columns.formats
columns = [pyfits.Column(n,f) for n,f in zip(names,formats)]
out = pyfits.HDUList([pyfits.PrimaryHDU(),pyfits.new_table(columns)])
out[1].header['NSIDE'] = nside_catalog
out[1].header['PIX'] = pix
out.writeto(outfile)
hdulist = pyfits.open(outfile,mode='update')
t1 = hdulist[1].data
# Could we speed up with sorting and indexing?
t2 = table[ table[catalog_pix_name] == pix ]
nrows1 = t1.shape[0]
nrows2 = t2.shape[0]
nrows = nrows1 + nrows2
out = pyfits.new_table(t1.columns, nrows=nrows)
for name in t1.columns.names:
out.data.field(name)[nrows1:]=t2.field(name)
hdulist[1] = out
logger.debug("Writing %s"%outfile)
hdulist.flush()
hdulist.close()
def _load(self, filename):
if filename is None:
filename = os.path.join(self.DATADIR, "VII_202/mwgc.dat")
self.filename = filename
kwargs = dict(delimiter=[12, 12, 3, 3, 6, 5, 3, 6, 8, 8, 6],
dtype=2 * ['S12'] + 7 * [float],
skip_header=72,
skip_footer=363)
raw = np.genfromtxt(filename, **kwargs)
kwargs2 = dict(delimiter=[13, 6, 6, 8, 8, 8, 9, 6, 6, 8, 7, 7, 5],
dtype=['S12'] + 12 * [float],
skip_header=433,
skip_footer=2)
raw2 = np.genfromtxt(filename, **kwargs2)
self.data.resize(len(raw))
self.data['name'] = np.char.strip(raw['f0'])
ra = raw[['f2', 'f3', 'f4']].view(float).reshape(len(raw), -1)
dec = raw[['f5', 'f6', 'f7']].view(float).reshape(len(raw), -1)
radius = raw2['f8'] / 60.0 # Half-light radius
# Could also use core radius raw2['f7']
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
self.data['radius'] = radius
def _load(self,filename):
kwargs = dict(delimiter=[8,15,9,4,3,3,5,5],usecols=[1]+list(range(3,8)),dtype=['S13']+5*[float])
if filename is None:
raw = []
for basename in ['VII_151/table1a.dat','VII_151/table1c.dat']:
filename = os.path.join(self.DATADIR,basename)
raw.append(np.genfromtxt(filename,**kwargs))
raw = np.concatenate(raw)
else:
raw = np.genfromtxt(filename,**kwargs)
self.filename = filename
self.data.resize(len(raw))
#self.data['name'] = np.char.strip(raw['f0'])
self.data['name'] = np.char.join(' ',np.char.split(raw['f0']))
ra = raw[['f1','f2','f3']].view(float).reshape(len(raw),-1)
dec = raw[['f4','f5']].view(float).reshape(len(raw),-1)
dec = np.vstack([dec.T,np.zeros(len(raw))]).T
ra1950 = ugali.utils.projector.hms2dec(ra)
dec1950 = ugali.utils.projector.dms2dec(dec)
ra2000,dec2000 = ugali.utils.idl.jprecess(ra1950,dec1950)
self.data['ra'] = ra2000
self.data['dec'] = dec2000
glon,glat = cel2gal(self.data['ra'],self.data['dec'])
self.data['glon'],self.data['glat'] = glon,glat
def pixelizeCatalog(infiles, config, force=False):
"""
Break catalog into chunks by healpix pixel.
Parameters:
-----------
infiles : List of input files
config : Configuration file
force : Overwrite existing files (depricated)
Returns:
--------
None
"""
nside_catalog = config['coords']['nside_catalog']
nside_pixel = config['coords']['nside_pixel']
outdir = mkdir(config['catalog']['dirname'])
filenames = config.getFilenames()
for i, filename in enumerate(infiles):
logger.info('(%i/%i) %s' % (i + 1, len(infiles), filename))
data = fitsio.read(filename)
logger.info("%i objects found" % len(data))
if not len(data): continue
glon, glat = cel2gal(data['RA'], data['DEC'])
cat_pix = ang2pix(nside_catalog, glon, glat)
pix_pix = ang2pix(nside_pixel, glon, glat)
cat_pix_name = 'PIX%i' % nside_catalog
pix_pix_name = 'PIX%i' % nside_pixel
data = mlab.rec_append_fields(
data,
names=['GLON', 'GLAT', cat_pix_name, pix_pix_name],
arrs=[glon, glat, cat_pix, pix_pix],
dtypes=['f4', 'f4', int, int])
for pix in np.unique(cat_pix):
logger.debug("Processing pixel %s" % pix)
arr = data[cat_pix == pix]
outfile = filenames.data['catalog'][pix]
if not os.path.exists(outfile):
logger.debug("Creating %s" % outfile)
out = fitsio.FITS(outfile, mode='rw')
out.write(arr)
hdr = ugali.utils.healpix.header_odict(nside=nside_catalog,
coord='G')
for key in ['PIXTYPE', 'ORDERING', 'NSIDE', 'COORDSYS']:
out[1].write_key(*list(hdr[key].values()))
out[1].write_key('PIX',
pix,
comment='HEALPIX pixel for this file')
else:
out = fitsio.FITS(outfile, mode='rw')
out[1].append(arr)
logger.debug("Writing %s" % outfile)
out.close()
def _load(self, filename):
kwargs = dict(delimiter=[1, 1, 4, 15, 3, 3, 8, 3, 3, 7],
usecols=[1, 2] + list(range(4, 10)),
dtype=['S1'] + [int] + 6 * [float])
if filename is None:
raw = []
for basename in ['VII_239A/ngcpos.dat', 'VII_239A/icpos.dat']:
filename = os.path.join(self.DATADIR, basename)
raw.append(np.genfromtxt(filename, **kwargs))
raw = numpy.concatenate(raw)
else:
raw = numpy.genfromtxt(filename, **kwargs)
self.filename = filename
# Some entries are missing...
raw['f4'] = numpy.where(numpy.isnan(raw['f4']), 0, raw['f4'])
raw['f7'] = numpy.where(numpy.isnan(raw['f7']), 0, raw['f7'])
self.data.resize(len(raw))
names = numpy.where(raw['f0'] == 'N', 'NGC %04i', 'IC %04i')
self.data['name'] = numpy.char.mod(names, raw['f1'])
ra = raw[['f2', 'f3', 'f4']].view(float).reshape(len(raw), -1)
dec = raw[['f5', 'f6', 'f7']].view(float).reshape(len(raw), -1)
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def _parse_coords(self,opts):
""" Parse target coordinates in various ways...
"""
# The coordinates are mutually exclusive, so
# shouldn't have to worry about over-writing them.
if 'coords' in vars(opts): return
radius = vars(opts).get('radius',0)
gal = None
if vars(opts).get('gal') is not None:
gal = opts.gal
elif vars(opts).get('cel') is not None:
gal = cel2gal(*opts.cel)
elif vars(opts).get('hpx') is not None:
gal = pix2ang(*opts.hpx)
if gal is not None:
opts.coords = [(gal[0],gal[1],radius)]
opts.names = [vars(opts).get('name','')]
else:
opts.coords = None
opts.names = None
if vars(opts).get('targets') is not None:
opts.names,opts.coords = self.parse_targets(opts.targets)
if vars(opts).get('radius') is not None:
opts.coords['radius'] = vars(opts).get('radius')
def _load(self, filename):
kwargs = dict(delimiter=[8, 15, 9, 4, 3, 3, 5, 5],
usecols=[1] + list(range(3, 8)),
dtype=['S13'] + 5 * [float])
if filename is None:
raw = []
for basename in ['VII_151/table1a.dat', 'VII_151/table1c.dat']:
filename = os.path.join(self.DATADIR, basename)
raw.append(np.genfromtxt(filename, **kwargs))
raw = numpy.concatenate(raw)
print raw.dtype
else:
raw = np.genfromtxt(filename, **kwargs)
print raw.dtype
self.filename = filename
self.data.resize(len(raw))
#self.data['name'] = np.char.strip(raw['f0'])
self.data['name'] = np.char.join(' ', np.char.split(raw['f0']))
print self.data.dtype
ra = raw[['f1', 'f2', 'f3']].view(float).reshape(len(raw), -1)
dec = raw[['f4', 'f5']].view(float).reshape(len(raw), -1)
dec = np.vstack([dec.T, np.zeros(len(raw))]).T
ra1950 = ugali.utils.projector.hms2dec(ra)
dec1950 = ugali.utils.projector.dms2dec(dec)
ra2000, dec2000 = ugali.utils.idl.jprecess(ra1950, dec1950)
self.data['ra'] = ra2000
self.data['dec'] = dec2000
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def match(self, lon, lat, coord='gal', tol=0.1, nnearest=1):
if coord.lower() == 'cel':
glon, glat = cel2gal(lon, lat)
else:
glon, glat = lon, lat
return ugali.utils.projector.match(glon, glat, self['glon'],
self['glat'], tol, nnearest)
def ebv(ra, dec, ebvmap=None):
ra = np.atleast_1d(ra)
dec = np.atleast_1d(dec)
if not len(ra) == len(dec):
msg = "Column lengths must match"
raise Exception(msg)
if ebvmap is None or ebvmap.lower() == 'sfd':
# Download SFD map
url = "http://lambda.gsfc.nasa.gov/data/foregrounds/SFD/lambda_sfd_ebv.fits"
logger.info("Downloading %s..." % url)
filename = tempfile.NamedTemporaryFile().name
cmd = "wget %s -O %s" % (url, filename)
subprocess.call(cmd, shell=True)
ebvmap = healpy.read_map(filename)
os.remove(filename)
elif isinstance(ebvmap, basestring):
logger.info("Loading %s..." % ebvmap)
ebvmap = healpy.read_map(ebvmap)
else:
msg = "Unrecognized ebv: %s" % ebvmap
raise Exception(msg)
# The SFD map is in Galactic coordinates
glon, glat = cel2gal(ra, dec)
ebv = healpix.get_interp_val(ebvmap, glon, glat)
return ebv
def finalizeObjects(self, objects):
objs = numpy.recarray(len(objects),
dtype=[('NAME','S24'),
('TS','f4'),
('GLON','f4'),
('GLAT','f4'),
('RA','f4'),
('DEC','f4'),
('MODULUS','f4'),
('DISTANCE','f4'),
('RICHNESS','f4'),
('MASS','f4'),
('NANNULUS','i4'),
('NINTERIOR','i4'),
])
objs['TS'] = self.values[objects['IDX_MAX'],objects['ZIDX_MAX']]
lon,lat = objects['X_MAX'],objects['Y_MAX']
coordsys = self.config['coords']['coordsys']
if coordsys.lower() == 'gal':
print("GAL coordintes")
objs['GLON'],objs['GLAT'] = lon,lat
objs['RA'],objs['DEC'] = gal2cel(lon,lat)
else:
print("CEL coordintes")
objs['RA'],objs['DEC'] = lon,lat
objs['GLON'],objs['GLAT'] = cel2gal(lon,lat)
modulus = objects['Z_MAX']
objs['MODULUS'] = modulus
objs['DISTANCE'] = mod2dist(modulus)
nside = healpy.npix2nside(len(self.nannulus))
pix = ang2pix(nside,lon,lat)
richness = self.richness[objects['IDX_MAX'],objects['ZIDX_MAX']]
objs['RICHNESS'] = richness
objs['MASS'] = richness * self.stellar[pix]
objs['NANNULUS'] = self.nannulus[pix].astype(int)
objs['NINTERIOR'] = self.ninterior[pix].astype(int)
# Default name formatting
# http://cdsarc.u-strasbg.fr/ftp/pub/iau/
# http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx
fmt = "J%(hour)02i%(hmin)04.1f%(deg)+03i%(dmin)02i"
for obj,_ra,_dec in zip(objs,objs['RA'],objs['DEC']):
hms = dec2hms(_ra); dms = dec2dms(_dec)
params = dict(hour=hms[0],hmin=hms[1]+hms[2]/60.,
deg=dms[0],dmin=dms[1]+dms[2]/60.)
obj['NAME'] = fmt%params
out = recfuncs.merge_arrays([objs,objects],usemask=False,
asrecarray=True,flatten=True)
return out
def parse_targets(filename):
"""
Load a text file with target coordinates. Returns
an array of target locations in Galactic coordinates.
File description:
[NAME] [LON] [LAT] [RADIUS] [COORD]
The values of LON and LAT will depend on COORD:
COORD = [GAL | CEL | HPX ],
LON = [GLON | RA | NSIDE]
LAT = [GLAT | DEC | PIX ]
"""
base,ext = os.path.splitext(filename)
if (ext=='.fits'):
import fitsio
data = fitsio.read(filename)
elif (ext=='.txt'):
from numpy.lib import NumpyVersion
if NumpyVersion(np.__version__) < '1.14.0':
data = np.genfromtxt(filename,names=True,dtype=None)
else:
data = np.genfromtxt(filename,names=True,dtype=None,encoding=None)
#data = np.genfromtxt(filename,unpack=True,usecols=list(range(5)),dtype=object,names=True)
elif (ext=='.yaml'):
import yaml
data = [(k,v['kernel']['lon']['value'],v['kernel']['lat']['value'],0.5,'CEL') for k,v in yaml.load(open(filename)).items()]
data = np.rec.fromrecords(data,names=['name','lon','lat','radius','coord'])
else:
msg = "Unrecognized file type: %s"%filename
raise IOError(msg)
data = np.atleast_1d(data)
data.dtype.names = list(map(str.lower,data.dtype.names))
# Deal with one-line input files
#if data.ndim == 1: data = np.array([data]).T
names = data['name']
out = data[['lon','lat','radius']].copy()
coord = np.char.lower(data['coord'])
gal = (coord=='gal')
cel = (coord=='cel')
hpx = (coord=='hpx')
if cel.any():
glon,glat = cel2gal(data['lon'][cel],data['lat'][cel])
out['lon'][cel] = glon
out['lat'][cel] = glat
if hpx.any():
glon,glat = pix2ang(data['lat'][hpx],data['lon'][hpx])
out['lon'][hpx] = glon
out['lat'][hpx] = glat
return names,out.view(np.ndarray)
def _load(self, filename):
if filename is None:
filename = os.path.join(self.DATADIR,"dr8_run_redmapper_v5.10_lgt20_catalog.fit")
raw = pyfits.open(filename)[1].data
self.data.resize(len(raw))
self.data['name'] = numpy.char.mod("RedMaPPer %d",raw['MEM_MATCH_ID'])
self.data['ra'] = raw['ra']
self.data['dec'] = raw['dec']
glon,glat = cel2gal(raw['ra'],raw['dec'])
self.data['glon'],self.data['glat'] = glon, glat
def _load(self,filename):
kwargs = dict(delimiter=',')
if filename is None:
filename = os.path.join(self.DATADIR,"extras/extra_clusters.csv")
raw = np.recfromcsv(filename,**kwargs)
self.data.resize(len(raw))
self.data['name'] = raw['name']
self.data['ra'] = raw['ra']
self.data['dec'] = raw['dec']
self.data['glon'],self.data['glat'] = cel2gal(raw['ra'],raw['dec'])
def _load(self, filename):
if filename is None:
filename = os.path.join(self.DATADIR,"redmapper/dr8_run_redmapper_v5.10_lgt20_catalog.fit")
self.filename = filename
raw = fitsio.read(filename,lower=True)
self.data.resize(len(raw))
self.data['name'] = np.char.mod("RedMaPPer %d",raw['mem_match_id'])
self.data['ra'] = raw['ra']
self.data['dec'] = raw['dec']
glon,glat = cel2gal(raw['ra'],raw['dec'])
self.data['glon'],self.data['glat'] = glon, glat
def finalizeObjects(self, objects):
objs = np.recarray(len(objects),
dtype=[
('NAME', 'S24'),
('TS', 'f4'),
('GLON', 'f4'),
('GLAT', 'f4'),
('RA', 'f4'),
('DEC', 'f4'),
('MODULUS', 'f4'),
('DISTANCE', 'f4'),
('RICHNESS', 'f4'),
('MASS', 'f4'),
('NANNULUS', 'i4'),
('NINTERIOR', 'i4'),
])
objs['TS'] = self.values[objects['IDX_MAX'], objects['ZIDX_MAX']]
lon, lat = objects['X_MAX'], objects['Y_MAX']
coordsys = self.config['coords']['coordsys']
if coordsys.lower() == 'gal':
print("GAL coordintes")
objs['GLON'], objs['GLAT'] = lon, lat
objs['RA'], objs['DEC'] = gal2cel(lon, lat)
else:
print("CEL coordintes")
objs['RA'], objs['DEC'] = lon, lat
objs['GLON'], objs['GLAT'] = cel2gal(lon, lat)
modulus = objects['Z_MAX']
objs['MODULUS'] = modulus
objs['DISTANCE'] = mod2dist(modulus)
nside = healpy.npix2nside(len(self.nannulus))
pix = ang2pix(nside, lon, lat)
richness = self.richness[objects['IDX_MAX'], objects['ZIDX_MAX']]
objs['RICHNESS'] = richness
objs['MASS'] = richness * self.stellar[pix]
objs['NANNULUS'] = self.nannulus[pix].astype(int)
objs['NINTERIOR'] = self.ninterior[pix].astype(int)
objs['NAME'] = ang2iau(objs['RA'], objs['DEC'], coord='cel')
out = recfuncs.merge_arrays([objs, objects],
usemask=False,
asrecarray=True,
flatten=True)
return out
def parse_targets(filename):
"""
Load a text file with target coordinates. Returns
an array of target locations in Galactic coordinates.
File description:
[NAME] [LON] [LAT] [RADIUS] [COORD]
The values of LON and LAT will depend on COORD:
COORD = [GAL | CEL | HPX ],
LON = [GLON | RA | NSIDE]
LAT = [GLAT | DEC | PIX ]
"""
base, ext = os.path.splitext(filename)
if (ext == '.fits'):
import fitsio
data = fitsio.read(filename)
else:
from numpy.lib import NumpyVersion
if NumpyVersion(np.__version__) < '1.14.0':
data = np.genfromtxt(filename, names=True, dtype=None)
else:
data = np.genfromtxt(filename,
names=True,
dtype=None,
encoding=None)
#data = np.genfromtxt(filename,unpack=True,usecols=list(range(5)),dtype=object,names=True)
data = np.atleast_1d(data)
data.dtype.names = list(map(str.lower, data.dtype.names))
# Deal with one-line input files
#if data.ndim == 1: data = np.array([data]).T
names = data['name']
out = data[['lon', 'lat', 'radius']].copy()
coord = np.char.lower(data['coord'])
gal = (coord == 'gal')
cel = (coord == 'cel')
hpx = (coord == 'hpx')
if cel.any():
glon, glat = cel2gal(data['lon'][cel], data['lat'][cel])
out['lon'][cel] = glon
out['lat'][cel] = glat
if hpx.any():
glon, glat = pix2ang(data['lat'][hpx], data['lon'][hpx])
out['lon'][hpx] = glon
out['lat'][hpx] = glat
return names, out.view(np.ndarray)
def supplement(self, coordsys='gal'):
""" Add some supplemental columns """
from ugali.utils.projector import gal2cel, gal2cel_angle
from ugali.utils.projector import cel2gal, cel2gal_angle
coordsys = coordsys.lower()
kwargs = dict(usemask=False, asrecarray=True)
out = copy.deepcopy(self)
if ('lon' in out.names) and ('lat' in out.names):
# Ignore entries that are all zero
zeros = np.all(self.ndarray == 0, axis=1)
if coordsys == 'gal':
ra, dec = gal2cel(out.lon, out.lat)
glon, glat = out.lon, out.lat
else:
ra, dec = out.lon, out.lat
glon, glat = cel2gal(out.lon, out.lat)
ra[zeros] = 0
dec[zeros] = 0
glon[zeros] = 0
glat[zeros] = 0
names = ['ra', 'dec', 'glon', 'glat']
arrs = [ra, dec, glon, glat]
out = mlab.rec_append_fields(out, names, arrs).view(Samples)
#out = recfuncs.append_fields(out,names,arrs,**kwargs).view(Samples)
if 'position_angle' in out.names:
if coordsys == 'gal':
pa_gal = out.position_angle
pa_cel = gal2cel_angle(out.lon, out.lat,
out.position_angle)
pa_cel = pa_cel - 180. * (pa_cel > 180.)
else:
pa_gal = cel2gal_angle(out.lon, out.lat,
out.position_angle)
pa_cel = out.position_angle
pa_gal = pa_gal - 180. * (pa_gal > 180.)
pa_gal[zeros] = 0
pa_cel[zeros] = 0
names = ['position_angle_gal', 'position_angle_cel']
arrs = [pa_gal, pa_cel]
out = recfuncs.append_fields(out, names, arrs,
**kwargs).view(Samples)
return out
def _load(self,filename):
kwargs = dict(delimiter=[32,2,3,3,5,3,3],dtype=['S32']+6*[float])
if filename is None:
filename = os.path.join(self.DATADIR,"J_MNRAS_389_678/table3.dat")
raw = np.genfromtxt(filename,**kwargs)
self.data.resize(len(raw))
self.data['name'] = numpy.char.strip(raw['f0'])
ra = raw[['f1','f2','f3']].view(float).reshape(len(raw),-1)
dec = raw[['f4','f5','f6']].view(float).reshape(len(raw),-1)
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
glon,glat = cel2gal(self.data['ra'],self.data['dec'])
self.data['glon'],self.data['glat'] = glon,glat
def _load(self, filename):
kwargs = dict(delimiter=',')
if filename is None:
filename = os.path.join(self.DATADIR, "extras/extra_dwarfs.csv")
self.filename = filename
raw = np.recfromcsv(filename, **kwargs)
self.data.resize(len(raw))
self.data['name'] = raw['name']
self.data['ra'] = raw['ra']
self.data['dec'] = raw['dec']
self.data['radius'] = raw['rhalf'] / 60.0 # Half-light radius, arcmin
self.data['glon'], self.data['glat'] = cel2gal(raw['ra'], raw['dec'])
def _load(self, filename):
raw = Vizier.get_catalogs('J/MNRAS/389/678')[0]
self.data.resize(len(raw))
self.data['name'] = np.char.strip(raw['Names'])
ra = np.array([map(float, hms.split()) for hms in raw['RAJ2000']])
dec = np.array([map(float, dms.split()) for dms in raw['DEJ2000']])
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
self.data['radius'] = raw['amaj'] / 60.0 # Major axis
# Could also use minor axis 'amin' and position angle 'PA'
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def _load(self,filename):
if filename is None:
filename = os.path.join(self.DATADIR,"J_AJ_144_4/NearbyGalaxies.dat")
raw = numpy.genfromtxt(filename,delimiter=[19,3,3,5,3,3,3],usecols=range(7),dtype=['|S19']+6*[float],skip_header=34)
self.data.resize(len(raw))
self.data['name'] = numpy.char.strip(raw['f0'])
ra = raw[['f1','f2','f3']].view(float).reshape(len(raw),-1)
dec = raw[['f4','f5','f6']].view(float).reshape(len(raw),-1)
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
glon,glat = cel2gal(self.data['ra'],self.data['dec'])
self.data['glon'],self.data['glat'] = glon,glat
def _load(self, filename):
kwargs = dict(delimiter=',')
if filename is None:
filename = os.path.join(self.DATADIR,
"extras/extra_structures.csv")
self.filename = filename
raw = np.recfromcsv(filename, **kwargs)
self.data.resize(len(raw))
self.data['name'] = raw['name']
self.data['ra'] = raw['ra']
self.data['dec'] = raw['dec']
self.data['radius'] = raw['width'] # Only applies to ATLAS stream
self.data['glon'], self.data['glat'] = cel2gal(raw['ra'], raw['dec'])
def _load(self, filename):
raw = Vizier.get_catalogs('J/AJ/144/4')[0]
self.data.resize(len(raw))
self.data['name'] = raw['Name']
ra = np.array([map(float, hms.split()) for hms in raw['RAJ2000']])
dec = np.array([map(float, dms.split()) for dms in raw['DEJ2000']])
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
self.data[
'radius'] = raw['R1'] / 60.0 # Half-light radius along major axis
# Could also include elliticity 'Ell' and position angle 'PA'
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def _load(self,filename):
if filename is None:
filename = os.path.join(self.DATADIR,"VII_202/mwgc.dat")
kwargs = dict(delimiter=[12,12,3,3,6,5,3,6,8,8,6],dtype=2*['S12']+7*[float],skip_header=72,skip_footer=363)
raw = numpy.genfromtxt(filename,**kwargs)
self.data.resize(len(raw))
self.data['name'] = numpy.char.strip(raw['f0'])
ra = raw[['f2','f3','f4']].view(float).reshape(len(raw),-1)
dec = raw[['f5','f6','f7']].view(float).reshape(len(raw),-1)
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
glon,glat = cel2gal(self.data['ra'],self.data['dec'])
self.data['glon'],self.data['glat'] = glon,glat
def supplement(self,coordsys='gal'):
""" Add some supplemental columns """
from ugali.utils.projector import gal2cel, gal2cel_angle
from ugali.utils.projector import cel2gal, cel2gal_angle
coordsys = coordsys.lower()
kwargs = dict(usemask=False, asrecarray=True)
out = copy.deepcopy(self)
if ('lon' in out.names) and ('lat' in out.names):
# Ignore entries that are all zero
zeros = np.all(self.ndarray==0,axis=1)
if coordsys == 'gal':
ra,dec = gal2cel(out.lon,out.lat)
glon,glat = out.lon,out.lat
else:
ra,dec = out.lon,out.lat
glon,glat = cel2gal(out.lon,out.lat)
ra[zeros] = 0; dec[zeros] = 0
glon[zeros] = 0; glat[zeros] = 0
names = ['ra','dec','glon','glat']
arrs = [ra,dec,glon,glat]
out = mlab.rec_append_fields(out,names,arrs).view(Samples)
#out = recfuncs.append_fields(out,names,arrs,**kwargs).view(Samples)
if 'position_angle' in out.names:
if coordsys == 'gal':
pa_gal = out.position_angle
pa_cel = gal2cel_angle(out.lon,out.lat,out.position_angle)
pa_cel = pa_cel - 180.*(pa_cel > 180.)
else:
pa_gal = cel2gal_angle(out.lon,out.lat,out.position_angle)
pa_cel = out.position_angle
pa_gal = pa_gal - 180.*(pa_gal > 180.)
pa_gal[zeros] = 0; pa_cel[zeros] = 0
names = ['position_angle_gal','position_angle_cel']
arrs = [pa_gal,pa_cel]
out = recfuncs.append_fields(out,names,arrs,**kwargs).view(Samples)
return out
def _load(self, filename):
kwargs = dict(delimiter=',')
if filename is None:
filename = os.path.join(self.DATADIR, "extras/extra_clusters.csv")
self.filename = filename
raw = np.recfromcsv(filename, **kwargs)
if FILTER_DWARFS:
raw = raw[raw['name'] != 'Kim 2'] # Indus 1 (Kim 2)
pass
self.data.resize(len(raw))
self.data['name'] = raw['name']
self.data['ra'] = raw['ra']
self.data['dec'] = raw['dec']
self.data['radius'] = raw['rhalf'] / 60.0 # Half-light radius, arcmin
self.data['glon'], self.data['glat'] = cel2gal(raw['ra'], raw['dec'])
def _load(self, filename):
raw = Vizier.get_catalogs('J/A+A/558/A53')
if FILTER_DWARFS:
raw = [raw[0][raw[0]['MWSC'] != '2020'], raw[1],
raw[2]] # Coma Berenices (Melotte_111)
self.data.resize(len(raw[0]))
ids = np.array(map(int, raw[0]['MWSC'])) - 1
self.data['name'] = raw[1]['Name'][ids]
self.data['ra'] = raw[0]['RAJ2000']
self.data['dec'] = raw[0]['DEJ2000']
self.data['radius'] = raw[0]['r1'] # Radius of central part
# Could also use core radius 'r0' or radius 'r2'
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def _load(self, filename):
if filename is None:
filename = os.path.join(self.DATADIR,
"J_AJ_144_4/NearbyGalaxies.dat")
self.filename = filename
delimiter = [
19, 3, 3, 5, 3, 3, 3, 6, 6, 5, 5, 7, 5, 5, 5, 4, 4, 6, 5, 5, 5, 5,
5, 5, 4, 4, 7, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 5, 5, 6, 5,
5, 2
]
raw = np.genfromtxt(filename,
delimiter=delimiter,
usecols=list(range(7)) + [26],
dtype=['|S19'] + 7 * [float],
skip_header=36)
raw[['LMC' in name for name in raw['f0']
].index(True)]['f7'] = 540.0 # LMC radius = 9 deg
raw[['SMC' in name for name in raw['f0']
].index(True)]['f7'] = 180.0 # LMC radius = 3 deg
raw[['Bootes III' in name for name in raw['f0']
].index(True)]['f7'] = 60.0 # Bootes III radius = 1 deg
self.data.resize(len(raw))
self.data['name'] = np.char.lstrip(np.char.strip(raw['f0']), '*')
ra = raw[['f1', 'f2', 'f3']].view(float).reshape(len(raw), -1)
dec = raw[['f4', 'f5', 'f6']].view(float).reshape(len(raw), -1)
self.data['ra'] = ugali.utils.projector.hms2dec(ra)
self.data['dec'] = ugali.utils.projector.dms2dec(dec)
radius = raw['f7']
# McConnachie sets "bad" radius to either 99.99 or 9.999
bad_r = np.nan # arcmin
radius = np.array(
[r if set(str(r)) != set('9.') else bad_r for r in radius])
self.data[
'radius'] = radius / 60.0 # Half-light radius along major axis
# Could also include ellipticity and position angle
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def parse_targets(filename):
"""
Load a text file with target coordinates. Returns
an array of target locations in Galactic coordinates.
File description:
[NAME] [LON] [LAT] [RADIUS] [COORD]
The values of LON and LAT will depend on COORD:
COORD = [GAL | CEL | HPX ],
LON = [GLON | RA | NSIDE]
LAT = [GLAT | DEC | PIX ]
"""
base,ext = os.path.splitext(filename)
if ext == '.fits':
f = pyfits.open(filename)
data = f[1].data.view(np.recarray)
data = recfuncs.append_fields(data,'RADIUS',np.zeros(len(data)),usemask=False)
return data['NAME'],data[['GLON','GLAT','RADIUS']]
elif (ext=='.txt') or (ext=='.dat'):
data = np.loadtxt(filename,unpack=True,usecols=range(5),dtype=object)
# Deal with one-line input files
if data.ndim == 1: data = np.array([data]).T
names = data[0]
out = data[1:4].astype(float)
lon,lat,radius = out
coord = np.array([s.lower() for s in data[4]])
gal = (coord=='gal')
cel = (coord=='cel')
hpx = (coord=='hpx')
if cel.any():
glon,glat = cel2gal(lon[cel],lat[cel])
out[0][cel] = glon
out[1][cel] = glat
if hpx.any():
glon,glat = pix2ang(lat[hpx],lon[hpx])
out[0][hpx] = glon
out[1][hpx] = glat
return names,out.T
def parse_targets(filename):
"""
Load a text file with target coordinates. Returns
an array of target locations in Galactic coordinates.
File description:
[NAME] [LON] [LAT] [RADIUS] [COORD]
The values of LON and LAT will depend on COORD:
COORD = [GAL | CEL | HPX ],
LON = [GLON | RA | NSIDE]
LAT = [GLAT | DEC | PIX ]
"""
base,ext = os.path.splitext(filename)
if ext == '.fits':
f = pyfits.open(filename)
data = f[1].data.view(np.recarray)
data = recfuncs.append_fields(data,'RADIUS',np.zeros(len(data)),usemask=False)
return data['NAME'],data[['GLON','GLAT','RADIUS']]
elif (ext=='.txt') or (ext=='.dat'):
data = np.loadtxt(filename,unpack=True,usecols=list(range(5)),dtype=object)
# Deal with one-line input files
if data.ndim == 1: data = np.array([data]).T
names = data[0]
out = data[1:4].astype(float)
lon,lat,radius = out
coord = np.array([s.lower() for s in data[4]])
gal = (coord=='gal')
cel = (coord=='cel')
hpx = (coord=='hpx')
if cel.any():
glon,glat = cel2gal(lon[cel],lat[cel])
out[0][cel] = glon
out[1][cel] = glat
if hpx.any():
glon,glat = pix2ang(lat[hpx],lon[hpx])
out[0][hpx] = glon
out[1][hpx] = glat
return names,out.T
def _load(self,filename):
if filename is None:
filename = os.path.join(self.DATADIR,"VII_26D/catalog.dat")
raw = np.genfromtxt(filename,delimiter=[3,7,2,4,3,2],dtype=['S3']+['S7']+4*[float])
self.data.resize(len(raw))
self.data['name'] = numpy.char.mod('UGC %s',numpy.char.strip(raw['f1']))
ra = raw[['f2','f3']].view(float).reshape(len(raw),-1)
ra = np.vstack([ra.T,np.zeros(len(raw))]).T
dec = raw[['f4','f5']].view(float).reshape(len(raw),-1)
dec = np.vstack([dec.T,np.zeros(len(raw))]).T
ra1950 = ugali.utils.projector.hms2dec(ra)
dec1950 = ugali.utils.projector.dms2dec(dec)
ra2000,dec2000 = ugali.utils.idl.jprecess(ra1950,dec1950)
self.data['ra'] = ra2000
self.data['dec'] = dec2000
glon,glat = cel2gal(self.data['ra'],self.data['dec'])
self.data['glon'],self.data['glat'] = glon,glat
def _load(self, filename):
catalog = Vizier.get_catalogs('VII/151')
raw = astropy.table.vstack([catalog[0], catalog[2]],
metadata_conflicts='silent')
self.data.resize(len(raw))
self.data['name'] = np.char.join(' ', np.char.split(raw['Name1']))
ra = np.array([map(float, hms.split()) for hms in raw['RA1950']])
dec = np.array([map(float, dms.split()) for dms in raw['DE1950']])
dec = np.vstack([dec.T, np.zeros(len(raw))]).T
ra1950 = ugali.utils.projector.hms2dec(ra)
dec1950 = ugali.utils.projector.dms2dec(dec)
ra2000, dec2000 = ugali.utils.idl.jprecess(ra1950, dec1950)
self.data['ra'] = ra2000
self.data['dec'] = dec2000
self.data['radius'] = (10**np.array(raw['lgtt'])) / 60.0 # log(radius)
# Could also use log(core radius) 'lgtc'
glon, glat = cel2gal(self.data['ra'], self.data['dec'])
self.data['glon'], self.data['glat'] = glon, glat
def finalizeObjects(self, objects):
objs = numpy.recarray(len(objects),
dtype=[
('NAME', 'S24'),
('TS', 'f4'),
('GLON', 'f4'),
('GLAT', 'f4'),
('RA', 'f4'),
('DEC', 'f4'),
('MODULUS', 'f4'),
('DISTANCE', 'f4'),
('RICHNESS', 'f4'),
('MASS', 'f4'),
('NANNULUS', 'i4'),
('NINTERIOR', 'i4'),
])
objs['TS'] = self.values[objects['IDX_MAX'], objects['ZIDX_MAX']]
lon, lat = objects['X_MAX'], objects['Y_MAX']
coordsys = self.config['coords']['coordsys']
if coordsys.lower() == 'gal':
print("GAL coordintes")
objs['GLON'], objs['GLAT'] = lon, lat
objs['RA'], objs['DEC'] = gal2cel(lon, lat)
else:
print("CEL coordintes")
objs['RA'], objs['DEC'] = lon, lat
objs['GLON'], objs['GLAT'] = cel2gal(lon, lat)
modulus = objects['Z_MAX']
objs['MODULUS'] = modulus
objs['DISTANCE'] = mod2dist(modulus)
nside = healpy.npix2nside(len(self.nannulus))
pix = ang2pix(nside, lon, lat)
richness = self.richness[objects['IDX_MAX'], objects['ZIDX_MAX']]
objs['RICHNESS'] = richness
objs['MASS'] = richness * self.stellar[pix]
objs['NANNULUS'] = self.nannulus[pix].astype(int)
objs['NINTERIOR'] = self.ninterior[pix].astype(int)
# Default name formatting
# http://cdsarc.u-strasbg.fr/ftp/pub/iau/
# http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx
fmt = "J%(hour)02i%(hmin)04.1f%(deg)+03i%(dmin)02i"
for obj, _ra, _dec in zip(objs, objs['RA'], objs['DEC']):
hms = dec2hms(_ra)
dms = dec2dms(_dec)
params = dict(hour=hms[0],
hmin=hms[1] + hms[2] / 60.,
deg=dms[0],
dmin=dms[1] + dms[2] / 60.)
obj['NAME'] = fmt % params
out = recfuncs.merge_arrays([objs, objects],
usemask=False,
asrecarray=True,
flatten=True)
return out
def match(self,lon,lat,coord='gal',tol=0.1,nnearest=1):
if coord.lower() == 'cel':
glon, glat = cel2gal(lon,lat)
else:
glon,glat = lon, lat
return ugali.utils.projector.match(glon,glat,self['glon'],self['glat'],tol,nnearest)
def glon_glat(self):
if self.coordsys == 'gal': return self.lon,self.lat
else: return cel2gal(self.lon,self.lat)
def get_results(self, **kwargs):
kwargs.setdefault('alpha', self.alpha)
kwargs.setdefault('burn', self.nburn * self.nwalkers)
# Calculate best-fit parameters from MCMC chain
logger.debug('Estimating parameters...')
estimate = self.estimate_params(**kwargs)
params = {k: v[0] for k, v in estimate.items()}
results = dict(estimate)
# Extra parameters from the MCMC chain
logger.debug('Estimating auxiliary parameters...')
logger.debug("alpha = %.2f" % kwargs['alpha'])
results['alpha'] = kwargs['alpha']
try:
results['ra'] = self.estimate('ra', **kwargs)
results['dec'] = self.estimate('dec', **kwargs)
results['glon'] = self.estimate('glon', **kwargs)
results['glat'] = self.estimate('glat', **kwargs)
except KeyError:
logger.warn("Didn't find 'ra' or 'dec' in Samples...")
if self.coordsys == 'gal':
results['glon'] = results['lon']
results['glat'] = results['lat']
ra, dec = gal2cel(results['lon'][0], results['lat'][0])
results['ra'] = ugali.utils.stats.interval(ra)
results['dec'] = ugali.utils.stats.interval(dec)
else:
results['ra'] = results['lon']
results['dec'] = results['lat']
glon, glat = cel2gal(results['lon'][0], results['lat'][0])
results['glon'] = ugali.utils.stats.interval(glon)
results['glat'] = ugali.utils.stats.interval(glat)
lon, lat = results['lon'][0], results['lat'][0]
ra, dec = results['ra'][0], results['dec'][0]
glon, glat = results['glon'][0], results['glat'][0]
results.update(gal=[float(glon), float(glat)])
results.update(cel=[float(ra), float(dec)])
try:
results['position_angle_cel'] = self.estimate(
'position_angle_cel', **kwargs)
except KeyError:
results['position_angle_cel'] = ugali.utils.stats.interval(np.nan)
# Update the loglike to the best-fit parameters from the chain
logger.debug('Calculating TS...')
ts = 2 * self.loglike.value(**params)
results['ts'] = ugali.utils.stats.interval(ts, np.nan, np.nan)
# Celestial position angle
# Break ambiguity in direction with '% 180.'
pa, pa_err = results['position_angle']
pa_cel = gal2cel_angle(lon, lat, pa) % 180.
pa_cel_err = np.array(pa_err) - pa + pa_cel
results['position_angle_cel'] = ugali.utils.stats.interval(
pa_cel, pa_cel_err[0], pa_cel_err[1])
mod, mod_err = estimate['distance_modulus']
dist = mod2dist(mod)
dist_lo, dist_hi = [mod2dist(mod_err[0]), mod2dist(mod_err[1])]
results['distance'] = ugali.utils.stats.interval(
dist, dist_lo, dist_hi)
dist, dist_err = results['distance']
ext, ext_err = estimate['extension']
ext_sigma = np.nan_to_num(np.array(ext_err) - ext)
results['extension_arcmin'] = ugali.utils.stats.interval(
60 * ext, 60 * ext_err[0], 60 * ext_err[1])
# Radially symmetric extension (correct for ellipticity).
ell, ell_err = estimate['ellipticity']
rext, rext_err = ext * np.sqrt(1 -
ell), np.array(ext_err) * np.sqrt(1 -
ell)
rext_sigma = np.nan_to_num(np.array(rext_err) - rext)
results['extension_radial'] = ugali.utils.stats.interval(
rext, rext_err[0], rext_err[1])
results['extension_radial_arcmin'] = ugali.utils.stats.interval(
60 * rext, 60 * rext_err[0], 60 * rext_err[1])
# Bayes factor for ellipticity
results['ellipticity_bayes_factor'] = self.bayes_factor(
'ellipticity', burn=kwargs['burn'])
# Physical Size (should do this with the posteriors)
# Radially symmetric
dist_sigma = np.nan_to_num(np.array(dist_err) - dist)
size = np.arctan(np.radians(ext)) * dist
size_sigma = size * np.sqrt((ext_sigma / ext)**2 +
(dist_sigma / dist)**2)
size_err = [size - size_sigma[0], size + size_sigma[1]]
results['physical_size'] = ugali.utils.stats.interval(
size, size_err[0], size_err[1])
rsize = np.arctan(np.radians(rext)) * dist
rsize_sigma = rsize * np.sqrt((rext_sigma / rext)**2 +
(dist_sigma / dist)**2)
rsize_err = [rsize - rsize_sigma[0], rsize + rsize_sigma[1]]
results['physical_size_radial'] = ugali.utils.stats.interval(
rsize, rsize_err[0], rsize_err[1])
# Richness
rich, rich_err = estimate['richness']
# Number of observed stars (sum of p-values)
nobs = self.loglike.p.sum()
nobs_lo, nobs_hi = nobs + np.sqrt(nobs) * np.array([-1, 1])
results['nobs'] = ugali.utils.stats.interval(nobs, nobs_lo, nobs_hi)
# Number of predicted stars (pixelization effects?)
npred = self.loglike.f * rich
npred_lo, npred_hi = rich_err[0] * self.loglike.f, rich_err[
1] * self.loglike.f
results['npred'] = ugali.utils.stats.interval(npred, npred_lo,
npred_hi)
# Careful, depends on the isochrone...
stellar_mass = self.source.stellar_mass()
mass = rich * stellar_mass
mass_lo, mass_hi = rich_err[0] * stellar_mass, rich_err[
1] * stellar_mass
results['mass'] = ugali.utils.stats.interval(mass, mass_lo, mass_hi)
stellar_luminosity = self.source.stellar_luminosity()
lum = rich * stellar_luminosity
lum_lo, lum_hi = rich_err[0] * stellar_luminosity, rich_err[
1] * stellar_luminosity
results['luminosity'] = ugali.utils.stats.interval(lum, lum_lo, lum_hi)
# Absolute magnitude only calculated for DES isochrones with g,r
try:
Mv = self.source.absolute_magnitude(rich)
Mv_lo = self.source.absolute_magnitude(rich_err[0])
Mv_hi = self.source.absolute_magnitude(rich_err[1])
results['Mv'] = ugali.utils.stats.interval(Mv, Mv_lo, Mv_hi)
except ValueError as e:
logger.warning("Skipping absolute magnitude")
logger.warn(str(e))
Mv = np.nan
results['Mv'] = Mv
mu = surfaceBrightness(Mv, rsize, dist) ##updated from size-->rsize
results['surface_brightness'] = ugali.utils.stats.interval(
mu, np.nan, np.nan)
# ADW: WARNING this is very fragile.
# Also, this is not quite right, should cut on the CMD available space
kwargs = dict(richness=rich,
mag_bright=16.,
mag_faint=23.,
n_trials=5000,
alpha=kwargs['alpha'],
seed=0)
martin = self.config['results'].get('martin')
if martin:
logger.info("Calculating Martin magnitude...")
if martin > 1: kwargs['n_trials'] = martin
Mv_martin = self.source.isochrone.absolute_magnitude_martin(
**kwargs)
results['Mv_martin'] = Mv_martin
mu_martin = surfaceBrightness(Mv_martin, rsize,
dist) ##updated from size-->rsize
results['surface_brightness_martin'] = ugali.utils.stats.interval(
mu_martin, np.nan, np.nan)
else:
logger.warning("Skipping Martin magnitude")
results['Mv_martin'] = np.nan
results['surface_brightness_martin'] = np.nan
try:
results['constellation'] = ang2const(lon, lat, self.coordsys)[1]
except:
pass
results['iau'] = ugali.utils.projector.ang2iau(lon, lat, self.coordsys)
coord = SkyCoord(ra * u.deg, dec * u.deg, distance=dist * u.kpc)
results['ra_sex'] = str(coord.ra.to_string())
results['dec_sex'] = str(coord.dec.to_string())
# Calculate some separations from GC, LMC, SMC
#NED coordinates with de Grisj distance
LMC = SkyCoord(80.8939 * u.deg,
-69.7561 * u.deg,
distance=49.89 * u.kpc)
#NED coordinates with de Grisj distance
SMC = SkyCoord(13.1866 * u.deg,
-72.8286 * u.deg,
distance=61.94 * u.kpc)
# GC from astropy?
GC = SkyCoord(266.4168262 * u.deg,
-29.0077969 * u.deg,
distance=8.0 * u.kpc)
results['d_gc'] = coord.separation_3d(GC).value
results['d_lmc'] = coord.separation_3d(LMC).value
results['d_smc'] = coord.separation_3d(SMC).value
try:
results['feh'] = float(self.source.isochrone.feh)
except:
results['feh'] = np.nan
output = dict()
output['params'] = params
output['results'] = results
return output
def pixelizeCatalog(infiles, config, force=False):
"""
Break catalog into chunks by healpix pixel.
Parameters:
-----------
infiles : List of input files
config : Configuration file
force : Overwrite existing files (depricated)
Returns:
--------
None
"""
nside_catalog = config['coords']['nside_catalog']
nside_pixel = config['coords']['nside_pixel']
coordsys = config['coords']['coordsys'].upper()
outdir = mkdir(config['catalog']['dirname'])
filenames = config.getFilenames()
lon_field = config['catalog']['lon_field'].upper()
lat_field = config['catalog']['lat_field'].upper()
# ADW: It would probably be better (and more efficient) to do the
# pixelizing and the new column insertion separately.
for i,filename in enumerate(infiles):
logger.info('(%i/%i) %s'%(i+1, len(infiles), filename))
data = fitsio.read(filename)
logger.info("%i objects found"%len(data))
if not len(data): continue
columns = map(str.upper,data.dtype.names)
names,arrs = [],[]
if (lon_field in columns) and (lat_field in columns):
lon,lat = data[lon_field],data[lat_field]
elif coordsys == 'GAL':
msg = "Columns '%s' and '%s' not found."%(lon_field,lat_field)
msg += "\nConverting from RA,DEC"
logger.warning(msg)
lon,lat = cel2gal(data['RA'],data['DEC'])
names += [lon_field,lat_field]
arrs += [lon,lat]
elif coordsys == 'CEL':
msg = "Columns '%s' and '%s' not found."%(lon_field,lat_field)
msg += "\nConverting from GLON,GLAT"
lon,lat = gal2cel(data['GLON'],data['GLAT'])
names += [lon_field,lat_field]
arrs += [lon,lat]
cat_pix = ang2pix(nside_catalog,lon,lat)
pix_pix = ang2pix(nside_pixel,lon,lat)
cat_pix_name = 'PIX%i'%nside_catalog
pix_pix_name = 'PIX%i'%nside_pixel
try:
names += [cat_pix_name,pix_pix_name]
arrs += [cat_pix,pix_pix]
data=mlab.rec_append_fields(data,names=names,arrs=arrs)
except ValueError as e:
logger.warn(str(e)+'; not adding column.')
#data[cat_pix_name] = cat_pix
#data[pix_pix_name] = pix_pix
for pix in np.unique(cat_pix):
logger.debug("Processing pixel %s"%pix)
arr = data[cat_pix == pix]
outfile = filenames.data['catalog'][pix]
if not os.path.exists(outfile):
logger.debug("Creating %s"%outfile)
out=fitsio.FITS(outfile,mode='rw')
out.write(arr)
hdr=healpix.header_odict(nside=nside_catalog,
coord=coordsys[0])
for key in ['PIXTYPE','ORDERING','NSIDE','COORDSYS']:
out[1].write_key(*list(hdr[key].values()))
out[1].write_key('PIX',pix,comment='HEALPIX pixel for this file')
else:
out=fitsio.FITS(outfile,mode='rw')
out[1].append(arr)
logger.debug("Writing %s"%outfile)
out.close()
