Source code for nirfmxvna.enums

"""enums.py - Contains enum classes."""

from enum import Enum, IntFlag




class TriggerType(Enum):
    """TriggerType."""

    NONE = 0
    r"""No trigger is configured."""

    DIGITAL_EDGE = 1
    r"""The trigger is asserted when a digital edge is detected. You can specify the source of the digital edge using the
    :py:attr:`~nirfmxvna.attributes.AttributeID.DIGITAL_EDGE_TRIGGER_SOURCE` attribute."""

    SOFTWARE = 2
    r"""The trigger is asserted when you send a software trigger. Use :py:meth:`send_software_edge_trigger` method to send a
    software trigger. RFmx ignores Software Edge Trigger when performing Calibration."""





class DigitalEdgeTriggerEdge(Enum):
    """DigitalEdgeTriggerEdge."""

    RISING_EDGE = 0
    r"""The trigger asserts on the rising edge of the digital-signal."""

    FALLING_EDGE = 1
    r"""The trigger asserts on the falling edge of the digital-signal."""





class TriggerMode(Enum):
    """TriggerMode."""

    SIGNAL = 0
    r"""VNA waits for asserting only one instance of trigger before acquiring all data points for the configured measurements
    in the RFmxVNA Signal namespace. You can specify the RFmxVNA Signal name using `Selector String
    <https://www.ni.com/docs/en-US/bundle/rfmx/page/selector-strings-net.html>`_ attribute."""

    SWEEP = 1
    r"""All data points that share a source port are acquired after VNA asserts one instance of the trigger.
    
    For example, when you  measure S11 and S22 at 10 frequency points using a 2-port VNA, after asserting the first
    instance of trigger, the device completes all acquisitions that require VNA port 1 as source. Upon asserting the second
    trigger, the device completes all acquisitions that require VNA port 2 as source."""

    POINT = 2
    r"""VNA acquires only one data point for each trigger instance that it asserts.
    
    For example, when you  measure S11 and S22 at 10 frequency points using a 2-port VNA, the device will assert a
    total of 20 trigger instances to complete all acquisitions."""

    SEGMENT = 3
    r"""When :py:attr:`~nirfmxvna.attributes.AttributeID.SWEEP_TYPE` attribute is set to **Segment**, all data points within a
    segment that share a source port are acquired after VNA asserts one instance of the trigger.
    
    For example, when measuring S11 and S22 using a 2-port VNA across 2 frequency segments, each containing 4
    frequency points, after the first trigger is asserted, the device completes all acquisitions in the first segment that
    require VNA port 1 as source. Upon asserting the second trigger, the device completes all acquisitions in the second
    segment that require VNA port 1 as source. On the third trigger, the device completes all acquisitions in the first
    segment that require VNA port 2 as source. On the fourth trigger, the device completes all acquisitions in the second
    segment that require VNA port 2 as source. Therefore, a total of 4 triggers are required to complete all acquisitions
    of both segments for both source ports."""





class ReadyForTriggerEventLevel(Enum):
    """ReadyForTriggerEventLevel."""

    ACTIVE_HIGH = 0
    r"""Event level is HIGH when analyzer is ready to receive trigger."""

    ACTIVE_LOW = 1
    r"""Event level is LOW when analyzer is ready to receive trigger."""





class IndexEventLevel(Enum):
    """IndexEventLevel."""

    ACTIVE_HIGH = 0
    r"""Event level is HIGH when analyzer has completed all the acquisitions for the signal."""

    ACTIVE_LOW = 1
    r"""Event level is LOW when analyzer has completed all the acquisitions for the signal."""





class SweepType(Enum):
    """SweepType."""

    LIST = 0
    r"""The frequency is swept in arbitrary frequency steps."""

    LINEAR = 1
    r"""The frequency is swept in equidistant steps over the frequency range."""

    SEGMENT = 2
    r"""The frequency is swept in frequency sub-sweeps, called segments.  For each segment, you can define independent values
    for settings like IF bandwidth, dwell time, source power level and test receiver attenuation."""

    CW_TIME = 4
    r"""The sweep is performed repeatedly on a single frequency and the measurement results are displayed versus time."""





class AutoIFBandwidthScalingEnabled(Enum):
    """AutoIFBandwidthScalingEnabled."""

    FALSE = 0
    r"""Disables automatic IF Bandwidth scaling that compensates for the increased VNA receiver noise at low frequencies."""

    TRUE = 1
    r"""Enables automatic IF Bandwidth scaling that compensates for the increased VNA receiver noise at low frequencies."""





