29020259427

Committed 09 Jul 2026 01:06PM UTC coverage: 96.206% (+0.6%) from 95.575%

Build # 29020259427

Build Type

Pull #51

github

Committed by

web-flow

Commit Message

Merge aca384df6 into 59f833d41

Pull Request Pull Request #51: Sanitise extrapolation and examples

Coverage Stats

533 of 560 new or added lines in 12 files covered. (95.18%)

75 existing lines in 4 files now uncovered.

3778 of 3927 relevant lines covered (96.21%)

1.92 hits per line

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

80.85

/src/WDPhotTools/diff2_functions_minimize.py

import numpy as np

from .diff2_functions_least_square import (
    diff2,
    diff2_distance,
    diff2_red_filter,
    diff2_red_filter_fixed_logg,
    diff2_red_interpolated,
    diff2_distance_red_filter,
    diff2_distance_red_filter_fixed_logg,
    diff2_distance_red_interpolated,
    diff2_distance_red_interpolated_fixed_logg,
)


def diff2_summed(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    return_err,
    photometry_space="magnitude",
):
    """
    Internal method for computing the ch2-squared value (for scipy.optimize.minimize).

    """

    d2, e2 = diff2(
        _x,
        obs,
        errors,
        distance,
        distance_err,
        interpolator_filter,
        True,
        photometry_space=photometry_space,
    )

    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


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

    """
    d2, e2 = 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,
        True,
        photometry_space=photometry_space,
    )

    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


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

    """
    d2, e2 = diff2_red_filter_fixed_logg(
        _x,
        obs,
        errors,
        distance,
        distance_err,
        interpolator_filter,
        interpolator_teff,
        logg_pos,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        zmin,
        zmax,
        True,
        photometry_space=photometry_space,
    )

    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


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

    """

    d2, e2 = diff2_red_interpolated(
        _x,
        obs,
        errors,
        distance,
        distance_err,
        interpolator_filter,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        zmin,
        zmax,
        True,
        photometry_space=photometry_space,
    )
    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


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

    """

    d2, e2 = diff2_distance_red_filter(
        _x,
        obs,
        errors,
        interpolator_filter,
        interpolator_teff,
        logg_pos,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        zmin,
        zmax,
        True,
        photometry_space=photometry_space,
    )
    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


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

    """

    d2, e2 = diff2_distance_red_filter_fixed_logg(
        _x,
        obs,
        errors,
        interpolator_filter,
        interpolator_teff,
        logg,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        zmin,
        zmax,
        True,
        photometry_space=photometry_space,
    )
    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


def diff2_distance_summed(
    _x,
    obs,
    errors,
    interpolator_filter,
    return_error,
    photometry_space="magnitude",
):
    """
    Internal method for computing the ch2-squared value in cases when the distance is not provided (for
    scipy.optimize.minimize).

    """

    d2, e2 = diff2_distance(
        _x,
        obs,
        errors,
        interpolator_filter,
        True,
        photometry_space=photometry_space,
    )

    if return_error:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


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

    """

    d2, e2 = diff2_distance_red_interpolated(
        _x,
        obs,
        errors,
        interpolator_filter,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        zmin,
        zmax,
        True,
        photometry_space=photometry_space,
    )

    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)


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

    """

    d2, e2 = diff2_distance_red_interpolated_fixed_logg(
        _x,
        obs,
        errors,
        interpolator_filter,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        zmin,
        zmax,
        True,
        photometry_space=photometry_space,
    )

    if return_err:
        return np.sum(d2), 1.0 / np.sum(1.0 / e2)

    else:
        return np.sum(d2)

1	import numpy as np	2✔
2
3	from .diff2_functions_least_square import (	2✔
4	diff2,
5	diff2_distance,
6	diff2_red_filter,
7	diff2_red_filter_fixed_logg,
8	diff2_red_interpolated,
9	diff2_distance_red_filter,
10	diff2_distance_red_filter_fixed_logg,
11	diff2_distance_red_interpolated,
12	diff2_distance_red_interpolated_fixed_logg,
13	)
14
15
16	def diff2_summed(	2✔
17	_x,
18	obs,
19	errors,
20	distance,
21	distance_err,
22	interpolator_filter,
23	return_err,
24	photometry_space="magnitude",
25	):
26	"""
27	Internal method for computing the ch2-squared value (for scipy.optimize.minimize).
28
29	"""
30
31	d2, e2 = diff2(	2✔
32	_x,
33	obs,
34	errors,
35	distance,
36	distance_err,
37	interpolator_filter,
38	True,
39	photometry_space=photometry_space,
40	)
41
42	if return_err:	2✔
UNCOV 43	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
44
45	else:
46	return np.sum(d2)	2✔
47
48
49	def diff2_red_filter_summed(	2✔
50	_x,
51	obs,
52	errors,
53	distance,
54	distance_err,
55	interpolator_filter,
56	interpolator_teff,
57	logg_pos,
58	rv,
59	extinction_mode,
60	reddening_vector,
61	ebv,
62	ra,
63	dec,
64	zmin,
65	zmax,
66	return_err,
67	photometry_space="magnitude",
68	):
69	"""
70	Internal method for computing the ch2-squared value (for scipy.optimize.minimize).
71
72	"""
73	d2, e2 = diff2_red_filter(	2✔
74	_x,
75	obs,
76	errors,
77	distance,
78	distance_err,
79	interpolator_filter,
80	interpolator_teff,
81	logg_pos,
82	rv,
83	extinction_mode,
84	reddening_vector,
85	ebv,
86	ra,
87	dec,
88	zmin,
89	zmax,
90	True,
91	photometry_space=photometry_space,
92	)
93
94	if return_err:	2✔
UNCOV 95	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
96
97	else:
98	return np.sum(d2)	2✔
99
100
101	def diff2_red_filter_fixed_logg_summed(	2✔
102	_x,
103	obs,
104	errors,
105	distance,
106	distance_err,
107	interpolator_filter,
108	interpolator_teff,
109	logg_pos,
110	rv,
111	extinction_mode,
112	reddening_vector,
113	ebv,
114	ra,
115	dec,
116	zmin,
117	zmax,
118	return_err,
119	photometry_space="magnitude",
120	):
121	"""
122	Internal method for computing the ch2-squared value (for scipy.optimize.minimize).
123
124	"""
125	d2, e2 = diff2_red_filter_fixed_logg(	2✔
126	_x,
127	obs,
128	errors,
129	distance,
130	distance_err,
131	interpolator_filter,
132	interpolator_teff,
133	logg_pos,
134	rv,
135	extinction_mode,
136	reddening_vector,
137	ebv,
138	ra,
139	dec,
140	zmin,
141	zmax,
142	True,
143	photometry_space=photometry_space,
144	)
145
146	if return_err:	2✔
UNCOV 147	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
148
149	else:
150	return np.sum(d2)	2✔
151
152
153	def diff2_red_interpolated_summed(	2✔
154	_x,
155	obs,
156	errors,
157	distance,
158	distance_err,
159	interpolator_filter,
160	rv,
161	extinction_mode,
162	reddening_vector,
163	ebv,
164	ra,
165	dec,
166	zmin,
167	zmax,
168	return_err,
169	photometry_space="magnitude",
170	):
171	"""
172	Internal method for computing the ch2-squared value in cases when the distance is not provided (for
173	scipy.optimize.minimize).
174
175	"""
176
177	d2, e2 = diff2_red_interpolated(	2✔
178	_x,
179	obs,
180	errors,
181	distance,
182	distance_err,
183	interpolator_filter,
184	rv,
185	extinction_mode,
186	reddening_vector,
187	ebv,
188	ra,
189	dec,
190	zmin,
191	zmax,
192	True,
193	photometry_space=photometry_space,
194	)
195	if return_err:	2✔
UNCOV 196	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
197
198	else:
199	return np.sum(d2)	2✔
200
201
202	def diff2_distance_red_filter_summed(	2✔
203	_x,
204	obs,
205	errors,
206	interpolator_filter,
207	interpolator_teff,
208	logg_pos,
209	rv,
210	extinction_mode,
211	reddening_vector,
212	ebv,
213	ra,
214	dec,
215	zmin,
216	zmax,
217	return_err,
218	photometry_space="magnitude",
219	):
220	"""
221	Internal method for computing the ch2-squared value in cases when the distance is not provided (for
222	scipy.optimize.minimize).
223
224	"""
225
226	d2, e2 = diff2_distance_red_filter(	2✔
227	_x,
228	obs,
229	errors,
230	interpolator_filter,
231	interpolator_teff,
232	logg_pos,
233	rv,
234	extinction_mode,
235	reddening_vector,
236	ebv,
237	ra,
238	dec,
239	zmin,
240	zmax,
241	True,
242	photometry_space=photometry_space,
243	)
244	if return_err:	2✔
UNCOV 245	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
246
247	else:
248	return np.sum(d2)	2✔
249
250
251	def diff2_distance_red_filter_fixed_logg_summed(	2✔
252	_x,
253	obs,
254	errors,
255	interpolator_filter,
256	interpolator_teff,
257	logg,
258	rv,
259	extinction_mode,
260	reddening_vector,
261	ebv,
262	ra,
263	dec,
264	zmin,
265	zmax,
266	return_err,
267	photometry_space="magnitude",
268	):
269	"""
270	Internal method for computing the ch2-squared value in cases when the distance is not provided (for
271	scipy.optimize.minimize).
272
273	"""
274
275	d2, e2 = diff2_distance_red_filter_fixed_logg(	2✔
276	_x,
277	obs,
278	errors,
279	interpolator_filter,
280	interpolator_teff,
281	logg,
282	rv,
283	extinction_mode,
284	reddening_vector,
285	ebv,
286	ra,
287	dec,
288	zmin,
289	zmax,
290	True,
291	photometry_space=photometry_space,
292	)
293	if return_err:	2✔
UNCOV 294	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
295
296	else:
297	return np.sum(d2)	2✔
298
299
300	def diff2_distance_summed(	2✔
301	_x,
302	obs,
303	errors,
304	interpolator_filter,
305	return_error,
306	photometry_space="magnitude",
307	):
308	"""
309	Internal method for computing the ch2-squared value in cases when the distance is not provided (for
310	scipy.optimize.minimize).
311
312	"""
313
314	d2, e2 = diff2_distance(	2✔
315	_x,
316	obs,
317	errors,
318	interpolator_filter,
319	True,
320	photometry_space=photometry_space,
321	)
322
323	if return_error:	2✔
UNCOV 324	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
325
326	else:
327	return np.sum(d2)	2✔
328
329
330	def diff2_distance_red_interpolated_summed(	2✔
331	_x,
332	obs,
333	errors,
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	photometry_space="magnitude",
345	):
346	"""
347	Internal method for computing the ch2-squared value in cases when the distance is not provided (for
348	scipy.optimize.minimize).
349
350	"""
351
352	d2, e2 = diff2_distance_red_interpolated(	2✔
353	_x,
354	obs,
355	errors,
356	interpolator_filter,
357	rv,
358	extinction_mode,
359	reddening_vector,
360	ebv,
361	ra,
362	dec,
363	zmin,
364	zmax,
365	True,
366	photometry_space=photometry_space,
367	)
368
369	if return_err:	2✔
370	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
371
372	else:
373	return np.sum(d2)	2✔
374
375
376	def diff2_distance_red_interpolated_fixed_logg_summed(	2✔
377	_x,
378	obs,
379	errors,
380	interpolator_filter,
381	rv,
382	extinction_mode,
383	reddening_vector,
384	ebv,
385	ra,
386	dec,
387	zmin,
388	zmax,
389	return_err,
390	photometry_space="magnitude",
391	):
392	"""
393	Internal method for computing the ch2-squared value in cases when the distance is not provided (for
394	scipy.optimize.minimize).
395
396	"""
397
398	d2, e2 = diff2_distance_red_interpolated_fixed_logg(	2✔
399	_x,
400	obs,
401	errors,
402	interpolator_filter,
403	rv,
404	extinction_mode,
405	reddening_vector,
406	ebv,
407	ra,
408	dec,
409	zmin,
410	zmax,
411	True,
412	photometry_space=photometry_space,
413	)
414
415	if return_err:	2✔
UNCOV 416	return np.sum(d2), 1.0 / np.sum(1.0 / e2)	×
417
418	else:
419	return np.sum(d2)	2✔

cylammarco / WDPhotTools / 29020259427

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