19997282973

Committed 03 Nov 2025 11:37AM UTC coverage: 96.218% (-0.2%) from 96.39%

Build # 19997282973

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #41 from cylammarco/dev

fixed from actions/checkout version

Run Details

3155 of 3279 relevant lines covered (96.22%)

1.92 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 mag error
    # 1 / (ln(10) / 2.5) = 1.1788231063225867 converts magnitude variance to flux variance scaling in the denominator
    # of residuals squared
    e2 = (errors**2.0 + (distance_err / distance * 2.17147241) ** 2.0) * 1.1788231063225867
    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(interpolator_teff(_x[:2]))
    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(interpolator_teff(_x[:-1]))
    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
    # 1 / (ln(10) / 2.5) = 1.1788231063225867 converts magnitude variance to flux variance scaling in the denominator
    # of residuals squared
    e2 = (errors**2.0 + (distance_err / distance * 2.17147241) ** 2.0) * 1.1788231063225867
    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(interpolator_teff(_x))

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

cylammarco / WDPhotTools / 19997282973

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