class SweepSequence(Enum):
    """SweepSequence."""

    STANDARD = 0
    r"""Acquisitions for all frequency points are completed with the first source port before moving to the next source port.
    For example, if there are three frequency points f1, f2 and f3 and two source ports, port1 and port2, then the sweep
    sequence will be (f1, port1), (f2, port1), (f3, port1), (f1, port2), (f2, port2), (f3, port2)."""

    POINT = 1
    r"""All acquisitions for a frequency point are completed with all required source ports, before moving to the next
    frequency point. For example, if there are three frequency points f1, f2 and f3 and two source ports, port1 and port2,
    then the sweep sequence will be (f1, port1), (f1, port2), (f2, port1), (f2, port2), (f3, port1), (f3, port2)."""





class SegmentEnabled(Enum):
    """SegmentEnabled."""

    FALSE = 0
    r"""Disables the selected segment."""

    TRUE = 1
    r"""Enables the selected segment."""





class SegmentPowerLevelEnabled(Enum):
    """SegmentPowerLevelEnabled."""

    FALSE = 0
    r"""All segments are measured with the source power level that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.POWER_LEVEL` attribute."""

    TRUE = 1
    r"""The selected segment is measured with the source power level that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.SEGMENT_POWER_LEVEL` attribute."""





class SegmentIFBandwidthEnabled(Enum):
    """SegmentIFBandwidthEnabled."""

    FALSE = 0
    r"""All segments are measured with the digital IF filter bandwidth that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.IF_BANDWIDTH` attribute."""

    TRUE = 1
    r"""The selected segment is measured with the digital IF filter bandwidth that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.SEGMENT_IF_BANDWIDTH` attribute."""





class SegmentTestReceiverAttenuationEnabled(Enum):
    """SegmentTestReceiverAttenuationEnabled."""

    FALSE = 0
    r"""All segments are measured with the test receiver attenuation that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.TEST_RECEIVER_ATTENUATION` attribute."""

    TRUE = 1
    r"""The selected segment is measured with the test receiver attenuation that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.SEGMENT_TEST_RECEIVER_ATTENUATION` attribute."""





class SegmentDwellTimeEnabled(Enum):
    """SegmentDwellTimeEnabled."""

    FALSE = 0
    r"""All segments are measured with the dwell time that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.DWELL_TIME` attribute."""

    TRUE = 1
    r"""The selected segment is measured with the dwell time that you specify using
    :py:attr:`~nirfmxvna.attributes.AttributeID.SEGMENT_DWELL_TIME` attribute."""





class PulseModeEnabled(Enum):
    """PulseModeEnabled."""

    FALSE = 0
    r"""Disables pulse mode operation. VNA pulse modulator and pulse generators are disabled."""

    TRUE = 1
    r"""Enables pulse mode operation."""





class PulseTriggerType(Enum):
    """PulseTriggerType."""

    NONE = 0
    r"""Based on the :py:attr:`~nirfmxvna.attributes.AttributeID.PULSE_PERIOD` value that you set, the VNA creates an
    appropriate periodic pulse trigger internally. Pulse Trigger is used to control the timing of the RF pulse modulator.
    Additionally pulse trigger is used as timing reference for all the pulse generator digital signals that you enabled."""

    DIGITAL_EDGE = 1
    r"""Uses an external digital edge trigger as the pulse trigger."""





class PulseAcquisitionAuto(Enum):
    """PulseAcquisitionAuto."""

    FALSE = 0
    r"""The :py:attr:`~nirfmxvna.attributes.AttributeID.PULSE_ACQUISITION_DELAY` and
    :py:attr:`~nirfmxvna.attributes.AttributeID.PULSE_ACQUISITION_WIDTH` attributes are not automatically set by the
    measurement. The values that you set for these attributes are used by the measurement."""

    TRUE = 1
    r"""The measurement uses the :py:attr:`~nirfmxvna.attributes.AttributeID.PULSE_MODULATOR_WIDTH`  attribute to automatically
    set appropriate values for :py:attr:`~nirfmxvna.attributes.AttributeID.PULSE_ACQUISITION_DELAY` and
    :py:attr:`~nirfmxvna.attributes.AttributeID.PULSE_ACQUISITION_WIDTH` attributes.
    
    Pulse Acquisition Delay is set as the sum of Pulse Modulator Delay and approximately 20% of the Pulse
    Modulator Width, and Pulse Acquisition Width is set to approximately 75% of the Pulse Modulator Width."""





class PulseGeneratorEnabled(Enum):
    """PulseGeneratorEnabled."""

    FALSE = 0
    r"""Disables the selected pulse generator."""

    TRUE = 1
    r"""Enables the selected pulse generator."""





