field_probe module

Define field probe to measure electric field.

class FieldProbe(name, raw_data, attenuation_file=None, calibration_file=None, freq_mhz=None, **kwargs)[source]

Bases: IElectricField

A probe to measure electric field.

Parameters:

name (str)
raw_data (Series | None)
attenuation_file (str | None, default: None)
calibration_file (str | None, default: None)
freq_mhz (float | None, default: None)

_a_rack: float: Rack calibration slope in \(\mathrm{V/dBm}\).

_b_rack: float: Rack calibration constant in \(\mathrm{dBm}\).

_g_probe: float: Total attenuation. Probe specific, also depends on frequency.

classmethod ylabel()[source]

Label used for plots.

Return type:: str

_abc_impl = <_abc._abc_data object at 0x7466d864b040>

_get_plot_methods(is_2d)

Give the proper plotting functions according to is_2d.

Parameters:: is_2d (bool)
Return type:: tuple[Callable, Callable]

_notify_callbacks()

Call all callback functions.

Return type:: None

_plot_vs_position_for_1d(sample_index, raw=False, color=None, artist=None, axe=None, **kwargs)

Plot what instrument measured at its position, at a given time step.

Adapted to Pick-Up instruments.

Parameters:

sample_index (int) – Index of the measurements.
raw (bool, default: False) – If the raw data should be plotted.
color (tuple[float, float, float] | None, default: None) – Color of the plot.
artist (StemContainer | None, default: None) – If provided, the stem Artist object is updated rather than overwritten. It is mandatory for matplotlib animation to work.
axe (Axes | None, default: None) – Axe where the artist should be created. It must be provided if artist is not given.

Return type:

StemContainer

Returns:

The plotted stem.

_plot_vs_position_for_2d(sample_index, raw=False, color=None, axe=None, artist=None, **kwargs)

Plot what instrument measured at all positions, at a given time step.

Adapted to instruments with several positions, such as VirtualInstrument reproducing electric field envelope at all positions.

Parameters:

sample_index (int) – Index of the measurements.
raw (bool, default: False) – If the raw data should be plotted.
color (tuple[float, float, float] | None, default: None) – Color of the plot.
artist (Line2D | None, default: None) – If provided, the Line2D Artist object is updated rather than overwritten. It is mandatory for matplotlib animation to work.
axe (Axes | None, default: None) – Axe where the artist should be created. It must be provided if artist is not given.

Return type:

Line2D

Returns:

The plotted line.

_post_treat(data)

Apply all post-treatment functions.

Parameters:: data (ndarray[tuple[Any, ...], dtype[double]])
Return type:: ndarray[tuple[Any, ...], dtype[double]]

property _raw_data: Series

Raw data as measured by the instrument.

For classic Instrument, it should not change. For VirtualInstrument, it may change when the data it is calculated changes.

_raw_data_can_change = False

_scatter_data_1d(axes, multipactor, xdata=None)

Plot data, discriminating where there is multipactor or not.

Parameters:

axes (Axes) – Where to plot.
multipactor (ndarray[tuple[Any, ...], dtype[bool]]) – True where there is multipactor, False elsewhere.
xdata (float | ndarray[tuple[Any, ...], dtype[double]] | None, default: None) – x position of the data. The default is None, in which case we take position.

Return type:

None

_scatter_data_2d(*args, **kwargs)

Hold place.

Return type:: None

property _transfer_functions: list[Callable[[ndarray[tuple[Any, ...], dtype[float64]]], ndarray[tuple[Any, ...], dtype[float64]]]]

Give functions transforming acquisition voltage to physical quantity.

They are used when input files contain raw data, ie acquisition voltages.

add_post_treater(post_treater)

Append a single post-treating function.

Parameters:: post_treater (Callable[[ndarray[tuple[Any, ...], dtype[double]]], ndarray[tuple[Any, ...], dtype[double]]]) – Post-treating function to add. It must take an array as input, and return an array with the same size as output.
Return type:: None

property class_name: str: Get the name of the instrument class.

copy()

Deep copy of the instrument.

Return type:: Self

property data: ndarray[tuple[Any, ...], dtype[float64]]

Get the treated data.

Note that in order to save time, _data is not re-calculated from raw_data every time. Hence, it is primordial to re-set _y_data to None every time a change is made to _post_treaters.

property data_as_pd: Series | DataFrame: Get the treated data as a pandas object.

classmethod from_pd_dataframe(name, raw_data, **kwargs)

Instantiate the object from several CSV file columns.

Parameters:

name (str) – Name of the instrument.
raw_data (DataFrame) – Object holding several columns of the CSV.
kwargs – Other keyword arguments passed to the Instrument.

Return type:

Self

Returns:

An instrument. Note that its data attribute will be a 2D array.

growth_array(**kwargs)

Identify regions where the signal is increasing (“growing”).

This method analyzes a signal to determine where it exhibits a growing trend. It returns a float array of the same length as the input signal, where 1.0 indicates a region of growth and -1.0 otherwise. 0.0 means constant signal. A priori, will be useful for:

Notes

Designed for non-noisy instruments such as PowerSetpoint.

Parameters:

width – Width of the sample to determine increase.
no_change_value – Value to put in growth mask when we did not manage to find whether measured signal increased or not.
**kwargs – Additional keyword arguments passed to array_is_growing().

Return type:

ndarray[tuple[Any, ...], dtype[double]]

Returns:

Array where +1 means growing, -1 decreasing, 0 means constant.

growth_mask(minimum_number_of_points=0, n_trailing_points_to_check=0, width=10, **kwargs)

Identify regions where the signal is increasing (“growing”).

This method analyzes a signal to determine where it exhibits a growing trend. It returns a boolean array of the same length as the input signal, where True indicates a region of growth and False otherwise. A priori, will be useful for:

