25194239086

Committed 26 Apr 2026 08:07PM UTC coverage: 61.697% (-28.8%) from 90.54%

Build # 25194239086

Build Type

push

github

Committed by

jameswilburlewis

Commit Message

Added test for loading Cluster CODIF differential energy flux

Coverage Stats

0 of 7 new or added lines in 1 file covered. (0.0%)

19460 existing lines in 418 files now uncovered.

30204 of 48955 relevant lines covered (61.7%)

1.44 hits per line

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

71.43

/pyspedas/tplot_tools/tplot_math/makegap.py

import pyspedas
from pyspedas.tplot_tools import store_data, get_data, degap, del_data
import numpy as np


def makegap(var_data, dt=None, margin=0.0, func="nan"):
    """
    Fill gaps in the data either with NaNs or the last number.  This
    is identical to degap, except operates directly on the data and
    time arrays, rather than the tplot variable. This is intended for
    use with the data_gap option. This version actually puts the data
    into a temporary tplot variable, and call degap, then extracts
    that data into the proper form.

    Parameters
    ----------
        var_data : named tuple
            The data for the tplot variable, a structure that contains at least, tags for 'y' and 'times'
        dt : int/float
            Step size of the data in seconds, default is to use the median time interval
        margin : int/float, optional, default is 0.0 seconds (there is no margin in the IDL tplot makegap)
            The maximum deviation from the step size allowed before degapping occurs.  In other words,
            if you'd like to fill in data every 4 seconds but occasionally the data is 4.1 seconds apart,
            set the margin to .1 so that a data point is not inserted there.
        func : str, optional
            Either 'nan' or 'ffill', which overrides normal interpolation with NaN
            substitution or forward-filled values.

    Returns
    -------
    tuple
        A tuple returned by calling get_data() on the degapped temp variable

    Examples
    --------

        >>> import pyspedas
        >>> time = [pyspedas.time_float("2020-01-01") + i for i in [1, 2, 3, 4, 5, 6, 9, 10, 11]]
        >>> y = [1, 2, 3, 4, 5, 6, 9, 10, 11]
        >>> pyspedas.store_data("a", data={"x": time, "y": y})
        >>> a = pyspedas.get_data("a")
        >>> print(a)
        >>> b = pyspedas.makegap(a)
        >>> print(b)

    """
    # vt = var_data.times
    # gap_size = np.diff(vt) #vt is in nanoseconds, and np.diff works over day boundaries
    # Default for dt is the median value of gap_size, the time interval differences
    # if dt == None:
    #    dt = np.median(gap_size)
    #    dt0 = dt
    # else:
    # change dt to appropriate type
    #    dt0 = np.timedelta64(int(dt*1e9), 'ns')

    # gap_index_locations = np.where(gap_size > dt0)

    # First create a temporary tplot variable for the data, times need to be in unix time
    #x = time_float(var_data.times)
    x = np.int64(var_data.times)/1e9
    if var_data.y.ndim == 1:
        store_data("makegap_tmp", data={"x": x, "y": var_data.y})
    else:  # multiple dimensions
        var_data_out = None
        store_data("makegap_tmp", data={"x": x, "y": var_data.y})
        # Check for values, v, or v1, v2, v3
        if len(var_data) == 2:  # No v's
            store_data("makegap_tmp", data={"x": x, "y": var_data.y})
        elif len(var_data) == 3:  # v or v1,needs indexing if it's 2d
            store_data(
                "makegap_tmp", data={"x": x, "y": var_data.y, "v": var_data[2]}
            )
        elif len(var_data) == 4:  # has both v1 and v2
            store_data(
                "makegap_tmp",
                data={"x": x, "y": var_data.y, "v1": var_data[2], "v2": var_data[3]},
            )
        elif len(var_data) == 5:  # has v1, v2, v3
            store_data(
                "makegap_tmp",
                data={
                    "x": x,
                    "y": var_data.y,
                    "v1": var_data[2],
                    "v2": var_data[3],
                    "v3": var_data[3],
                },
            )
    # Now, degap the variable
    degap("makegap_tmp", dt=dt, margin=margin, func=func)
    # and return the getdata result
    var_data_out = get_data("makegap_tmp", dt=True)
    del_data("makegap_tmp")
    return var_data_out