class AveragingEnabled(Enum):
    """AveragingEnabled."""

    FALSE = 0
    r"""Disables measurement averaging."""

    TRUE = 1
    r"""Enables measurement averaging. You can set number of times each measurement is repeated and averaged-over using the
    :py:attr:`~nirfmxvna.attributes.AttributeID.AVERAGING_COUNT` attribute."""





class CorrectionEnabled(Enum):
    """CorrectionEnabled."""

    FALSE = 0
    r"""The measurement disables error corection."""

    TRUE = 1
    r"""The measurement enables error correction."""





class CorrectionInterpolationEnabled(Enum):
    """CorrectionInterpolationEnabled."""

    FALSE = 0
    r"""The measurement disables interpolation of error terms for error correction."""

    TRUE = 1
    r"""The measurement enables interpolation of error terms for error correction."""





class CorrectionPortSubsetEnabled(Enum):
    """CorrectionPortSubsetEnabled."""

    FALSE = 0
    r"""The measurement disables port-subsetting for error correction."""

    TRUE = 1
    r"""The measurement enabes port-subsetting for error correction."""





class CorrectionPortExtensionEnabled(Enum):
    """CorrectionPortExtensionEnabled."""

    FALSE = 0
    r"""The measurement disables port extension."""

    TRUE = 1
    r"""The measurement enables port extension."""





class CorrectionPortExtensionDelayDomain(Enum):
    """CorrectionPortExtensionDelayDomain."""

    DELAY = 0
    r"""The port extension is specified in terms of its electrical delay."""

    DISTANCE = 1
    r"""The port extension is specified in terms of its physical length."""





class CorrectionPortExtensionDistanceUnit(Enum):
    """CorrectionPortExtensionDistanceUnit."""

    METERS = 0
    r"""The port extension physical length is expressed in meters."""

    FEET = 1
    r"""The port extension physical length is expressed in feet."""

    INCHES = 2
    r"""The port extension physical length is expressed in inches."""





class CorrectionPortExtensionDCLossEnabled(Enum):
    """CorrectionPortExtensionDCLossEnabled."""

    FALSE = 0
    r"""The measurement disables the compensation of DC Loss of the port extension."""

    TRUE = 1
    r"""The measurement compensates for the DC loss based on the value of  Port Extension DC Loss (dB) specified by you."""





class CorrectionPortExtensionLoss1Enabled(Enum):
    """CorrectionPortExtensionLoss1Enabled."""

    FALSE = 0
    r"""The measurement disables the compensation of Loss1 of the port extension."""

    TRUE = 1
    r"""The measurement compensates for the Loss1 based on the configured value of  Port Extension Loss1 (dB)."""





class CorrectionPortExtensionLoss2Enabled(Enum):
    """CorrectionPortExtensionLoss2Enabled."""

    FALSE = 0
    r"""The measurement disables the compensation of Loss2 of the port extension."""

    TRUE = 1
    r"""The measurement compensates for the Loss2 based on the configured value of  Port Extension Loss2 (dB)."""





class CorrectionPortExtensionAutoLossEnabled(Enum):
    """CorrectionPortExtensionAutoLossEnabled."""

    FALSE = 0
    r"""Disable the loss estimation in automatic port extension."""

    TRUE = 1
    r"""Enable the loss estimation in automatic port extension."""





class CorrectionPortExtensionAutoRegularizationEnabled(Enum):
    """CorrectionPortExtensionAutoRegularizationEnabled."""

    FALSE = 0
    r"""Disable the regularization of the compensated trace in automatic port extension."""

    TRUE = 1
    r"""Enable the regularization of the compensated trace in automatic port extension."""





class CorrectionPortExtensionAutoFrequencyMode(Enum):
    """CorrectionPortExtensionAutoFrequencyMode."""

    SWEEP = 0
    r"""Sets the frequency mode to Sweep. Configured sweep range is used to determine the phase and loss values."""

    USER = 1
    r"""Sets the frequency mode to User Span. User-defined span is used to determine the phase and loss values."""





class CorrectionCalibrationCalkitType(Enum):
    """CorrectionCalibrationCalkitType."""

    ELECTRONIC = 0
    r"""Perform calibration using an electronic calkit module.
    **Supported Electronic Calkit Modules**: NI CAL-5501."""

    MECHANICAL = 1
    r"""Perform calibration using discrete cal standards from a mechanical calkit."""





