reflection_coefficient module

Define the reflection coefficient virtual probe.

As for now, it is always a real, i.e. it is \(R = |\Gamma|\).

class ReflectionCoefficient(name, raw_data, forward, reflected, **kwargs)[source]

Bases: VirtualInstrument

Store the reflection coefficient.

We use the definition:

\[R = \frac{V_r}{V_f} = \sqrt{\frac{P_r}{P_f}}\]

where \(P_r\) is the reflected power and \(P_f\) is the forward power. This object is created by InstrumentFactory.run_virtual() when there is one ForwardPower and one ReflectedPower in its instruments argument.

Parameters:

name (str)
raw_data (Series)
forward (ForwardPower)
reflected (ReflectedPower)

recompute()[source]

Recompute reflection coefficient.

This method is called when one of the stored Power attributes data is changed.

Note

Also triggers the recalculation of SWR.

Return type:: Series

classmethod from_powers(forward, reflected, name='Reflection_coefficient', position=nan, **kwargs)[source]

Compute the reflection coefficient from given Power.

Parameters:

forward (ForwardPower)
reflected (ReflectedPower)
name (str, default: 'Reflection_coefficient')
position (float, default: nan)

Return type:

Self

classmethod ylabel()[source]

Label used for plots.

Return type:: str

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

_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 = True

_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.