def test_sizemag_plot():
"""Check a size-magnitude plot.
"""
if __name__ == '__main__':
logger = piff.config.setup_logger(2)
else:
logger = piff.config.setup_logger(
log_file='output/test_sizemag_plot.log')
config = piff.config.read_config('sizemag.yaml')
file_name = os.path.join('output',
config['output']['stats'][0]['file_name'])
# Some modifications to speed it up a bit.
config['select'] = {
'type': 'Properties',
'where': '(CLASS_STAR > 0.9) & (MAG_AUTO < 13)',
'hsm_size_reject': 4,
'min_snr': 50,
}
config['psf']['interp'] = {'type': 'Mean'}
config['psf']['outliers']['nsigma'] = 10
del config['output']['stats'][1:]
# Run via piffify
piff.piffify(config, logger)
assert os.path.isfile(file_name)
# repeat with plotify function
os.remove(file_name)
piff.plotify(config, logger)
assert os.path.isfile(file_name)
def test_twodstats_config():
"""Test running stats through a config file.
"""
if __name__ == '__main__':
logger = piff.config.setup_logger(verbose=2)
else:
logger = piff.config.setup_logger(
log_file='output/test_twodstats_config.log')
image_file = os.path.join('output', 'test_stats_image.fits')
cat_file = os.path.join('output', 'test_stats_cat.fits')
psf_file = os.path.join('output', 'test_twodstats.fits')
twodhist_file = os.path.join('output', 'test_twodhiststats.pdf')
twodhist_std_file = os.path.join('output', 'test_twodhiststats_std.pdf')
config = {
'input': {
'image_file_name': image_file,
'cat_file_name': cat_file,
'stamp_size': 48
},
'psf': {
'model': {
'type': 'Gaussian',
'fastfit': True,
'include_pixel': False
},
'interp': {
'type': 'Mean'
},
},
'output': {
'file_name':
psf_file,
'stats': [
{
'type': 'TwoDHist',
'file_name': twodhist_file,
'nbins_u': 3,
'nbins_v': 3,
},
{
'type': 'TwoDHist',
'file_name': twodhist_std_file,
'reducing_function': 'np.std',
'nbins_u': 3,
'nbins_v': 3,
},
]
}
}
piff.piffify(config, logger)
assert os.path.isfile(twodhist_file)
assert os.path.isfile(twodhist_std_file)
# repeat with plotify function
os.remove(twodhist_file)
os.remove(twodhist_std_file)
piff.plotify(config, logger)
assert os.path.isfile(twodhist_file)
assert os.path.isfile(twodhist_std_file)
def test_shapestats_config():
"""Test running stats through a config file.
"""
if __name__ == '__main__':
logger = piff.config.setup_logger(verbose=2)
else:
logger = piff.config.setup_logger(log_file='output/test_shapestats_config.log')
image_file = os.path.join('output','test_stats_image.fits')
cat_file = os.path.join('output','test_stats_cat.fits')
psf_file = os.path.join('output','test_shapestats.fits')
shape_file = os.path.join('output','test_shapestats.pdf')
config = {
'input' : {
'image_file_name' : image_file,
'cat_file_name' : cat_file,
'stamp_size' : 48
},
'psf' : {
'model' : { 'type' : 'Gaussian',
'fastfit': True,
'include_pixel': False },
'interp' : { 'type' : 'Mean' },
},
'output' : {
'file_name' : psf_file,
'stats' : [
{
'type': 'ShapeHistograms',
'file_name': shape_file
},
]
},
}
piff.piffify(config, logger)
assert os.path.isfile(shape_file)
# repeat with plotify function
os.remove(shape_file)
piff.plotify(config, logger)
assert os.path.isfile(shape_file)
# Test ShapeHistogramStats directly
psf = piff.read(psf_file)
shapeStats = piff.ShapeHistogramsStats()
orig_stars, wcs, pointing = piff.Input.process(config['input'], logger)
shapeStats.compute(psf, orig_stars)
# test their characteristics
sigma = 1.3 # (copied from setup())
g1 = 0.23
g2 = -0.17
np.testing.assert_array_almost_equal(sigma, shapeStats.T, decimal=4)
np.testing.assert_array_almost_equal(sigma, shapeStats.T_model, decimal=3)
np.testing.assert_array_almost_equal(g1, shapeStats.g1, decimal=4)
np.testing.assert_array_almost_equal(g1, shapeStats.g1_model, decimal=3)
np.testing.assert_array_almost_equal(g2, shapeStats.g2, decimal=4)
np.testing.assert_array_almost_equal(g2, shapeStats.g2_model, decimal=3)
def test_invalid_config():
# Test a few invalid uses of the config parsing.
if __name__ == '__main__':
logger = piff.config.setup_logger(verbose=2)
else:
logger = piff.config.setup_logger(log_file='output/test_invalid_config.log')
image_file = os.path.join('output','simple_image.fits')
cat_file = os.path.join('output','simple_cat.fits')
psf_file = os.path.join('output','simple_psf.fits')
config = {
'input' : {
'image_file_name' : image_file,
'cat_file_name' : cat_file,
'flag_col' : 'flag',
'use_flag' : 1,
'skip_flag' : 4,
},
'psf' : {
'model' : { 'type' : 'Gaussian',
'fastfit': True,
'include_pixel': False},
'interp' : { 'type' : 'Mean' },
'max_iter' : 10,
'chisq_thresh' : 0.2,
},
'output' : { 'file_name' : psf_file },
}
# Invalid variable specification
with np.testing.assert_raises(ValueError):
piff.parse_variables(config, ['verbose:0'], logger=logger)
# process needs both input and psf
with np.testing.assert_raises(ValueError):
piff.process(config={'input':config['input']}, logger=logger)
with np.testing.assert_raises(ValueError):
piff.process(config={'psf':config['psf']}, logger=logger)
# piffify also needs output
with np.testing.assert_raises(ValueError):
piff.piffify(config={'input':config['input']}, logger=logger)
with np.testing.assert_raises(ValueError):
piff.piffify(config={'psf':config['psf']}, logger=logger)
with np.testing.assert_raises(ValueError):
piff.piffify(config={'input':config['input'], 'psf':config['psf']}, logger=logger)
# plotify doesn't need psf, but needs a 'file_name' in output
with np.testing.assert_raises(ValueError):
piff.plotify(config={'input':config['input']}, logger=logger)
with np.testing.assert_raises(ValueError):
piff.plotify(config={'input':config['input'], 'output':{}}, logger=logger)
# Error if missing either model or interp
config2 = copy.deepcopy(config)
del config2['psf']['model']
with np.testing.assert_raises(ValueError):
piff.piffify(config2, logger)
config2['psf']['model'] = config['psf']['model']
del config2['psf']['interp']
with np.testing.assert_raises(ValueError):
piff.piffify(config2, logger)
def test_twodstats_config():
"""Test running stats through a config file.
"""
if __name__ == '__main__':
logger = piff.config.setup_logger(verbose=2)
else:
logger = piff.config.setup_logger(log_file='output/test_twodstats_config.log')
image_file = os.path.join('output','test_stats_image.fits')
cat_file = os.path.join('output','test_stats_cat.fits')
psf_file = os.path.join('output','test_twodstats.fits')
twodhist_file = os.path.join('output','test_twodhiststats.pdf')
twodhist_std_file = os.path.join('output','test_twodhiststats_std.pdf')
config = {
'input' : {
'image_file_name' : image_file,
'cat_file_name' : cat_file,
'stamp_size' : 48
},
'psf' : {
'model' : { 'type' : 'Gaussian',
'fastfit': True,
'include_pixel': False },
'interp' : { 'type' : 'Mean' },
},
'output' : {
'file_name' : psf_file,
'stats' : [
{
'type': 'TwoDHist',
'file_name': twodhist_file,
'number_bins_u': 3,
'number_bins_v': 3,
},
{
'type': 'TwoDHist',
'file_name': twodhist_std_file,
'reducing_function': 'np.std',
'number_bins_u': 3,
'number_bins_v': 3,
},
]
}
}
piff.piffify(config, logger)
assert os.path.isfile(twodhist_file)
assert os.path.isfile(twodhist_std_file)
# repeat with plotify function
os.remove(twodhist_file)
os.remove(twodhist_std_file)
piff.plotify(config, logger)
assert os.path.isfile(twodhist_file)
assert os.path.isfile(twodhist_std_file)
def test_starstats_config():
"""Test running stats through a config file.
"""
if __name__ == '__main__':
logger = piff.config.setup_logger(verbose=2)
else:
logger = piff.config.setup_logger(log_file='output/test_starstats_config.log')
image_file = os.path.join('output','test_stats_image.fits')
cat_file = os.path.join('output','test_stats_cat.fits')
psf_file = os.path.join('output','test_starstats.fits')
star_file = os.path.join('output', 'test_starstats.pdf')
star_noadjust_file = os.path.join('output', 'test_starstats_noadjust.pdf')
config = {
'input' : {
'image_file_name' : image_file,
'cat_file_name' : cat_file,
'stamp_size' : 48
},
'psf' : {
'model' : { 'type' : 'Gaussian',
'fastfit': True,
'include_pixel': False },
'interp' : { 'type' : 'Mean' },
},
'output' : {
'file_name' : psf_file,
'stats' : [
{
'type': 'Star',
'file_name': star_file,
'number_plot': 5,
'adjust_stars': True,
}
]
}
}
piff.piffify(config, logger)
assert os.path.isfile(star_file)
# repeat with plotify function
os.remove(star_file)
piff.plotify(config, logger)
assert os.path.isfile(star_file)
# check default number_plot
psf = piff.read(psf_file)
starStats = piff.StarStats()
orig_stars, wcs, pointing = piff.Input.process(config['input'], logger)
starStats.compute(psf, orig_stars)
assert starStats.number_plot == len(starStats.stars)
assert starStats.number_plot == len(starStats.models)
assert starStats.number_plot == len(starStats.indices)
np.testing.assert_array_equal(starStats.stars[2].image.array,
orig_stars[starStats.indices[2]].image.array)
# check number_plot = 6
starStats = piff.StarStats(number_plot=6)
starStats.compute(psf, orig_stars)
assert len(starStats.stars) == 6
# check number_plot >> len(stars)
starStats = piff.StarStats(number_plot=1000000)
starStats.compute(psf, orig_stars)
assert len(starStats.stars) == len(orig_stars)
# if use all stars, no randomness
np.testing.assert_array_equal(starStats.stars[3].image.array, orig_stars[3].image.array)
np.testing.assert_array_equal(starStats.indices, np.arange(len(orig_stars)))
# check number_plot = 0
starStats = piff.StarStats(number_plot=0)
starStats.compute(psf, orig_stars)
assert len(starStats.stars) == len(orig_stars)
# if use all stars, no randomness
np.testing.assert_array_equal(starStats.stars[3].image.array, orig_stars[3].image.array)
np.testing.assert_array_equal(starStats.indices, np.arange(len(orig_stars)))
# rerun with adjust stars and see if it did the right thing
# first with starstats == False
starStats = piff.StarStats(number_plot=0, adjust_stars=False)
starStats.compute(psf, orig_stars, logger=logger)
fluxs_noadjust = np.array([s.fit.flux for s in starStats.stars])
ds_noadjust = np.array([s.fit.center for s in starStats.stars])
# check that fluxes 1
np.testing.assert_array_equal(fluxs_noadjust, 1)
# check that ds are 0
np.testing.assert_array_equal(ds_noadjust, 0)
# now with starstats == True
starStats = piff.StarStats(number_plot=0, adjust_stars=True)
starStats.compute(psf, orig_stars, logger=logger)
fluxs_adjust = np.array([s.fit.flux for s in starStats.stars])
ds_adjust = np.array([s.fit.center for s in starStats.stars])
# copy the right values from setup()
dx = 0.31
dy = -0.32
flux = 123.45
# compare fluxes
np.testing.assert_allclose(fluxs_adjust, flux, rtol=1e-4)
# compare dx and dy, keeping in mind that ds_adjust is dx/y * 0.26 (scale)
dx_adjust = ds_adjust[:, 0] / 0.26
dy_adjust = ds_adjust[:, 1] / 0.26
np.testing.assert_allclose(dx_adjust, dx, rtol=1e-4)
np.testing.assert_allclose(dy_adjust, dy, rtol=1e-4)
# do once with adjust_stars = False to graphically demonstrate
config['output']['stats'][0]['file_name'] = star_noadjust_file
config['output']['stats'][0]['adjust_stars'] = False
piff.plotify(config, logger)
assert os.path.isfile(star_noadjust_file)
def test_rhostats_config():
"""Test running stats through a config file.
"""
if __name__ == '__main__':
logger = piff.config.setup_logger(verbose=2)
else:
logger = piff.config.setup_logger(log_file='output/test_rhostats_config.log')
image_file = os.path.join('output','test_stats_image.fits')
cat_file = os.path.join('output','test_stats_cat.fits')
psf_file = os.path.join('output','test_rhostats.fits')
rho_file = os.path.join('output','test_rhostats.pdf')
config = {
'input' : {
'image_file_name' : image_file,
'cat_file_name' : cat_file,
'stamp_size' : 48
},
'psf' : {
'model' : { 'type' : 'Gaussian',
'fastfit': True,
'include_pixel': False },
'interp' : { 'type' : 'Mean' },
},
'output' : {
'file_name' : psf_file,
'stats' : { # Note: stats doesn't have to be a list.
'type': 'Rho',
'file_name': rho_file
}
},
}
piff.piffify(config, logger)
assert os.path.isfile(rho_file)
# repeat with plotify function
os.remove(rho_file)
piff.plotify(config, logger)
assert os.path.isfile(rho_file)
# Test rho statistics directly.
min_sep = 1
max_sep = 100
bin_size = 0.1
psf = piff.read(psf_file)
orig_stars, wcs, pointing = piff.Input.process(config['input'], logger)
stats = piff.RhoStats(min_sep=min_sep, max_sep=max_sep, bin_size=bin_size)
stats.compute(psf, orig_stars)
rhos = [stats.rho1, stats.rho2, stats.rho3, stats.rho4, stats.rho5]
for rho in rhos:
# Test the range of separations
radius = np.exp(rho.logr)
np.testing.assert_array_less(radius, max_sep)
np.testing.assert_array_less(min_sep, radius)
# bin_size is reduced slightly to get integer number of bins
assert rho.bin_size < bin_size
assert np.isclose(rho.bin_size, bin_size, rtol=0.1)
np.testing.assert_array_almost_equal(np.diff(rho.logr), rho.bin_size, decimal=5)
# Test that the max absolute value of each rho isn't crazy
np.testing.assert_array_less(np.abs(rho.xip), 1)
# # Check that each rho isn't precisely zero. This means the sum of abs > 0
np.testing.assert_array_less(0, np.sum(np.abs(rho.xip)))
# Test using the piffify executable
os.remove(rho_file)
config['verbose'] = 0
with open('rho.yaml','w') as f:
f.write(yaml.dump(config, default_flow_style=False))
piffify_exe = get_script_name('piffify')
p = subprocess.Popen( [piffify_exe, 'rho.yaml'] )
p.communicate()
assert os.path.isfile(rho_file)
# Test using the plotify executable
os.remove(rho_file)
plotify_exe = get_script_name('plotify')
p = subprocess.Popen( [plotify_exe, 'rho.yaml'] )
p.communicate()
assert os.path.isfile(rho_file)
# test running plotify with dir in config, with no logger, and with a modules specification.
# (all to improve test coverage)
config['output']['dir'] = '.'
config['modules'] = [ 'custom_wcs' ]
os.remove(rho_file)
piff.plotify(config)
assert os.path.isfile(rho_file)
def test_shapestats_config():
"""Test running stats through a config file.
"""
if __name__ == '__main__':
logger = piff.config.setup_logger(verbose=2)
else:
logger = piff.config.setup_logger(log_file='output/test_shapestats_config.log')
image_file = os.path.join('output','test_stats_image.fits')
cat_file = os.path.join('output','test_stats_cat.fits')
psf_file = os.path.join('output','test_shapestats.fits')
shape_file = os.path.join('output','test_shapestats.pdf')
config = {
'input' : {
'image_file_name' : image_file,
'cat_file_name' : cat_file,
'stamp_size' : 48
},
'psf' : {
'model' : { 'type' : 'Gaussian',
'fastfit': True,
'include_pixel': False },
'interp' : { 'type' : 'Mean' },
},
'output' : {
'file_name' : psf_file,
'stats' : [
{
'type': 'ShapeHist',
'file_name': shape_file
},
]
},
}
piff.piffify(config, logger)
assert os.path.isfile(shape_file)
# repeat with plotify function
os.remove(shape_file)
piff.plotify(config, logger)
assert os.path.isfile(shape_file)
# Test ShapeHistStats directly
psf = piff.read(psf_file)
shapeStats = piff.ShapeHistStats(nbins=5) # default is sqrt(nstars)
orig_stars, wcs, pointing = piff.Input.process(config['input'], logger)
with np.testing.assert_raises(RuntimeError):
shapeStats.write() # Cannot write before compute
shapeStats.compute(psf, orig_stars)
shapeStats.plot(histtype='bar', log=True) # can supply additional args for matplotlib
# test their characteristics
sigma = 1.3 # (copied from setup())
T = 2*sigma**2
g1 = 0.23
g2 = -0.17
np.testing.assert_array_almost_equal(T, shapeStats.T, decimal=4)
np.testing.assert_array_almost_equal(T, shapeStats.T_model, decimal=3)
np.testing.assert_array_almost_equal(g1, shapeStats.g1, decimal=4)
np.testing.assert_array_almost_equal(g1, shapeStats.g1_model, decimal=3)
np.testing.assert_array_almost_equal(g2, shapeStats.g2, decimal=4)
np.testing.assert_array_almost_equal(g2, shapeStats.g2_model, decimal=3)