class CorrectionCalibrationMethod(Enum):
    """CorrectionCalibrationMethod."""

    SOL = 0
    r"""Full 1-port calibration using atleast three distinct reflection standards, typically named Short, Open and Load."""

    SOLT = 1
    r"""Full 2-port calibration by performing two SOL calibrations on the two ports using atleast three distinct reflection
    standards, and a Thru cal using a transmission standard connecting the two ports. Use
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_THRU_METHOD` attribute to select a suitable Thru cal
    procedure."""

    TRL = 2
    r"""Full 2-port calibration using a Thru, at least one Line, and one Reflect standard (Thru-Reflect-Line). The Thru
    standard can be an flush Thru or can have non-zero length (LRL, Line-Reflect-Line). The Reflect standard has to be
    identical for both ports. If multiple lines with different lengths are defined, the measurement automatically splits
    the measurement frequency range into segments and picks the line standard with appropriate length for each segment. The
    reference impedance of the calibration is the characteristic impedance of the Line(s)."""





class CorrectionCalibrationThruMethod(Enum):
    """CorrectionCalibrationThruMethod."""

    AUTO = 0
    r"""Measurement selects the appropriate Thru calibration method based on the value you specified for
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` attribute. If
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is **Electronic**, then **Delay Thru
    Using Defined Thru** is selected. If :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is
    **Mechanical**, then **Undefined Thru** is selected."""

    DEFINED_THRU = 1
    r"""The Thru definition from calkit definition is used based on the value you specified for
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` attribute. If
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is **Electronic**, the Thru definition
    from the electronic calkit EPROM is used. If
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is **Mechanical**, the Thru definition
    from the calkit definition file is used."""

    FLUSH_THRU = 2
    r"""Indicates a direct connection of the test ports when
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is **Mechanical**. The measured Thru is
    treated as flush Thru ignoring the Thru definition from the Calkit file. This method is not supported when
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is **Electronic**."""

    UNDEFINED_THRU = 3
    r"""Indicates connection of a Thru without a stored definition when
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is **Mechanical**. The measured Thru is
    treated as unknown Thru ignoring the Thru definition from the Calkit file. If a delay is configured, the delay will be
    utilized for the calibration. This method is not supported when
    :py:attr:`~nirfmxvna.attributes.AttributeID.CORRECTION_CALIBRATION_CALKIT_TYPE` is **Electronic**."""

    VCAL_THRU_AS_UNKNOWN_THRU = 5
    r"""The Thru from the electronical Calkit is used for Thru measurement during calibration. The Thru definirion from vCal
    EPROM is used as a phase reference for the Thru characterization during calibration.
    This method is not supported when Calkit Type is **Mechanical**."""





class SParamsFormat(Enum):
    """SParamsFormat."""

    MAGNITUDE = 0
    r"""Sets the format of the selected S-Parameter to Magnitude. You can specify
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_MAGNITUDE_UNITS`."""

    PHASE = 1
    r"""Sets the format of the selected S-Parameter to Phase. Phase values are expressed in degrees. Phase can be represented
    in various, mathematically equivalent ways such as phase wrapped between the range [-180, 180) degrees, or phase can be
    represented in an unwrapped manner. You can specify the phase representation by configuring
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_PHASE_TRACE_TYPE`."""

    COMPLEX = 2
    r"""Sets the format of the selected S-Parameter as complex numbers in cartesian co-ordinates."""

    SWR = 3
    r"""Sets the format of the selected S-Parameter to Standing Wave Ratio (SWR). SWR is a unitless quantity."""

    SMITH_IMPEDANCE = 4
    r"""Sets the format of the selected S-Parameter to Smith Impedance. S-Parameter values are transformed into impedence
    values. Impedence values are expressed in ohms. You can use these values to plot on a Smith Chart."""

    SMITH_ADMITTANCE = 5
    r"""Sets the format of the selected S-Parameter to Smith Admittance. S-Parameter values are transformed into admittance
    values. Admittance values are expressed in siemens. You can use these values to plot on an Inverted Smith Chart."""

    POLAR = 6
    r"""Sets the format of the selected S-Parameter as complex numbers in polar co-ordinates, where the radial axis (i.e.,
    magnitude of the complex numbers) is always in linear scale and angular axis (phase) is represented in degrees and
    always wrapped between ±180 deg."""

    GROUP_DELAY = 7
    r"""Sets the format of the selected S-Parameter to Group Delay. Group delay represents the time it takes for the signal to
    pass through a device under test. The delay is expressed in seconds.
    
    Group delay vs. frequency is derived from phase vs. frequency response. At a given frequency point, group delay
    is computed by selecting two nearby frequency points and taking the ratio of the phase difference to the frequency
    separation between them. The frequency separation between the two selected points is called the group delay aperture.
    
    You can control the aperture by first configuring
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_GROUP_DELAY_APERTURE_MODE` and once the mode is selected, you can
    set the aperture by configuring :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_GROUP_DELAY_APERTURE_POINTS`,
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_GROUP_DELAY_APERTURE_PERCENTAGE` or
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_GROUP_DELAY_APERTURE_FREQUENCY_SPAN`.
    
    For example, if the number of aperture points is equal to 3, then group delay at a nth frequency point is
    computed  by selecting the (n-1)th frequency point and (n+1)th frequency point."""





