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

93.1

/src/WDPhotTools/likelihood_functions.py

import numpy as np

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


def log_dummy_prior(*args):
    """
    Default log(prior) returns zero.

    """

    return 0.0


def log_likelihood(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    d2, e2 = diff2(_x, obs, errors, distance, distance_err, interpolator_filter, True)
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_distance(_x, obs, errors, interpolator_filter, prior):
    """
    Internal method for computing the ch2-squared value in cases when
    the distance is not provided (for emcee).

    """

    d2, e2 = diff2_distance(_x, obs, errors, interpolator_filter, True)
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_distance_red_filter(
    _x,
    obs,
    errors,
    interpolator_filter,
    interpolator_teff,
    logg_pos,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    z_min,
    z_max,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    d2, e2 = diff2_distance_red_filter(
        _x,
        obs,
        errors,
        interpolator_filter,
        interpolator_teff,
        logg_pos,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        z_min,
        z_max,
        True,
    )
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_distance_red_filter_fixed_logg(
    _x,
    obs,
    errors,
    interpolator_filter,
    interpolator_teff,
    logg,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    z_min,
    z_max,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    d2, e2 = diff2_distance_red_filter_fixed_logg(
        _x,
        obs,
        errors,
        interpolator_filter,
        interpolator_teff,
        logg,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        z_min,
        z_max,
        True,
    )
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_distance_red_interpolated(
    _x,
    obs,
    errors,
    interpolator_filter,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    z_min,
    z_max,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    d2, e2 = diff2_distance_red_interpolated(
        _x,
        obs,
        errors,
        interpolator_filter,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        z_min,
        z_max,
        True,
    )
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_distance_red_interpolated_fixed_logg(
    _x,
    obs,
    errors,
    interpolator_filter,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    z_min,
    z_max,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    d2, e2 = diff2_distance_red_interpolated_fixed_logg(
        _x,
        obs,
        errors,
        interpolator_filter,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        z_min,
        z_max,
        True,
    )
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_red_filter(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    interpolator_teff,
    logg_pos,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    z_min,
    z_max,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    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,
        z_min,
        z_max,
        True,
    )
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_red_filter_fixed_logg(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    interpolator_teff,
    logg,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    z_min,
    z_max,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    d2, e2 = diff2_red_filter_fixed_logg(
        _x,
        obs,
        errors,
        distance,
        distance_err,
        interpolator_filter,
        interpolator_teff,
        logg,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        z_min,
        z_max,
        True,
    )
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf


def log_likelihood_red_interpolated(
    _x,
    obs,
    errors,
    distance,
    distance_err,
    interpolator_filter,
    rv,
    extinction_mode,
    reddening_vector,
    ebv,
    ra,
    dec,
    z_min,
    z_max,
    prior,
):
    """
    Internal method for computing the ch2-squared value (for emcee).

    """

    d2, e2 = diff2_red_interpolated(
        _x,
        obs,
        errors,
        distance,
        distance_err,
        interpolator_filter,
        rv,
        extinction_mode,
        reddening_vector,
        ebv,
        ra,
        dec,
        z_min,
        z_max,
        True,
    )
    p = prior(*_x)

    if np.isfinite(d2).all():
        return -0.5 * np.sum(d2 + np.log(2 * np.pi * e2)) + p

    else:
        return -np.inf

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

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