20631205081

Committed 01 Jan 2026 02:28AM UTC coverage: 96.349% (+0.1%) from 96.216%

Build # 20631205081

Build Type

Pull #48

github

Committed by

web-flow

Commit Message

Merge eede3b72b into f1d6b2b86

Pull Request Pull Request #48: Tests/coverage improvements

Run Details

118 of 119 new or added lines in 5 files covered. (99.16%)

2 existing lines in 1 file now uncovered.

3272 of 3396 relevant lines covered (96.35%)

1.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.63

/src/WDPhotTools/diff2_functions_least_square.py

import numpy as np

from .extinction import get_extinction_fraction


def diff2(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    return_err,
):
    """
    Internal method for computing the ch2-squared value (for scipy.optimize.least_squares).

    """

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x))

    mag = np.asarray(mag).reshape(-1)

    # 5 / ln(10) = 2.17147241 converts fractional distance error to magnitude error
    # (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
    e2 = (errors**2.0 + (distance_err / distance * 2.17147241) ** 2.0) * 0.8483036976765438

    d2 = ((10.0 ** ((obs - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2
        else:
            return d2
    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf
        else:
            return np.ones_like(obs) * np.inf


def diff2_distance(_x, obs, errors, interpolator_filter, return_err):
    """
    Internal method for computing the ch2-squared value in cases when the distance is not provided (for
    scipy.optimize.least_squares).

    """

    if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x[:-1]))

    mag = np.asarray(mag).reshape(-1)
    e2 = errors**2.0
    d2 = ((10.0 ** ((obs - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf


def diff2_distance_red_interpolated(
    _x,
    obs,
    errors,
    interpolator_filter,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    zmin,
    zmax,
    return_err,
):
    """
    Internal method for computing the ch2-squared value in cases when the distance is not provided.

    """

    if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x[:2]))

    if extinction_mode == "total":
        extinction_fraction = 1.0

    else:
        extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)

    av = np.array([i(rv) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction
    mag = np.asarray(mag).reshape(-1)
    e2 = errors**2.0
    d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf


def diff2_distance_red_interpolated_fixed_logg(
    _x,
    obs,
    errors,
    interpolator_filter,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    zmin,
    zmax,
    return_err,
):
    """
    Internal method for computing the ch2-squared value in cases when the distance is not provided.

    """

    if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x[:-1]))

    if extinction_mode == "total":
        extinction_fraction = 1.0

    else:
        extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)

    av = np.array([i(rv) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction
    mag = np.asarray(mag).reshape(-1)
    e2 = errors**2.0

    d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf


def diff2_distance_red_filter(
    _x,
    obs,
    errors,
    interpolator_filter,
    interpolator_teff,
    logg_pos,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    zmin,
    zmax,
    return_err,
):
    """
    Internal method for computing the ch2-squared value in cases when
    the distance is not provided.

    """

    if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x[:2]))

    if extinction_mode == "total":
        extinction_fraction = 1.0

    else:
        extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)

    teff = float(np.asarray(interpolator_teff(_x[:2])).reshape(-1)[0])
    logg = _x[logg_pos]
    av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction
    mag = np.asarray(mag).reshape(-1)
    e2 = errors**2.0
    d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf


def diff2_distance_red_filter_fixed_logg(
    _x,
    obs,
    errors,
    interpolator_filter,
    interpolator_teff,
    logg,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    zmin,
    zmax,
    return_err,
):
    """
    Internal method for computing the ch2-squared value in cases when the distance is not provided.

    """

    if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x[:-1]))

    if extinction_mode == "total":
        extinction_fraction = 1.0

    else:
        extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)

    teff = float(np.asarray(interpolator_teff(_x[:-1])).reshape(-1)[0])
    av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction
    mag = np.asarray(mag).reshape(-1)
    e2 = errors**2.0

    d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf


def diff2_red_interpolated(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    zmin,
    zmax,
    return_err,
):
    """
    Internal method for computing the ch2-squared value.

    """

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x))

    if extinction_mode == "total":
        extinction_fraction = 1.0

    else:
        extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)

    av = np.array([i(rv) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction
    mag = np.asarray(mag).reshape(-1)

    # 5 / ln(10) = 2.17147241 converts fractional distance error to mag error
    # (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
    # of residuals squared
    e2 = (errors**2.0 + (distance_err / distance * 2.17147241) ** 2.0) * 0.8483036976765438
    d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf


def diff2_red_filter(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    interpolator_teff,
    logg_pos,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    zmin,
    zmax,
    return_err,
):
    """
    Internal method for computing the ch2-squared value (for scipy.optimize.least_square).

    """

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x))

    teff = float(np.asarray(interpolator_teff(_x)).reshape(-1)[0])

    if not np.isfinite(teff):
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf

    if extinction_mode == "total":
        extinction_fraction = 1.0

    else:
        extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)

    logg = _x[logg_pos]
    av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction
    mag = np.asarray(mag).reshape(-1)

    # 5 / ln(10) = 2.17147241 converts fractional distance error to mag error
    # (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
    # of residuals squared
    e2 = (errors**2.0 + (distance_err / distance * 2.17147241) ** 2.0) * 0.8483036976765438
    d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs) * np.inf