class SParamsMagnitudeUnits(Enum):
    """SParamsMagnitudeUnits."""

    DB = 0
    r"""Sets S-Parameter magnitude units to dB."""

    LINEAR = 1
    r"""Sets S-Parameter magnitude units to linear such that S-Parameters are reported in linear scale (V/V)."""





class SParamsPhaseTraceType(Enum):
    """SParamsPhaseTraceType."""

    WRAPPED = 0
    r"""The reported S-Parameter phase is wrapped between -180 degress to +180 degrees."""

    UNWRAPPED = 1
    r"""The reported S-Parameter phase is unwrapped."""





class SParamsGroupDelayApertureMode(Enum):
    """SParamsGroupDelayApertureMode."""

    POINTS = 0
    r"""Sets group delay aperture mode to Points. You can specify the aperture in terms of the number of frequency points by
    configuring :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_GROUP_DELAY_APERTURE_POINTS`."""

    PERCENTAGE = 1
    r"""Sets group delay aperture mode to Percentage. You can specify the aperture in terms of the frequency separation
    expressed in percentage by configuring
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_GROUP_DELAY_APERTURE_PERCENTAGE`."""

    FREQUENCY_SPAN = 2
    r"""Sets group delay aperture to Frequency Span. You can specify the aperture in terms of the frequency separation by
    configuring :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_GROUP_DELAY_APERTURE_PERCENTAGE`."""





class SParamsMathFunction(Enum):
    """SParamsMathFunction."""

    OFF = 0
    r"""No mathematical operation is performed."""

    ADD = 1
    r"""Data in measurement memory is added to S-Parameter data."""

    SUBTRACT = 2
    r"""Data in measurement memory is subtracted from S-Parameter data."""

    MULTIPLY = 3
    r"""S-Parameter data is multiplied by the data in measurement memory."""

    DIVIDE = 4
    r"""S-Parameter data is divided by the data in measurement memory."""





class SParamsCorrectionState(Enum):
    """SParamsCorrectionState."""

    NONE = 0
    r"""Error correction is not applied."""

    CORRECTED = 1
    r"""Error correction is applied without interpolation using the error terms from the calset."""

    INTERPOLATED = 2
    r"""Error correction is applied with error terms for at least one sweep point interpolated from the calset error terms."""

    SETTINGS_MODIFIED = 3
    r"""Settings during the measurment differ from those used during calibration."""





class SParamsSnPDataFormat(Enum):
    """SParamsSnPDataFormat."""

    AUTO = 0
    r"""RFmx automatically selects the appropriate SnP Data Format based on the value specified for
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_FORMAT`  attribute.
    
    If you set :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_FORMAT` to Complex or SWR or Smith Impedence or
    Smith Admittance or Group Delay, S-parameters are saved in the Real-Imaginary format.
    
    If you set :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_FORMAT` to Magnitude, S-parameters are saved as
    either Log Magnitude-Angle or Linear Magnitude-Angle according to
    :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_MAGNITUDE_UNITS`.
    
    If you set :py:attr:`~nirfmxvna.attributes.AttributeID.SPARAMS_FORMAT` to Phase or Polar, S-parameters are
    saved as Linear Magnitude-Angle by default."""

    LOG_MAGNITUDE_ANGLE = 1
    r"""All available S-parameters are represented as a pair of columns - first column stores magnitude of a S-Parameter in log
    scale (dB) and second column stores phase of the S-Parameter in degrees."""

    REAL_IMAGINARY = 2
    r"""All available S-parameters are represented as a pair of columns - first column stores real part of the complex-valued
    S-Parameter and second column stores imaginary part."""

    LINEAR_MAGNITUDE_ANGLE = 3
    r"""All available S-parameters are represented as a pair of columns - first column stores magnitude of a S-Parameter in
    linear scale (V/V) and second column stores phase of the S-Parameter in degrees."""





class WavesReceiver(Enum):
    """WavesReceiver."""

    TEST = 0
    r"""Measures the wave on the test receiver."""

    REFERENCE = 1
    r"""Measures the wave on the reference receiver."""





