17522145194

Committed 06 Jul 2025 07:39PM UTC coverage: 96.608% (-0.06%) from 96.669%

Build # 17522145194

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #38 from cylammarco/dev

Housekeeping

Run Details

3 of 4 new or added lines in 2 files covered. (75.0%)

3 existing lines in 2 files now uncovered.

3218 of 3331 relevant lines covered (96.61%)

1.93 hits per line

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

89.25

/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)

    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)
    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)
    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)
    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	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 1.1788231063225867	2✔
28	d2 = ((10.0 ** ((obs - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
29
30	if np.isfinite(d2).all():	2✔
31	if return_err:	2✔
32	return d2, e2	2✔
33
34	else:
35	return d2	2✔
36
37	else:
38	if return_err:	2✔
39	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
40
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	1✔
55
56	else:
57	return np.ones_like(obs) * np.inf	2✔
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✔
104	if return_err:	1✔
105	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	1✔
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:	2✔
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	2✔
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✔
UNCOV 224	if return_err:	×
UNCOV 225	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	×
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(interpolator_teff(_x[:2]))	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	×
288
289	else:
290	return np.ones_like(obs) * np.inf	2✔
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(interpolator_teff(_x[:-1]))	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	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 1.1788231063225867	2✔
361	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
362
363	if np.isfinite(d2).all():	2✔
364	if return_err:	2✔
365	return d2, e2	2✔
366
367	else:
368	return d2	2✔
369
370	else:
371	if return_err:	2✔
372	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
373
374	else:
375	return np.ones_like(obs) * np.inf	×
376
377
378	def diff2_red_filter(	2✔
379	_x,
380	obs,
381	errors,
382	distance,
383	distance_err,
384	interpolator_filter,
385	interpolator_teff,
386	logg_pos,
387	rv,
388	extinction_mode,
389	reddening_vector,
390	ebv,
391	ra,
392	dec,
393	zmin,
394	zmax,
395	return_err,
396	):
397	"""
398	Internal method for computing the ch2-squared value (for scipy.optimize.least_square).
399
400	"""
401
402	mag = []	2✔
403
404	for interp in interpolator_filter:	2✔
405	mag.append(interp(_x))	2✔
406
407	teff = float(interpolator_teff(_x))	2✔
408
409	if not np.isfinite(teff):	2✔
410	if return_err:	2✔
411	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
412
413	else:
414	return np.ones_like(obs) * np.inf	×
415
416	if extinction_mode == "total":	2✔
417	extinction_fraction = 1.0	2✔
418
419	else:
420	extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)	×
421
422	logg = _x[logg_pos]	2✔
423	av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
424	mag = np.asarray(mag).reshape(-1)	2✔
425	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 1.1788231063225867	2✔
426	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
427
428	if np.isfinite(d2).all():	2✔
429	if return_err:	2✔
430	return d2, e2	2✔
431
432	else:
433	return d2	2✔
434
435	else:
436	if return_err:	×
437	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	×
438
439	else:
440	return np.ones_like(obs) * np.inf	×
441
442
443	def diff2_red_filter_fixed_logg(	2✔
444	_x,
445	obs,
446	errors,
447	distance,
448	distance_err,
449	interpolator_filter,
450	interpolator_teff,
451	logg,
452	rv,
453	extinction_mode,
454	reddening_vector,
455	ebv,
456	ra,
457	dec,
458	zmin,
459	zmax,
460	return_err,
461	):
462	"""
463	Internal method for computing the ch2-squared value (for scipy.optimize.least_square).
464
465	"""
466
467	mag = []	2✔
468
469	for interp in interpolator_filter:	2✔
470	mag.append(interp(_x))	2✔
471
472	if extinction_mode == "total":	2✔
473	extinction_fraction = 1.0	2✔
474
475	else:
476	extinction_fraction = get_extinction_fraction(distance, ra, dec, zmin, zmax)	×
477
478	teff = float(interpolator_teff(_x))	2✔
479	av = np.array([i([logg, teff, rv]) for i in reddening_vector]).reshape(-1) * ebv * extinction_fraction	2✔
480	mag = np.asarray(mag).reshape(-1)	2✔
481	e2 = (errors*2.0 + (distance_err / distance 2.17147241) ** 2.0) * 1.1788231063225867	2✔
482	d2 = ((10.0 ** ((obs - av - mag - 5.0 * np.log10(distance) + 5.0) / 2.5) - 1.0) ** 2.0) / e2	2✔
483
484	if np.isfinite(d2).all():	2✔
485	if return_err:	2✔
486	return d2, e2	2✔
487
488	else:
489	return d2	2✔
490
491	else:
492	if return_err:	2✔
493	return np.ones_like(obs) * np.inf, np.ones_like(obs) * np.inf	2✔
494
495	else:
496	return np.ones_like(obs)	×

cylammarco / WDPhotTools / 17522145194

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