PowerSetpoint to determine power cycles. A fallback is ForwardPower.
RPA.

The method performs three main operations:

It uses a sliding-window heuristic (via array_is_growing()) to detect growth.
It removes short, isolated False segments, enforcing a minimum number of consecutive True values to be considered valid.
It clears any trailing True values near the end of the array to prevent spurious detections due to edge effects.

Parameters:

minimum_number_of_points (int, default: 0) – The minimum number of consecutive True values required to consider a region as growing. Shorter segments are suppressed.
n_trailing_points_to_check (int, default: 0) – The number of points at the end of the signal to check and force to False if they form an isolated or uncertain growth pattern. Particulatly useful for ForwardPower to avoid detection of a new power cycle at the end of the test.
width (int, default: 10) – Width of the sample to determine increase.
**kwargs – Additional keyword arguments passed to array_is_growing().

Return type:

ndarray[tuple[Any, ...], dtype[bool]]

Returns:

Boolean array indicating where the signal is growing.

Notes

The detection is influenced by the choice of parameters and the behavior of array_is_growing().
Trailing regions and short noise-like fluctuations are filtered out.

Todo

Consider adding post-processing to remove isolated True values.

property is_global: bool: Tell if instrument is global by checking if position is nan.

property label: str | None: Label used for legends in plots vs position.

property post_treaters: list[Callable[[ndarray[tuple[Any, ...], dtype[float64]]], ndarray[tuple[Any, ...], dtype[float64]]]]: Get the list of the post-treating functions.

property raw_data_as_pd: Series | DataFrame: Get the raw (untreated) data as a pandas object, without post-treating.

register_callback(cb)

Register the callback function.

Callback functions are called when a post-treater is added to Self. This is used when VirtualInstrument data depends on some other Instrument data. Currently used for:

ForwardPower (updates ReflectionCoefficient)
ReflectedPower (updates ReflectionCoefficient)
ReflectionCoefficient (updates SWR)

Parameters:: cb (Callable[[], Series])
Return type:: None

remove_post_treater(post_treater=None, index=None)

Remove post_treater or the post-treater at index index.

Parameters:

post_treater (Callable[[ndarray[tuple[Any, ...], dtype[double]]], ndarray[tuple[Any, ...], dtype[double]]] | None, default: None) – Post-treater to remove. Has priority over index.
index (int | None, default: None) – Index of post-treater to remove.

Return type:

None

replace(**overrides)

Copy with modified attributes.

Return type:: Self

__raw_data: Series

_data: ndarray[tuple[Any, ...], dtype[float64]]

_data_as_pd: Series | DataFrame

_post_treaters: list[Callable[[ndarray[tuple[Any, ...], dtype[float64]]], ndarray[tuple[Any, ...], dtype[float64]]]]

_callbacks: list[Callable[[], Series]]: Functions to call when a post-treater is added to current object.

See also

register_callback()

reduction_info: ReductionInfo | None: Set by PowerStep.to_single_values(). None until reduction occurs.

name: Name of the instrument.

position: The position of the instrument. If irrelevant (global diagnostic), must be set to np.nan.

_rf_rack_calibration_constants(calibration_file, freq_mhz, freq_col='Frequency [MHz]', a_col='a [dBm / V]', b_col='b [dBm]')[source]

Load calibration file, interpolate proper calibration data.

Todo

To refactor so that it takes calibration_folder as argument instead of calibration_file. Idea is to be more DRY.

The given file must look like:

# some comments
Probe       Frequency [MHz] a [dBm / V]     b [dBm]
E1  80.0    10.232945073011583      -51.43251555580861
E1  88.0    10.244590821913084      -51.46188696517617
E1  100.0   10.270347916270323      -51.578312368686596
E1  120.0   10.301710211286146      -51.73648053093371
E1  140.0   10.33558455881163       -51.83334288966003
E1  160.0   10.375268145607556      -51.91758233328844
E1  180.0   10.398407751401276      -51.87058673739318

The preferred way to create such a file is to use the dedicated tool.

Parameters:

calibration_file (Path | str) – Path to the CSV calibration file.
freq_mhz (float) – RF frequency for this test in \(\mathrm{MHz}\).
freq_col (str, default: 'Frequency [MHz]') – Name of the column holding the measure frequency in \(\mathrm{MHz}\).
a_col (str, default: 'a [dBm / V]') – Name of the column holding the measured slope in \(\mathrm{dBm/V}\).
b_col (str, default: 'b [dBm]') – Name of the column holding the measured bias in \(\mathrm{dBm}\).

Return type:

tuple[float, float]

_probe_attenuation(attenuation_file, freq_mhz, name)[source]

Load attenuation file, interpolate proper attenuation data.

The given file must look like:

# Calibration of electric field probes
# Adrien Placais measurement on 2025-06-11
# Attenuations are in dB
Frequency [MHz],100,120,140,160
NI9205_E1,-78.7,-77.2,-75.6,-75.4
NI9205_E2,-77.8,-77.4,-77.2,-75.4
NI9205_E3,-78.1,-77.2,-76.8,-76.6
NI9205_E4,-77.8,-76.8,-75.9,-74.6
NI9205_E5,-79.5,-76.9,-76.4,-75.5
NI9205_E6,-79.6,-78.2,-77.5,-76.9
NI9205_E7,-75.9,-76.6,-74.4,-74.0

Parameters:

attenuation_file (Path | str) – Path to the CSV attenuation file.
freq_mhz (float) – RF frequency for this test in \(\mathrm{MHz}\). If not present in the file, it is interpolated. If it is outside interpolation range, a warning is printed.
name (str) – Name of current column; must correspond to a line in the file.

Returns:

Attenuation for this probe at freq_mhz.

Return type:

float