class WavesFormat(Enum):
    """WavesFormat."""

    MAGNITUDE = 0
    r"""Sets the format for the selected wave to Magnitude. You can specify
    :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_MAGNITUDE_UNITS`."""

    PHASE = 1
    r"""Sets the format of the selected wave to Phase. Phase values are expressed in degrees. Phase can be represented in
    various, mathematically equivalent ways such as phase wrapped between the range [-180, 180) degrees, or phase can be
    represented in an unwrapped manner. You can specify the phase representation by configuring
    :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_PHASE_TRACE_TYPE`."""

    COMPLEX = 2
    r"""Sets the format for the selected wave as complex numbers in cartesian co-ordinates."""

    SWR = 3
    r"""Sets the format for the selected wave to Standing Wave Ratio (SWR). SWR is a unitless quantity."""

    SMITH_IMPEDANCE = 4
    r"""Sets the format for the selected wave to Smith Impedance. The measured values of the wave are transformed into
    impedence values. Impedence values are expressed in ohms. You can use these values to plot on a Smith Chart."""

    SMITH_ADMITTANCE = 5
    r"""Sets the format for the selected wave to Smith Admittance. The measured values of the wave are transformed into
    admittance values. Admittance values are expressed in siemens. You can use these values to plot on an Inverted Smith
    Chart."""

    POLAR = 6
    r"""Sets the format for the selected wave as complex numbers in polar co-ordinates, where the radial axis (i.e., magnitude
    of the complex numbers) is always in linear scale and angular axis (phase) is represented in degrees and always wrapped
    between ±180 deg."""

    GROUP_DELAY = 7
    r"""Sets the format of the selected wave to Group Delay. Group delay represents the time it takes for the signal to pass
    through a device under test. The delay is expressed in seconds.
    
    Group delay vs. frequency is derived from phase vs. frequency response. At a given frequency point, group delay
    is computed by selecting two nearby frequency points and taking the ratio of the phase difference to the frequency
    separation between them. The frequency separation between the two selected points is called the group delay aperture.
    
    You can control the aperture by first configuring
    :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_GROUP_DELAY_APERTURE_MODE` and once the mode is selected, you can set
    the aperture by configuring :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_GROUP_DELAY_APERTURE_POINTS`,
    :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_GROUP_DELAY_APERTURE_PERCENTAGE` or
    :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_GROUP_DELAY_APERTURE_FREQUENCY_SPAN`.
    
    For example, if the number of aperture points is equal to 3, then group delay at a nth frequency point is
    computed by selecting the (n-1)th frequency point and (n+1)th frequency point."""





class WavesMagnitudeUnits(Enum):
    """WavesMagnitudeUnits."""

    DBM = 0
    r"""Sets wave magnitude units to dBm."""

    DBMV = 1
    r"""Sets wave magnitude units to dBmV."""

    DBUV = 2
    r"""Sets wave magnitude units to dBuV."""

    DBMA = 3
    r"""Sets wave magnitude units to dBmA."""

    W = 4
    r"""Sets wave magnitude units to watts."""

    V = 5
    r"""Sets wave magnitude units to volts."""

    A = 6
    r"""Sets wave magnitude units to ampere."""





class WavesPhaseTraceType(Enum):
    """WavesPhaseTraceType."""

    WRAPPED = 0
    r"""The reported wave phase is wrapped between -180 degress to +180 degrees."""

    UNWRAPPED = 1
    r"""The reported wave phase is unwrapped."""





class WavesGroupDelayApertureMode(Enum):
    """WavesGroupDelayApertureMode."""

    POINTS = 0
    r"""Sets group delay aperture mode to Points. You can specify the aperture in terms of the number of frequency points by
    configuring :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_GROUP_DELAY_APERTURE_POINTS`."""

    PERCENTAGE = 1
    r"""Sets group delay aperture mode to Percentage. You can specify the aperture in terms of the frequency separation
    expressed in percentage by configuring
    :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_GROUP_DELAY_APERTURE_PERCENTAGE`."""

    FREQUENCY_SPAN = 2
    r"""Sets group delay aperture to Frequency Span. You can specify the aperture in terms of the frequency separation by
    configuring :py:attr:`~nirfmxvna.attributes.AttributeID.WAVES_GROUP_DELAY_APERTURE_FREQUENCY_SPAN`."""





class WavesCorrectionState(Enum):
    """WavesCorrectionState."""

    NONE = 0
    r"""Error correction is not applied."""

    CORRECTED = 1
    r"""Error correction is applied without interpolation using the error terms from the calset."""

    INTERPOLATED = 2
    r"""Error correction is applied with error terms for at least one sweep point interpolated from the calset error terms."""

    SETTINGS_MODIFIED = 3
    r"""Settings during the measurment differ from those used during calibration."""





class IQCorrectionState(Enum):
    """IQCorrectionState."""

    NONE = 0
    r"""Error correction is not applied."""

    CORRECTED = 1
    r"""Error correction is applied without interpolation using the error terms from the calset."""

    INTERPOLATED = 2
    r"""Error correction is applied with error terms for at least one sweep point interpolated from the calset error terms."""

    SETTINGS_MODIFIED = 3
    r"""Settings during the measurment differ from those used during calibration."""