1	import pyspedas	3✔
2	from pyspedas.tplot_tools import store_data, get_data, degap, del_data	3✔
3	import numpy as np	3✔
4
5
6	def makegap(var_data, dt=None, margin=0.0, func="nan"):	3✔
7	"""
8	Fill gaps in the data either with NaNs or the last number. This
9	is identical to degap, except operates directly on the data and
10	time arrays, rather than the tplot variable. This is intended for
11	use with the data_gap option. This version actually puts the data
12	into a temporary tplot variable, and call degap, then extracts
13	that data into the proper form.
14
15	Parameters
16	----------
17	var_data : named tuple
18	The data for the tplot variable, a structure that contains at least, tags for 'y' and 'times'
19	dt : int/float
20	Step size of the data in seconds, default is to use the median time interval
21	margin : int/float, optional, default is 0.0 seconds (there is no margin in the IDL tplot makegap)
22	The maximum deviation from the step size allowed before degapping occurs. In other words,
23	if you'd like to fill in data every 4 seconds but occasionally the data is 4.1 seconds apart,
24	set the margin to .1 so that a data point is not inserted there.
25	func : str, optional
26	Either 'nan' or 'ffill', which overrides normal interpolation with NaN
27	substitution or forward-filled values.
28
29	Returns
30	-------
31	tuple
32	A tuple returned by calling get_data() on the degapped temp variable
33
34	Examples
35	--------
36
37	>>> import pyspedas
38	>>> time = [pyspedas.time_float("2020-01-01") + i for i in [1, 2, 3, 4, 5, 6, 9, 10, 11]]
39	>>> y = [1, 2, 3, 4, 5, 6, 9, 10, 11]
40	>>> pyspedas.store_data("a", data={"x": time, "y": y})
41	>>> a = pyspedas.get_data("a")
42	>>> print(a)
43	>>> b = pyspedas.makegap(a)
44	>>> print(b)
45
46	"""
47	# vt = var_data.times
48	# gap_size = np.diff(vt) #vt is in nanoseconds, and np.diff works over day boundaries
49	# Default for dt is the median value of gap_size, the time interval differences
50	# if dt == None:
51	# dt = np.median(gap_size)
52	# dt0 = dt
53	# else:
54	# change dt to appropriate type
55	# dt0 = np.timedelta64(int(dt*1e9), 'ns')
56
57	# gap_index_locations = np.where(gap_size > dt0)
58
59	# First create a temporary tplot variable for the data, times need to be in unix time
60	#x = time_float(var_data.times)
UNCOV 61	x = np.int64(var_data.times)/1e9	1✔
UNCOV 62	if var_data.y.ndim == 1:	1✔
63	store_data("makegap_tmp", data={"x": x, "y": var_data.y})	×
64	else: # multiple dimensions
UNCOV 65	var_data_out = None	1✔
UNCOV 66	store_data("makegap_tmp", data={"x": x, "y": var_data.y})	1✔
67	# Check for values, v, or v1, v2, v3
UNCOV 68	if len(var_data) == 2: # No v's	1✔
69	store_data("makegap_tmp", data={"x": x, "y": var_data.y})	×
UNCOV 70	elif len(var_data) == 3: # v or v1,needs indexing if it's 2d	1✔
UNCOV 71	store_data(	1✔
72	"makegap_tmp", data={"x": x, "y": var_data.y, "v": var_data[2]}
73	)
74	elif len(var_data) == 4: # has both v1 and v2	×
75	store_data(	×
76	"makegap_tmp",
77	data={"x": x, "y": var_data.y, "v1": var_data[2], "v2": var_data[3]},
78	)
79	elif len(var_data) == 5: # has v1, v2, v3	×
80	store_data(	×
81	"makegap_tmp",
82	data={
83	"x": x,
84	"y": var_data.y,
85	"v1": var_data[2],
86	"v2": var_data[3],
87	"v3": var_data[3],
88	},
89	)
90	# Now, degap the variable
UNCOV 91	degap("makegap_tmp", dt=dt, margin=margin, func=func)	1✔
92	# and return the getdata result
UNCOV 93	var_data_out = get_data("makegap_tmp", dt=True)	1✔
UNCOV 94	del_data("makegap_tmp")	1✔
UNCOV 95	return var_data_out	1✔

spedas / pyspedas / 25194239086

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