def test_check_band_below_faint_limits_failure():
"""
Check that if you have 1 catalog and 2+ bands below the faint limit,
you cannot calculate the JHK bands and thus the magnitude. This should
raise an error. This case is that you have only SDSS data, and 2 of the
3 bands are below the faint limit.
"""
# Edit base data for specific test
data = copy.copy(BASE_DATA)
data['tmassJMag'] = -999
data['tmassHMag'] = -999
data['tmassKsMag'] = -999
data['SDSSgMag'] = 25
data['SDSSzMag'] = 25
data['SDSSiMag'] = 15
data['JpgMag'] = -999
data['FpgMag'] = -999
data['NpgMag'] = -999
fgs = FGSCountrate(guide_star_id="N13I000018", guider=1)
with pytest.raises(Exception) as e_info:
fgs.calc_jhk_mag(data)
assert 'There is not enough information on this guide star' in str(
e_info.value)
assert 'tmassJMag' in str(e_info.value)
def test_check_band_below_faint_limits_pass(jmag, hmag, kmag, gmag, zmag, rmag,
imag, convert_j, convert_h,
convert_k):
"""
Test that the checking of faint bands will in certain cases have the code
choose a conversion method that is not the "best" case conversion because
of the existence of faint stars.
"""
# Edit base data for specific test
data = copy.copy(BASE_DATA)
data['tmassJMag'] = jmag
data['tmassHMag'] = hmag
data['tmassKsMag'] = kmag
data['SDSSgMag'] = gmag
data['SDSSrMag'] = rmag
data['SDSSzMag'] = zmag
data['SDSSiMag'] = imag
data['JpgMag'] = -999
data['FpgMag'] = -999
data['NpgMag'] = -999
fgs = FGSCountrate(guide_star_id="N13I000018", guider=1)
fgs.calc_jhk_mag(data)
assert fgs.j_convert_method == convert_j
assert fgs.h_convert_method == convert_h
assert fgs.k_convert_method == convert_k
def test_check_band_below_faint_limits_failure():
"""
Check that if you have 1 catalog and 2+ bands below the faint limit,
you cannot calculate the JHK bands and thus the magnitude. This should
raise an error. This case is that you have only SDSS data, and 2 of the
3 bands are below the faint limit.
"""
# Edit base data for specific test
data = copy.copy(BASE_DATA)
data['tmassJMag'] = -999
data['tmassHMag'] = -999
data['tmassKsMag'] = -999
data['SDSSgMag'] = 25
data['SDSSrMag'] = -999
data['SDSSzMag'] = 25
data['SDSSiMag'] = 15
data['JpgMag'] = -999
data['FpgMag'] = -999
data['NpgMag'] = -999
fgs = FGSCountrate(guide_star_id="N13I000018", guider=1)
_ = fgs.calc_jhk_mag(data)
assert fgs.j_convert_method == 'cannot_calculate'
assert fgs.h_convert_method == 'cannot_calculate'
assert fgs.k_convert_method == 'cannot_calculate'
with pytest.raises(Exception) as e_info:
fgs.calc_fgs_cr_mag_and_err()
assert 'Cannot compute FGS countrate & magnitude for a guide star' in str(
e_info.value)
def test_band_missing():
"""Test that when a band (SDSS_g) is missing, it's signal is set to 0"""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data with SDSS_g missing
fgs.gsc_series = copy.copy(GSC_SERIES)
fgs.gsc_series['SDSSgMag'] = -999
fgs.gsc_series['SDSSgMagErr'] = -999
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Compute FGS countrate and magnitude to get fgs.band_dataframe attribute
_ = fgs.calc_fgs_cr_mag_and_err()
# Check Mag, ABMag, Flux, and Signal = -999
assert fgs.survey == 'sdss'
assert fgs.band_dataframe.at['SDSSgMag', 'Mag'] == -999
assert fgs.band_dataframe.at['SDSSgMag', 'ABMag'] == -999
assert fgs.band_dataframe.at['SDSSgMag', 'Flux'] == -999
assert fgs.band_dataframe.at['SDSSgMag', 'Signal'] == -999
def test_sdss_or_gsc():
"""Test that only SDSS or GSC data is used to compute CR and Mag, and not a combination of the two"""
gs_id = 'N13I000018'
guider = 1
# Test SDSS only - set tmass to missing (sdss will be chosen over gsc already)
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
fgs.gsc_series = copy.copy(GSC_SERIES)
for ind in TMASS_BANDS:
fgs.gsc_series.loc[ind] = -999
fgs.calc_jhk_mag(fgs.gsc_series)
_ = fgs.calc_fgs_cr_mag_and_err()
# check gsc bands have been fully removed
assert False not in ['pgMag' not in i for i in fgs._present_calculated_mags]
# check that gsc bands are all excluded from calculations
assert fgs.survey == 'sdss'
gsc_index = [i for i in fgs.band_dataframe['ABMag'].index if 'pgMag' in i]
assert all(-999 == fgs.band_dataframe['ABMag'][gsc_index].values)
# Test GSC only - set tmass and SDSS g, z, and i to missing (keep r).
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
fgs.gsc_series = copy.copy(GSC_SERIES)
for ind in TMASS_BANDS:
fgs.gsc_series.loc[ind] = -999
fgs.gsc_series['SDSSgMag'] = -999
fgs.gsc_series['SDSSzMag'] = -999
fgs.gsc_series['SDSSiMag'] = -999
fgs.calc_jhk_mag(fgs.gsc_series)
_ = fgs.calc_fgs_cr_mag_and_err()
# check sdss bands have been fully removed
assert False not in ['SDSS' not in i for i in fgs._present_calculated_mags]
# check that sdss bands are all excluded from calculations
assert fgs.survey == 'gsc2'
sdss_index = [i for i in fgs.band_dataframe['ABMag'].index if 'SDSS' in i]
assert all(-999 == fgs.band_dataframe['ABMag'][sdss_index].values)
# Test 2MASS only - set everything to missing except for tmass
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
fgs.gsc_series = copy.copy(GSC_SERIES)
for ind in SDSS_BANDS:
fgs.gsc_series.loc[ind] = -999
for ind in GSC2_BANDS:
fgs.gsc_series.loc[ind] = -999
fgs.calc_jhk_mag(fgs.gsc_series)
_ = fgs.calc_fgs_cr_mag_and_err()
# check sdss and gsc bands have been fully removed
assert False not in ['SDSS' not in i for i in fgs._present_calculated_mags]
assert False not in ['pgMag' not in i for i in fgs._present_calculated_mags]
# check that sdss and gsc bands are all excluded from calculations
assert fgs.survey == 'gsc2'
sdss_index = [i for i in fgs.band_dataframe['ABMag'].index if 'SDSS' in i]
assert all(-999 == fgs.band_dataframe['ABMag'][sdss_index].values)
gsc_index = [i for i in fgs.band_dataframe['ABMag'].index if 'pgMag' in i]
assert all(-999 == fgs.band_dataframe['ABMag'][gsc_index].values)
def test_gscbj_sdssg_missing():
"""Test that when GSC_B_J and SDSS_g are missing, their signal is set to 0"""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data with GSC_B_J and SDSS_g missing
values = [
'N13I000018', 420900912, 273.207, 65.5335, 8.30302e-05, 0.000185965,
-999, -999, 14.0877, 0.2927929, 13.7468, 0.239294, 13.339,
0.0250000003, 12.993, 0.0270000007, 12.901, 0.0270000007, 15.78594,
0.005142, -999, -999, 14.27808, 0.003273380, 14.1443, 0.003414216,
14.1067, 0.00433389
]
index = [
'hstID', 'gsc1ID', 'ra', 'dec', 'raErr', 'decErr', 'JpgMag',
'JpgMagErr', 'FpgMag', 'FpgMagErr', 'NpgMag', 'NpgMagErr', 'tmassJmag',
'tmassJmagErr', 'tmassHmag', 'tmassHmagErr', 'tmassKsMag',
'tmassKsMagErr', 'SDSSuMag', 'SDSSuMagErr', 'SDSSgMag', 'SDSSgMagErr',
'SDSSrMag', 'SDSSrMagErr', 'SDSSiMag', 'SDSSiMagErr', 'SDSSzMag',
'SDSSzMagErr'
]
fgs.gsc_series = pd.Series(values, index=index)
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Compute FGS countrate and magnitude to get fgs.band_dataframe attribute
fgs.calc_fgs_cr_mag_and_err()
# Check Mag, ABMag, and Flux = -999 and Signal is set to 0 for both
assert fgs.band_dataframe.at['JpgMag', 'Mag'] == -999
assert fgs.band_dataframe.at['SDSSgMag', 'Mag'] == -999
assert fgs.band_dataframe.at['JpgMag', 'ABMag'] == -999
assert fgs.band_dataframe.at['SDSSgMag', 'ABMag'] == -999
assert fgs.band_dataframe.at['JpgMag', 'Flux'] == -999
assert fgs.band_dataframe.at['SDSSgMag', 'Flux'] == -999
assert fgs.band_dataframe.at['JpgMag', 'Signal'] == 0.0
assert fgs.band_dataframe.at['SDSSgMag', 'Signal'] == 0.0
def test_compute_countrate_magnitude():
"""
Test the conversion from GSC magnitudes to FGS countrate
returns values as expected
"""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data
values = [
'N13I000018 ', 420900912, 273.206729760604, 65.5335149359777,
8.3030233068735e-05, 0.000185964552890292, 14.9447, 0.285722, 14.0877,
0.29279299999999997, 13.7468, 0.239294, 13.33899974823,
0.025000000372529, 12.9930000305176, 0.0270000007003546,
12.9010000228882, 0.0270000007003546, 15.78594, 0.005142466,
14.654670000000001, 0.003211281, 14.27808, 0.0032733809999999997,
14.14432, 0.003414216, 14.106670000000001, 0.00433389
]
index = [
'hstID', 'gsc1ID', 'ra', 'dec', 'raErr', 'decErr', 'JpgMag',
'JpgMagErr', 'FpgMag', 'FpgMagErr', 'NpgMag', 'NpgMagErr', 'tmassJMag',
'tmassJMagErr', 'tmassHMag', 'tmassHMagErr', 'tmassKsMag',
'tmassKsMagErr', 'SDSSuMag', 'SDSSuMagErr', 'SDSSgMag', 'SDSSgMagErr',
'SDSSrMag', 'SDSSrMagErr', 'SDSSiMag', 'SDSSiMagErr', 'SDSSzMag',
'SDSSzMagErr'
]
fgs.gsc_series = pd.Series(values, index=index)
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Compute FGS countrate and magnitude
cr, cr_err, mag, mag_err = fgs.calc_fgs_cr_mag_and_err()
assert np.isclose(cr, 1777234.5129574337, 1e-5)
assert np.isclose(cr_err, 154340.24919027157, 1e-5)
assert np.isclose(mag, 13.310964314752303, 1e-5)
assert np.isclose(mag_err, 0.6657930516063038, 1e-5)
def test_dim_limits_partialsdss():
"""Test that when some SDSS bands are below the dim limits, those bands
are not included in the JHK or count rate/magnitude calculations, but
the remaining SDSS bands are used."""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data with TMASS not present and 2 SDSS bands set to dim
fgs.gsc_series = copy.copy(GSC_SERIES)
for ind in TMASS_BANDS:
fgs.gsc_series.loc[ind] = -999
fgs.gsc_series['SDSSgMag'] = 17
fgs.gsc_series['SDSSrMag'] = 24 # dim
fgs.gsc_series['SDSSzMag'] = 24 # dim
fgs.gsc_series['SDSSiMag'] = 17
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Check conversion method
assert fgs.j_convert_method == 'convert_sdssgi_to_jhk'
assert fgs.h_convert_method == 'convert_sdssgi_to_jhk'
assert fgs.k_convert_method == 'convert_sdssgi_to_jhk'
# Compute FGS countrate and magnitude to get fgs.band_dataframe attribute
_ = fgs.calc_fgs_cr_mag_and_err()
# Check Mag, ABMag, Flux, and Signal = -999 for g and r
assert fgs.survey == 'sdss'
assert fgs.band_dataframe.at['SDSSzMag', 'ABMag'] == -999
assert fgs.band_dataframe.at['SDSSzMag', 'Flux'] == -999
assert fgs.band_dataframe.at['SDSSzMag', 'Signal'] == -999
assert fgs.band_dataframe.at['SDSSrMag', 'ABMag'] == -999
assert fgs.band_dataframe.at['SDSSrMag', 'Flux'] == -999
assert fgs.band_dataframe.at['SDSSrMag', 'Signal'] == -999
def test_compute_countrate_magnitude():
"""
Test the conversion from GSC magnitudes to FGS countrate
returns values as expected
"""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data
values = [
'N13I000018', 420900912, 273.207, 65.5335, 8.30302e-05, 0.000185965,
14.9447, 0.285722, 14.0877, 0.2927929, 13.7468, 0.239294, 13.339,
0.0250000003, 12.993, 0.0270000007, 12.901, 0.0270000007, 15.78594,
0.005142, 14.6547, 0.003211281, 14.27808, 0.003273380, 14.1443,
0.003414216, 14.1067, 0.00433389
]
index = [
'hstID', 'gsc1ID', 'ra', 'dec', 'raErr', 'decErr', 'JpgMag',
'JpgMagErr', 'FpgMag', 'FpgMagErr', 'NpgMag', 'NpgMagErr', 'tmassJmag',
'tmassJmagErr', 'tmassHmag', 'tmassHmagErr', 'tmassKsMag',
'tmassKsMagErr', 'SDSSuMag', 'SDSSuMagErr', 'SDSSgMag', 'SDSSgMagErr',
'SDSSrMag', 'SDSSrMagErr', 'SDSSiMag', 'SDSSiMagErr', 'SDSSzMag',
'SDSSzMagErr'
]
fgs.gsc_series = pd.Series(values, index=index)
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Compute FGS countrate and magnitude
cr, cr_err, mag, mag_err = fgs.calc_fgs_cr_mag_and_err()
assert pytest.approx(cr, 1777234.5129574337, 5)
assert pytest.approx(cr_err, 154340.24919027157, 5)
assert pytest.approx(mag, -39.77243568524769, 5)
assert pytest.approx(mag_err, 1.9887037388556956, 5)
def test_dim_limits_allsdss():
"""Test that when all SDSS bands are below the dim limits, they are not included in the
JHK or count rate/magnitude calculations, and GSC2 bands are used instead."""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data with TMASS not present and all SDSS bands set to dim
fgs.gsc_series = copy.copy(GSC_SERIES)
for ind in TMASS_BANDS:
fgs.gsc_series.loc[ind] = -999
fgs.gsc_series['SDSSgMag'] = 24
fgs.gsc_series['SDSSrMag'] = 24
fgs.gsc_series['SDSSzMag'] = 24
fgs.gsc_series['SDSSiMag'] = 24
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Check conversion method
assert fgs.j_convert_method == 'convert_gsc2bjin_to_jhk'
assert fgs.h_convert_method == 'convert_gsc2bjin_to_jhk'
assert fgs.k_convert_method == 'convert_gsc2bjin_to_jhk'
# Check that no SDSS bands made it into the present bands list
assert ['sdss' not in substring.lower() for substring in fgs._present_queried_mags]
assert ['sdss' not in substring.lower() for substring in fgs._present_calculated_mags]
# Compute FGS countrate and magnitude to get fgs.band_dataframe attribute
_ = fgs.calc_fgs_cr_mag_and_err()
# Check this calculation should only be done with GSC bands
assert fgs.survey == 'gsc2'
assert fgs.band_dataframe.at['JpgMag', 'ABMag'] != -999
assert fgs.band_dataframe.at['FpgMag', 'ABMag'] != -999
assert fgs.band_dataframe.at['NpgMag', 'ABMag'] != -999
def test_bad_sdss_gz_limits():
"""Test that when SDSSgMag and SDSSzMag color differences are bad, that conversion is skipped"""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data with SDSS_g and z having bad color ranges and tmass missing
fgs.gsc_series = BASE_DATA
fgs.gsc_series['tmassJMag'] = -999
fgs.gsc_series['tmassHMag'] = -999
fgs.gsc_series['tmassKsMag'] = -999
fgs.gsc_series['SDSSgMag'] = 20
fgs.gsc_series['SDSSzMag'] = 14
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Check that the conversion method is the next SDSS one that doesn't include SDSS_g-z
assert fgs.j_convert_method == 'convert_sdssrz_to_jhk'
assert fgs.h_convert_method == 'convert_sdssrz_to_jhk'
assert fgs.k_convert_method == 'convert_sdssrz_to_jhk'
def test_compute_countrate_magnitude():
"""
Test the conversion from GSC magnitudes to FGS countrate
returns values as expected
"""
gs_id = 'N13I000018'
guider = 1
fgs = FGSCountrate(guide_star_id=gs_id, guider=guider)
# Reset data to a set of constant, fake data
fgs.gsc_series = copy.copy(GSC_SERIES)
# Convert to JHK magnitudes
fgs.j_mag, fgs.j_mag_err, fgs.h_mag, fgs.h_mag_err, fgs.k_mag, fgs.k_mag_err = \
fgs.calc_jhk_mag(fgs.gsc_series)
# Compute FGS countrate and magnitude
cr, cr_err, mag, mag_err = fgs.calc_fgs_cr_mag_and_err()
assert np.isclose(cr, 1786779.2896366853, 1e-5)
assert np.isclose(cr_err, 153161.72059228245, 1e-5)
assert np.isclose(mag, 13.304318358662279, 1e-5)
assert np.isclose(mag_err, 0.665287435671057, 1e-5)
def test_convert_mag_to_jhk():
"""
Using a different technique for choosing the conversion method and
comparing that output to the technique used in calc_jhk_mag.
This test is done by finding all possible combinations of the
magnitudes that could be used for the conversion and checking
that they have the same output with both techniques.
"""
full_list = [
'JpgMag', 'FpgMag', 'NpgMag', 'tmassJMag', 'tmassHMag', 'tmassKsMag',
'SDSSuMag', 'SDSSgMag', 'SDSSrMag', 'SDSSiMag', 'SDSSzMag'
]
for L in range(0, len(full_list) + 1):
for subset in itertools.combinations(full_list, L):
if subset == ():
continue
# Recreate data
fgs = FGSCountrate(guide_star_id="N13I000018", guider=1)
fgs.gsc_series = BASE_DATA
# Compute conversion
delete_list = list(set(full_list) - set(subset))
data2 = copy.copy(fgs.gsc_series)
for i in delete_list:
data2[i] = -999
fgs.calc_jhk_mag(data=data2)
# Compare output to here
method_names = []
for i in ['tmassJMag', 'tmassHMag', 'tmassKsMag']:
if i in list(subset):
method_name_test = "convert_tmass_to_jhk"
elif {'SDSSgMag', 'SDSSzMag'}.issubset(subset):
method_name_test = "convert_sdssgz_to_jhk"
elif {'SDSSrMag', 'SDSSzMag'}.issubset(subset):
method_name_test = "convert_sdssrz_to_jhk"
elif {'SDSSgMag', 'SDSSiMag'}.issubset(subset):
method_name_test = "convert_sdssgi_to_jhk"
# elif {'SDSSiMag', 'SDSSzMag'}.issubset(subset): # Add back in once GSSS uses this pair
# method_name_test = "convert_sdssiz_to_jhk"
elif {'JpgMag', 'NpgMag'}.issubset(subset):
method_name_test = "convert_gsc2bjin_to_jhk"
elif {'FpgMag', 'NpgMag'}.issubset(subset):
method_name_test = "convert_gsc2rfin_to_jhk"
elif {'JpgMag', 'FpgMag'}.issubset(subset):
method_name_test = "convert_gsc2bjrf_to_jhk"
else:
method_name_test = 'cannot_calculate'
method_names.append(method_name_test)
failure_message = f'For input {list(subset)} and band {i[5]}: the test called {method_name_test} ' \
f'while the calc_jhk_mag method called ' \
f'{getattr(fgs, f"{i[5].lower()}_convert_method")}'
assert method_name_test == getattr(
fgs, f'{i[5].lower()}_convert_method'), failure_message
def test_convert_mag_to_jhk():
"""
Using a different technique for choosing the conversion method and
comparing that output to the technique used in calc_jhk_mag.
This test is done by finding all possible combinations of the
magnitudes that could be used for the conversion and checking
that they have the same output with both techniques.
"""
full_list = [
'JpgMag', 'FpgMag', 'NpgMag', 'tmassJMag', 'tmassHMag', 'tmassKsMag',
'SDSSuMag', 'SDSSgMag', 'SDSSrMag', 'SDSSiMag', 'SDSSzMag'
]
for L in range(0, len(full_list) + 1):
for subset in itertools.combinations(full_list, L):
if subset == ():
continue
# Recreate data
fgs = FGSCountrate(guide_star_id="N13I000018", guider=1)
fgs.gsc_series = BASE_DATA
# Compute conversion
delete_list = list(set(full_list) - set(subset))
data2 = copy.copy(fgs.gsc_series)
for i in delete_list:
data2[i] = -999
try:
fgs.calc_jhk_mag(data=data2)
error = False
except ValueError:
error = True
# Compare output to here
method_names = []
for i in ['tmassJMag', 'tmassHMag', 'tmassKsMag']:
if i in list(subset):
method_name_test = "convert_tmass_to_jhk"
elif set(['SDSSgMag', 'SDSSzMag']).issubset(subset):
method_name_test = "convert_sdssgz_to_jhk"
elif set(['SDSSgMag', 'SDSSiMag']).issubset(subset):
method_name_test = "convert_sdssgi_to_jhk"
elif set(['SDSSiMag', 'SDSSzMag']).issubset(subset):
method_name_test = "convert_sdssiz_to_jhk"
elif set(['JpgMag', 'NpgMag']).issubset(subset):
method_name_test = "convert_gsc2bjin_to_jhk"
elif set(['FpgMag', 'NpgMag']).issubset(subset):
method_name_test = "convert_gsc2rfin_to_jhk"
elif set(['JpgMag', 'FpgMag']).issubset(subset):
method_name_test = "convert_gsc2bjrf_to_jhk"
else:
method_name_test = 'cannot_convert_to_jhk'
method_names.append(method_name_test)
if method_name_test != getattr(
fgs, '{}_convert_method'.format(i[5].lower())):
if error is False:
print(subset)
print(
" **", error, method_name_test,
getattr(fgs,
'{}_convert_method'.format(i[5].lower())))
# If you could compute the JHK mags, check the same conversion method as used
if error is False:
failure_message = 'For input {} and band {}: the test called {} while the calc_jhk_mag ' \
'method called {}'.format(list(subset), i[5], method_name_test,
getattr(fgs, '{}_convert_method'.format(i[5].lower())))
assert method_name_test == getattr(
fgs, '{}_convert_method'.format(
i[5].lower())), failure_message
# If you can't compute the JHK mags, check methods agree it's not possible
if error is True:
assert 'cannot_convert_to_jhk' in method_names