class LimitedConfigurationChange(Enum):
    """LimitedConfigurationChange."""

    DISABLED = 0
    r"""This is the normal mode of RFmx operation. All configuration changes in RFmxInstr attributes or RFmxVNA attributes will
    be applied during RFmx Commit."""

    NO_CHANGE = 1
    r"""Signal configuration and RFmxInstr configuration are locked after the first Commit or Initiate of the named signal
    configuration. Any configuration change thereafter either in RFmxInstr attributes or personality attributes will not be
    considered by subsequent RFmx Commits or Initiates of this signal. Use No Change if you have created named signal
    configurations for all measurement configurations but are setting some RFmxInstr attributes. Refer to the Limitations
    of the Limited Configuration Change Property topic for more details about the limitations of using this mode."""





class SourcePowerMode(Enum):
    """SourcePowerMode."""

    AUTO = 0
    r"""The source is turned on when making the measurement."""

    OFF = 1
    r"""The source is turned off for all the ports when making the measurements."""





class RestoreConfiguration(Enum):
    """RestoreConfiguration."""

    NONE = 0
    r"""Do not apply the stimulus settings from the calset."""

    STIMULUS = 1
    r"""Applies the stimulus settings from the calset."""





class MeasurementTypes(IntFlag):
    """MeasurementTypes."""

    SPARAMS = 1 << 0
    r"""Enables S-Parameter measurement."""

    WAVES = 1 << 1
    r"""Enables Wave measurement."""

    IQ = 1 << 2
    r"""Enables IQ measurement."""





class CalFrequencyGrid(Enum):
    """CalFrequencyGrid."""

    DIRECTIVITY = 0
    r"""Directivity measured at Measurement Port (Source Port ignored)."""

    SOURCE_MATCH = 1
    r"""Source Match measured at Measurement Port (Source Port ignored)."""

    REFLECTION_TRACKING = 2
    r"""Reflection Tracking measured at Measurement Port (Source Port ignored)."""

    TRANSMISSION_TRACKING = 3
    r"""Transmission Tracking measured at Measurement Port with Source Port being the source port."""

    LOAD_MATCH = 4
    r"""Load Match measured at Measurement Port with Source Port being the source port."""

    K = 5
    r"""K measured at Measurement Port (Source Port ignored)."""

    ALPHA = 6
    r"""alpha measured at Measurement Port (Source Port ignored)."""

    BETA = 7
    r"""beta measured at Measurement Port (Source Port ignored)."""

    GAMMA = 8
    r"""gamma measured at Measurement Port (Source Port ignored)."""

    DELTA = 9
    r"""delta measured at Measurement Port (Source Port ignored)."""

    SWITCH_TERM = 10
    r"""Switch term measured at Measurement Port (Source Port ignored)."""





class CalErrorTerm(Enum):
    """CalErrorTerm."""

    DIRECTIVITY = 0
    r"""Directivity measured at Measurement Port (Source Port ignored)."""

    SOURCE_MATCH = 1
    r"""Source Match measured at Measurement Port (Source Port ignored)."""

    REFLECTION_TRACKING = 2
    r"""Reflection Tracking measured at Measurement Port (Source Port ignored)."""

    TRANSMISSION_TRACKING = 3
    r"""Transmission Tracking measured at Measurement Port with Source Port being the source port."""

    LOAD_MATCH = 4
    r"""Load Match measured at Measurement Port with Source Port being the source port."""

    K = 5
    r"""K measured at Measurement Port (Source Port ignored)."""

    ALPHA = 6
    r"""alpha measured at Measurement Port (Source Port ignored)."""

    BETA = 7
    r"""beta measured at Measurement Port (Source Port ignored)."""

    GAMMA = 8
    r"""gamma measured at Measurement Port (Source Port ignored)."""

    DELTA = 9
    r"""delta measured at Measurement Port (Source Port ignored)."""

    SWITCH_TERM = 10
    r"""Switch term measured at Measurement Port (Source Port ignored)."""





class SParameterOrientation(Enum):
    """SParameterOrientation."""

    PORT1_TOWARDS_VNA = 0
    r"""Port 1 of the S2P is oriented towards the VNA."""

    PORT2_TOWARDS_VNA = 1
    r"""Port 2 of the S2P is oriented towards the VNA."""





class CalkitManagerCalkitConnectorGender(Enum):
    """CalkitManagerCalkitConnectorGender."""

    MALE = 0
    r"""Specifies male connector gender."""

    FEMALE = 1
    r"""Specifies female connector gender."""

    NO_GENDER = 2
    r"""Specifies no connector gender."""