def diff2_red_filter_fixed_logg(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    interpolator_teff,
    logg,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    zmin,
    zmax,
    return_err,
):
    """
    Internal method for computing the ch2-squared value (for scipy.optimize.least_square).

    """

    mag = []

    for interp in interpolator_filter:
        mag.append(interp(_x))

    if extinction_mode == "total":
        extinction_fraction = 1.0

    else:
        extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)

    teff = float(np.asarray(interpolator_teff(_x)).reshape(-1)[0])
    av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction
    mag = np.asarray(mag).reshape(-1)

    # 5 / ln(10) = 2.17147241 converts fractional distance error to mag error
    # (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
    # of residuals squared
    e2 = (errors**2.0 + (distance_err / distance * 2.17147241) ** 2.0) * 0.8483036976765438
    d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2

    if np.isfinite(d2).all():
        if return_err:
            return d2, e2

        else:
            return d2

    else:
        if return_err:
            return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf

        else:
            return np.ones_like(obs)

1	import numpy as np	2✔
2
3	from .extinction import get_extinction_fraction	2✔
4
5
6	def diff2(	2✔
7	_x,
8	obs,
9	errors,
10	distance,
11	distance_err,
12	interpolator_filter,
13	return_err,
14	):
15	"""
16	Internal method for computing the ch2-squared value (for scipy.optimize.least_squares).
17
18	"""
19
20	mag = []	2✔
21
22	for interp in interpolator_filter:	2✔
23	mag.append(interp(_x))	2✔
24
25	mag = np.asarray(mag).reshape(-1)	2✔
26
27	# 5 / ln(10) = 2.17147241 converts fractional distance error to magnitude error
28	# (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
29	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 0.8483036976765438	2✔
30
31	d2 = ((10.0 ** ((obs - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
32
33	if np.isfinite(d2).all():	2✔
34	if return_err:	2✔
35	return d2, e2	2✔
36	else:
37	return d2	2✔
38	else:
39	if return_err:	2✔
40	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
41	else:
42	return np.ones_like(obs) * np.inf	×
43
44
45	def diff2_distance(_x, obs, errors, interpolator_filter, return_err):	2✔
46	"""
47	Internal method for computing the ch2-squared value in cases when the distance is not provided (for
48	scipy.optimize.least_squares).
49
50	"""
51
52	if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):	2✔
53	if return_err:	2✔
54	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
55
56	else:
57	return np.ones_like(obs) * np.inf	×
58
59	mag = []	2✔
60
61	for interp in interpolator_filter:	2✔
62	mag.append(interp(_x[:-1]))	2✔
63
64	mag = np.asarray(mag).reshape(-1)	2✔
65	e2 = errors**2.0	2✔
66	d2 = ((10.0 ** ((obs - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
67
68	if np.isfinite(d2).all():	2✔
69	if return_err:	2✔
70	return d2, e2	2✔
71
72	else:
73	return d2	2✔
74
75	else:
76	if return_err:	2✔
77	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
78
79	else:
80	return np.ones_like(obs) * np.inf	2✔
81
82
83	def diff2_distance_red_interpolated(	2✔
84	_x,
85	obs,
86	errors,
87	interpolator_filter,
88	rv,
89	extinction_mode,
90	reddening_vector,
91	ebv,
92	ra,
93	dec,
94	zmin,
95	zmax,
96	return_err,
97	):
98	"""
99	Internal method for computing the ch2-squared value in cases when the distance is not provided.
100
101	"""
102
103	if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):	2✔
UNCOV 104	if return_err:	×
UNCOV 105	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	×
106
107	else:
108	return np.ones_like(obs) * np.inf	×
109
110	mag = []	2✔
111
112	for interp in interpolator_filter:	2✔
113	mag.append(interp(_x[:2]))	2✔
114
115	if extinction_mode == "total":	2✔
116	extinction_fraction = 1.0	2✔
117
118	else:
119	extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)	×
120
121	av = np.array([i(rv) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
122	mag = np.asarray(mag).reshape(-1)	2✔
123	e2 = errors**2.0	2✔
124	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
125
126	if np.isfinite(d2).all():	2✔
127	if return_err:	2✔
128	return d2, e2	2✔
129
130	else:
131	return d2	2✔
132
133	else:
134	if return_err:	2✔
135	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
136
137	else:
138	return np.ones_like(obs) * np.inf	2✔
139
140
141	def diff2_distance_red_interpolated_fixed_logg(	2✔
142	_x,
143	obs,
144	errors,
145	interpolator_filter,
146	rv,
147	extinction_mode,
148	reddening_vector,
149	ebv,
150	ra,
151	dec,
152	zmin,
153	zmax,
154	return_err,
155	):
156	"""
157	Internal method for computing the ch2-squared value in cases when the distance is not provided.
158
159	"""
160
161	if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):	2✔
162	if return_err:	×
163	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	×
164
165	else:
166	return np.ones_like(obs) * np.inf	×
167
168	mag = []	2✔
169
170	for interp in interpolator_filter:	2✔
171	mag.append(interp(_x[:-1]))	2✔
172
173	if extinction_mode == "total":	2✔
174	extinction_fraction = 1.0	2✔
175
176	else:
177	extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)	×
178
179	av = np.array([i(rv) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
180	mag = np.asarray(mag).reshape(-1)	2✔
181	e2 = errors**2.0	2✔
182
183	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
184
185	if np.isfinite(d2).all():	2✔
186	if return_err:	2✔
187	return d2, e2	2✔
188
189	else:
190	return d2	2✔
191
192	else:
193	if return_err:	2✔
194	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
195
196	else:
197	return np.ones_like(obs) * np.inf	2✔
198
199
200	def diff2_distance_red_filter(	2✔
201	_x,
202	obs,
203	errors,
204	interpolator_filter,
205	interpolator_teff,
206	logg_pos,
207	rv,
208	extinction_mode,
209	reddening_vector,
210	ebv,
211	ra,
212	dec,
213	zmin,
214	zmax,
215	return_err,
216	):
217	"""
218	Internal method for computing the ch2-squared value in cases when
219	the distance is not provided.
220
221	"""
222
223	if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):	2✔
224	if return_err:	2✔
225	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
226
227	else:
228	return np.ones_like(obs) * np.inf	×
229
230	mag = []	2✔
231
232	for interp in interpolator_filter:	2✔
233	mag.append(interp(_x[:2]))	2✔
234
235	if extinction_mode == "total":	2✔
236	extinction_fraction = 1.0	2✔
237
238	else:
239	extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)	×
240
241	teff = float(np.asarray(interpolator_teff(_x[:2])).reshape(-1)[0])	2✔
242	logg = _x[logg_pos]	2✔
243	av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
244	mag = np.asarray(mag).reshape(-1)	2✔
245	e2 = errors**2.0	2✔
246	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
247
248	if np.isfinite(d2).all():	2✔
249	if return_err:	2✔
250	return d2, e2	2✔
251
252	else:
253	return d2	2✔
254
255	else:
256	if return_err:	2✔
257	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
258
259	else:
260	return np.ones_like(obs) * np.inf	2✔
261
262
263	def diff2_distance_red_filter_fixed_logg(	2✔
264	_x,
265	obs,
266	errors,
267	interpolator_filter,
268	interpolator_teff,
269	logg,
270	rv,
271	extinction_mode,
272	reddening_vector,
273	ebv,
274	ra,
275	dec,
276	zmin,
277	zmax,
278	return_err,
279	):
280	"""
281	Internal method for computing the ch2-squared value in cases when the distance is not provided.
282
283	"""
284
285	if (_x[-1] <= 0.0) or (_x[-1] > 10000.0):	2✔
286	if return_err:	2✔
287	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
288
289	else:
290	return np.ones_like(obs) * np.inf	×
291
292	mag = []	2✔
293
294	for interp in interpolator_filter:	2✔
295	mag.append(interp(_x[:-1]))	2✔
296
297	if extinction_mode == "total":	2✔
298	extinction_fraction = 1.0	2✔
299
300	else:
301	extinction_fraction = get_extinction_fraction(_x[-1], ra, dec, zmin, zmax)	×
302
303	teff = float(np.asarray(interpolator_teff(_x[:-1])).reshape(-1)[0])	2✔
304	av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
305	mag = np.asarray(mag).reshape(-1)	2✔
306	e2 = errors**2.0	2✔
307
308	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(_x[-1]) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
309
310	if np.isfinite(d2).all():	2✔
311	if return_err:	2✔
312	return d2, e2	2✔
313
314	else:
315	return d2	2✔
316
317	else:
318	if return_err:	2✔
319	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
320
321	else:
322	return np.ones_like(obs) * np.inf	2✔
323
324
325	def diff2_red_interpolated(	2✔
326	_x,
327	obs,
328	errors,
329	distance,
330	distance_err,
331	interpolator_filter,
332	rv,
333	extinction_mode,
334	reddening_vector,
335	ebv,
336	ra,
337	dec,
338	zmin,
339	zmax,
340	return_err,
341	):
342	"""
343	Internal method for computing the ch2-squared value.
344
345	"""
346
347	mag = []	2✔
348
349	for interp in interpolator_filter:	2✔
350	mag.append(interp(_x))	2✔
351
352	if extinction_mode == "total":	2✔
353	extinction_fraction = 1.0	2✔
354
355	else:
356	extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)	×
357
358	av = np.array([i(rv) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
359	mag = np.asarray(mag).reshape(-1)	2✔
360
361	# 5 / ln(10) = 2.17147241 converts fractional distance error to mag error
362	# (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
363	# of residuals squared
364	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 0.8483036976765438	2✔
365	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
366
367	if np.isfinite(d2).all():	2✔
368	if return_err:	2✔
369	return d2, e2	2✔
370
371	else:
372	return d2	2✔
373
374	else:
375	if return_err:	2✔
376	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
377
378	else:
379	return np.ones_like(obs) * np.inf	×
380
381
382	def diff2_red_filter(	2✔
383	_x,
384	obs,
385	errors,
386	distance,
387	distance_err,
388	interpolator_filter,
389	interpolator_teff,
390	logg_pos,
391	rv,
392	extinction_mode,
393	reddening_vector,
394	ebv,
395	ra,
396	dec,
397	zmin,
398	zmax,
399	return_err,
400	):
401	"""
402	Internal method for computing the ch2-squared value (for scipy.optimize.least_square).
403
404	"""
405
406	mag = []	2✔
407
408	for interp in interpolator_filter:	2✔
409	mag.append(interp(_x))	2✔
410
411	teff = float(np.asarray(interpolator_teff(_x)).reshape(-1)[0])	2✔
412
413	if not np.isfinite(teff):	2✔
414	if return_err:	2✔
415	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
416
417	else:
418	return np.ones_like(obs) * np.inf	×
419
420	if extinction_mode == "total":	2✔
421	extinction_fraction = 1.0	2✔
422
423	else:
424	extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)	×
425
426	logg = _x[logg_pos]	2✔
427	av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
428	mag = np.asarray(mag).reshape(-1)	2✔
429
430	# 5 / ln(10) = 2.17147241 converts fractional distance error to mag error
431	# (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
432	# of residuals squared
433	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 0.8483036976765438	2✔
434	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
435
436	if np.isfinite(d2).all():	2✔
437	if return_err:	2✔
438	return d2, e2	2✔
439
440	else:
441	return d2	2✔
442
443	else:
444	if return_err:	×
445	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	×
446
447	else:
448	return np.ones_like(obs) * np.inf	×
449
450
451	def diff2_red_filter_fixed_logg(	2✔
452	_x,
453	obs,
454	errors,
455	distance,
456	distance_err,
457	interpolator_filter,
458	interpolator_teff,
459	logg,
460	rv,
461	extinction_mode,
462	reddening_vector,
463	ebv,
464	ra,
465	dec,
466	zmin,
467	zmax,
468	return_err,
469	):
470	"""
471	Internal method for computing the ch2-squared value (for scipy.optimize.least_square).
472
473	"""
474
475	mag = []	2✔
476
477	for interp in interpolator_filter:	2✔
478	mag.append(interp(_x))	2✔
479
480	if extinction_mode == "total":	2✔
481	extinction_fraction = 1.0	2✔
482
483	else:
484	extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)	×
485
486	teff = float(np.asarray(interpolator_teff(_x)).reshape(-1)[0])	2✔
487	av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
488	mag = np.asarray(mag).reshape(-1)	2✔
489
490	# 5 / ln(10) = 2.17147241 converts fractional distance error to mag error
491	# (ln(10) / 2.5)^2 = 0.8483036976765438 converts magnitude variance to fractional flux variance
492	# of residuals squared
493	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 0.8483036976765438	2✔
494	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
495
496	if np.isfinite(d2).all():	2✔
497	if return_err:	2✔
498	return d2, e2	2✔
499
500	else:
501	return d2	2✔
502
503	else:
504	if return_err:	2✔
505	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
506
507	else:
508	return np.ones_like(obs)	×

cylammarco / WDPhotTools / 20631205081

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous