def check_readwritereadqueals(f1):
s1 = sl.read_dao_file(f1)
d = tmpdir()
f2 = path.join(d.path, 'tmp' + s1.DAO_type.extension)
sl.write_dao_file(s1, f2)
s2 = sl.read_dao_file(f2)
assert s1.equals(s2)
def check_readwritereadqueals(f1):
s1 = sl.read_dao_file(f1)
d = tmpdir()
f2 = path.join(d.path, 'tmp' + s1.DAO_type.extension)
sl.write_dao_file(s1, f2)
s2 = sl.read_dao_file(f2)
assert s1.equals(s2)
def test_convert_ap_to_als():
s1 = sl.read_dao_file(data.als_file())
d = tmpdir()
f2 = path.join(d.path, 'tmp' + '.als')
sl.write_dao_file(s1, f2, sl.DAO.ALS_FILE)
s2 = sl.read_dao_file(f2)
cols_to_compare = ['id', 'x', 'y', 'mag', 'sky']
assert s1.round(4)[cols_to_compare].equals(s2.round(4)[cols_to_compare])
def test_convert_ap_to_als():
s1 = sl.read_dao_file(data.als_file())
d = tmpdir()
f2 = path.join(d.path, 'tmp' + '.als')
sl.write_dao_file(s1, f2, sl.DAO.ALS_FILE)
s2 = sl.read_dao_file(f2)
cols_to_compare = ['id', 'x', 'y', 'mag', 'sky']
assert s1.round(4)[cols_to_compare].equals(s2.round(4)[cols_to_compare])
def test_gapick_short():
d = TmpDir()
r = main(
ga_max_iter=2, # just two iteration of GA
ga_pop=15, # small population
overwrite=True,
out_dir=d.path,
fine=True,
)
assert (r.count() > 10)
ap = read_dao_file(path.join(d.path, 'i.ap'))
lst = read_dao_file(path.join(d.path, 'gen_last.lst'))
coo = read_dao_file(path.join(d.path, 'i.coo'))
nei = read_dao_file(path.join(d.path, 'i.nei'))
reg = read_ds9_regions(path.join(d.path, 'gen_last.reg'))
def __do(arg):
s = sl.read_dao_file(stdin)
sl.write_ds9_regions(s,
stdout,
color=arg.color,
width=arg.width,
size=arg.size)
def test_read_write_ds9():
s1 = sl.read_dao_file(data.ap_file())
d = tmpdir()
f2 = path.join(d.path, 'i.reg')
sl.write_ds9_regions(s1, f2)
s2 = sl.read_ds9_regions(f2)
assert s2[['id', 'x', 'y']].equals(s1[['id', 'x', 'y']])
assert not s2.auto_id.any()
def test_gapick_short():
d = TmpDir()
r = main(
ga_max_iter = 2, # just two iteration of GA
ga_pop = 15, # small population
overwrite = True,
out_dir = d.path,
fine = False,
demo=True,
)
assert (r.stars_number() > 10)
ap = read_dao_file(path.join(d.path, 'i.ap'))
lst = read_dao_file(path.join(d.path, 'gen_last.lst'))
coo = read_dao_file(path.join(d.path, 'i.coo'))
nei = read_dao_file(path.join(d.path, 'i.nei'))
reg = read_ds9_regions(path.join(d.path, 'gen_last.reg'))
def photometry_starlist(self):
"""StarList with photometry
:rtype: astwro.starlist.StarList
"""
if self.__starlist is None and self.photometry_file:
self.__starlist = read_dao_file(self.photometry_file)
return self.__starlist
def photometry_starlist(self):
"""StarList with photometry
:rtype: astwro.starlist.StarList
"""
if self.__starlist is None and self.photometry_file:
self.__starlist = read_dao_file(self.photometry_file)
return self.__starlist
def test_read_write_ds9():
s1 = sl.read_dao_file(data.ap_file())
d = tmpdir()
f2 = path.join(d.path, 'i.reg')
sl.write_ds9_regions(s1, f2)
s2 = sl.read_ds9_regions(f2)
assert s2[['id', 'x', 'y']].equals(s1[['id', 'x', 'y']])
assert not s2.auto_id.any()
def read_starlist(self, filepath, **kwargs):
# type: ([str], []) -> sl.StarList
"""
Returns `StarList` object with stars extracted from daophot files
:param [str] filepath: source file for starlist, if filename without path is provided, runner directory is assumed.
:param kwargs: additional parameters for extra processing in subclasses e.g. add_psf_errors=True
:rtype: starlist.StarList
"""
s = sl.read_dao_file(self.absolute_path(filepath))
return self._process_starlist(s, **kwargs)
def read_starlist(self, filepath, **kwargs):
# type: ([str], []) -> sl.StarList
"""
Returns `StarList` object with stars extracted from daophot files
:param [str] filepath: source file for starlist, if filename without path is provided, runner directory is assumed.
:param kwargs: additional parameters for extra processing in subclasses e.g. add_psf_errors=True
:rtype: starlist.StarList
"""
s = sl.read_dao_file(self.absolute_path(filepath))
return self._process_starlist(s, **kwargs)
def __do(args):
# 1 do daophot aperture and psf photometry and run allstar
dp = daophot(image_file=args.image)
dp.copy_to_runner_dir(args.coo, fname.COO_FILE)
dp.PHotometry()
dp.copy_to_runner_dir(args.lst, fname.LST_FILE)
dp.PSf()
dp.run(wait=True)
al = allstar(dp.dir)
al.run()
all_s = read_dao_file(al.file_from_runner_dir(fname.ALS_FILE))
# all_s.hist('chi')
return sigmaclip(all_s.chi)[0].mean()
def __do(arg):
# TODO: __do arguments - in/out files/streams
i = stdin
o = stdout
# http://stackoverflow.com/questions/14207708/ioerror-errno-32-broken-pipe-python
from signal import signal, SIGPIPE, SIG_DFL
signal(SIGPIPE, SIG_DFL)
if arg.input_format:
arg.input_format = arg.input_format.upper()
if arg.output_format:
arg.output_format = arg.output_format.upper()
if arg.input_format == 'DS9':
s = sl.read_ds9_regions(i)
else:
daotype = None
if arg.input_format == 'COO':
daotype = sl.DAO.COO_FILE
elif arg.input_format == 'SHORT':
daotype = sl.DAO.SHORT_FILE
s = sl.read_dao_file(i, dao_type=daotype)
if arg.verbose:
print ('Columns of input file: {}'.format(s.columns), file=stderr)
if arg.sort is not None:
s.sort_values(s.columns[arg.sort], ascending=not arg.descending, inplace=True)
if arg.verbose:
print ('Sorting by {}'.format(s.columns[arg.sort]), file=stderr)
if arg.output_format == 'DS9':
sl.write_ds9_regions(s, o)
else:
daotype = sl.DAO.UNKNOWN_FILE
if arg.output_format == 'COO':
daotype = sl.DAO.COO_FILE
elif arg.output_format == 'SHORT':
daotype = sl.DAO.SHORT_FILE
sl.write_dao_file(s, o, dao_type=daotype)
return sl
def test_read_als():
s = sl.read_dao_file(data.als_file())
check_starlist_daotype(s, sl.DAO.ALS_FILE)
def test_read_ap():
s = sl.read_dao_file(data.ap_file())
check_starlist_daotype(s, sl.DAO.AP_FILE)
def test_read_nei():
s = sl.read_dao_file(data.nei_file())
check_starlist_daotype(s, sl.DAO.NEI_FILE)
def test_read_lst():
s = sl.read_dao_file(data.lst_file())
check_starlist_daotype(s, sl.DAO.LST_FILE)
def picked_starlist(self):
"""StarList with picked stars"""
if self.__starlist is None and self.picked_stars_file:
self.__starlist = read_dao_file(self.picked_stars_file)
return self.__starlist
def test_read_nei():
s = sl.read_dao_file(data.nei_file())
check_starlist_daotype(s, sl.DAO.NEI_FILE)
def test_read_coo():
s = sl.read_dao_file(data.coo_file())
check_starlist_daotype(s, sl.DAO.COO_FILE)
def test_read_als():
s = sl.read_dao_file(data.als_file())
check_starlist_daotype(s, sl.DAO.ALS_FILE)
def __do(arg):
s = sl.read_dao_file(stdin)
sl.write_ds9_regions(s, stdout, color=arg.color, width=arg.width, size=arg.size)
def als_stars(self):
# type: () -> {astwro.starlist.StarList}
"""StarList of stars with profile photometry results """
if self.__als_stars is None and self.profile_photometry_file:
self.__als_stars = read_dao_file(self.profile_photometry_file)
return self.__als_stars
def neda_starlist(self):
"""stars list with neda photometry"""
if self.__nedalist is None and self.neda_file:
self.__nedalist = read_dao_file(self.neda_file)
return self.__nedalist
def nei_starlist(self):
"""StarList with neighbours stars"""
if self.__neilist is None and self.nei_file:
self.__neilist = read_dao_file(self.nei_file)
return self.__neilist
def picked_starlist(self):
"""StarList with picked stars"""
if self.__starlist is None and self.picked_stars_file:
self.__starlist = read_dao_file(self.picked_stars_file)
return self.__starlist
from __future__ import print_function
import astwro.starlist as sl
import sys
s = sl.read_dao_file('i.lst')
print (s)
sl.write_dao_file(s, sys.stdout, sl.DAO.LST_FILE)
def als_stars(self):
# type: () -> {astwro.starlist.StarList}
"""StarList of stars with profile photometry results """
if self.__als_stars is None and self.profile_photometry_file:
self.__als_stars = read_dao_file(self.profile_photometry_file)
return self.__als_stars
def test_read_lst():
s = sl.read_dao_file(data.lst_file())
check_starlist_daotype(s, sl.DAO.LST_FILE)
def test_read_coo():
s = sl.read_dao_file(data.coo_file())
check_starlist_daotype(s, sl.DAO.COO_FILE)
def test_read_ap():
s = sl.read_dao_file(data.ap_file())
check_starlist_daotype(s, sl.DAO.AP_FILE)
def found_starlist(self):
"""StarList with found stars"""
if self.__starlist is None and self.starlist_file:
self.__starlist = read_dao_file(self.starlist_file)
return self.__starlist
def found_starlist(self):
"""StarList with found stars"""
if self.__starlist is None and self.starlist_file:
self.__starlist = read_dao_file(self.starlist_file)
return self.__starlist
def nei_starlist(self):
"""StarList with neighbours stars"""
if self.__neilist is None and self.nei_file:
self.__neilist = read_dao_file(self.nei_file)
return self.__neilist
# time for allstar
population_alls = [
allstar(dir=d.dir, allstaropt=aopt, create_subtracted_image=False)
for d in population
]
# run them same way
for n in range(0, len(population_alls), run_parallel):
for d in population_alls[n:n + run_parallel]: # run group
d.run(wait=False)
for d in population_alls[n:n + run_parallel]: # wait for group
d.wait_for_results()
print(d.output)
# measure results and chose the best
scores = np.zeros_like(population)
for i, d in enumerate(population):
conv_stars = read_dao_file(d.file_from_runner_dir(fname.ALS_FILE))
psf_stars = read_dao_file(d.file_from_runner_dir(fname.LST_FILE))
result = {
'n': len(log),
'conv_stars': len(conv_stars), # converged by allstar
'psf_stars': len(psf_stars), # pdf stars
'als_chi': conv_stars['chi'].mean(), # mean of chi form ALS
'psf_chi': d.PSf_result.chi, # chi from daophot PS
'removed_star': 0
}
scores[i] = score_function(result)
log.append(result)
if counter % 8 == 0:
print('Done:{:5d}'.format(counter))
counter += 1
# and the winner is....
def neda_starlist(self):
"""stars list with neda photometry"""
if self.__nedalist is None and self.neda_file:
self.__nedalist = read_dao_file(self.neda_file)
return self.__nedalist