class CalkitManagerCalkitTrlReferencePlane(Enum):
    """CalkitManagerCalkitTrlReferencePlane."""

    THRU = 0
    r"""Specifies Thru as the reference plane."""

    REFLECT = 1
    r"""Specifies Reflect as the reference plane."""





class CalkitManagerCalkitCalibrationElementType(Enum):
    """CalkitManagerCalkitCalibrationElementType."""

    LOAD = 0
    r"""Specifies Load calibration element type."""

    OPEN = 1
    r"""Specifies Open calibration element type."""

    SHORT = 2
    r"""Specifies Short calibration element type."""

    THRU = 3
    r"""Specifies Thru calibration element type."""

    LINE = 4
    r"""Specifies Line calibration element type."""

    REFLECT = 5
    r"""Specifies Reflect calibration element type."""

    TERMINATION = 6
    r"""Specifies Termination calibration element type."""





class CalkitManagerCalkitCalibrationElementSParameterDefinition(Enum):
    """CalkitManagerCalkitCalibrationElementSParameterDefinition."""

    REFLECT_MODEL = 0
    r"""S-Parameter is defined using reflect model."""

    SPARAMETER = 1
    r"""S-Parameter is defined using S-Parameter data."""

    DELAY_MODEL = 2
    r"""S-Parameter is defined using delay model."""

    UNKNOWN = 3
    r"""S-Parameter definition is unknown."""





class CalkitManagerCalkitCalibrationElementReflectModelType(Enum):
    """CalkitManagerCalkitCalibrationElementReflectModelType."""

    REFLECT_OPEN = 0
    r"""Reflect model is Open."""

    REFLECT_SHORT = 1
    r"""Reflect model is Short."""

    LOAD = 2
    r"""Reflect model is Load."""





class CalkitManagerCalkitCalibrationElementReflectModelSParameterAvailability(Enum):
    """CalkitManagerCalkitCalibrationElementReflectModelSParameterAvailability."""

    ESTIMATE = 0
    r"""S-Parameter is estimated."""

    KNOWN = 1
    r"""S-Parameter is known."""





class CalkitManagerCalkitCalibrationElementSParameterAvailability(Enum):
    """CalkitManagerCalkitCalibrationElementSParameterAvailability."""

    ESTIMATE = 0
    r"""S-Parameter is estimated."""

    KNOWN = 1
    r"""S-Parameter is known."""





class MarkerSearchMode(Enum):
    """MarkerSearchMode."""

    NONE = 0
    r"""No search is performed."""

    MAX = 1
    r"""Searches for the maximum value on the trace."""

    MIN = 2
    r"""Searches for the minimum value on the trace."""

    PEAK = 3
    r"""Searches for the peak on the trace."""

    NEXT_PEAK = 4
    r"""Searches for the next peak on the trace."""

    NEXT_LEFT_PEAK = 5
    r"""Searches for the next peak to the left on the trace."""

    NEXT_RIGHT_PEAK = 6
    r"""Searches for the next peak to the right on the trace."""

    TARGET = 7
    r"""Searches for the target value on the trace."""

    NEXT_LEFT_TARGET = 8
    r"""Searches for the next target to the left on the trace."""

    NEXT_RIGHT_TARGET = 9
    r"""Searches for the next target to the right on the trace."""





class MarkerType(Enum):
    """MarkerType."""

    OFF = 0
    r"""The marker is disabled."""

    NORMAL = 1
    r"""The marker is enabled as a normal marker."""

    DELTA = 2
    r"""The marker is enabled as a delta marker."""

    FIXED = 3
    r"""The marker is enabled as a fixed marker."""





class MarkerPeakSearchThresholdEnabled(Enum):
    """MarkerPeakSearchThresholdEnabled."""

    FALSE = 0
    r"""Disables the threshold for the trace while finding the peaks."""

    TRUE = 1
    r"""Enables the threshold for the trace while finding the peaks."""





class MarkerPeakSearchExcursionEnabled(Enum):
    """MarkerPeakSearchExcursionEnabled."""

    FALSE = 0
    r"""Disables the peak excursion check while finding the peaks on trace."""

    TRUE = 1
    r"""Enables the peak excursion check while finding the peaks on trace."""





class MarkerMode(Enum):
    """MarkerMode."""

    CONTINUOUS = 0
    r"""Marker is updated continuously during sweep."""

    DISCRETE = 1
    r"""Marker is updated only at discrete frequency points."""





class CorrectionPortExtensionAutoStandard(Enum):
    """CorrectionPortExtensionAutoStandard."""

    OPEN = 0
    r"""Uses Open standard for port extension."""

    SHORT = 1
    r"""Uses Short standard for port extension."""