20978266610

Committed 14 Jan 2026 12:54AM UTC coverage: 95.519% (-0.6%) from 96.096%

Build # 20978266610

Build Type

push

github

Committed by

web-flow

Commit Message

v0.0.13 (#49)

* handling numpy 2 (#47)

* Compat: use numpy generic types for v1/v2 (np.floating/np.integer) in src; no stylistic changes

* Allow NumPy 2 in install: relax to >=1.23,<3; update README to state v1+v2 support

* updated array handling

* removed test output figure

* updated setup.cfg to include numpy2

* use asarray

* use np.where

* use where instead of argwhere; wrapped interpolator outputs with np.asarray(...).itme() or reshape(-1)[0].

* pack values in correct array shape for atmosphere interpolator

* Tests/coverage improvements (#48)

* tests: increase coverage and add edge-case tests across modules

* added more tests

* final fixes to the minimisation function and the interpolation functions. updated example scripts and tests.

* updated test

* avoid extrapolation in both ct and rbf interpolator for the atmosphere model

* fixed extrapolation issue

Run Details

299 of 337 new or added lines in 11 files covered. (88.72%)

4 existing lines in 3 files now uncovered.

3389 of 3548 relevant lines covered (95.52%)

1.91 hits per line

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

86.96

/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[:2]))

    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

    # Ensure finite residuals
    d2 = np.where(np.isfinite(d2), d2, np.float64(1e30))
    if return_err:
        e2 = np.where(np.isfinite(e2), e2, np.float64(1e30))
        return d2, e2
    else:
        return d2


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

cylammarco / WDPhotTools / 20978266610

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