inertialsim.sensors

Sensor specification and simulation.

The sensors module provides:

• classes to simulate gyroscope, accelerometer, and IMU sensor measurements from a wide variety of inputs (combinations of angular rate, specific force, acceleration, orientation, velocity, position and pose in local and global coordinate frames)
• classes to specify sensor parameters in customary units with automatic conversion to SI units
• classes to represent sensor simulation outputs (measurements, simulation state, and metadata)

Modules:

Name	Description
accelerometer	Accelerometer simulation.
gyro	Gyro simulation.
imu	Inertial Measurement Unit (IMU) simulation.

Classes:

Name	Description
Measurement	Sensor measurement data.
Sensor	An abstract base class for representing inertial sensors.
SensorModel	Specify which sources of error to simulate.
SensorState	Simulation internal state.
SimulationState	Simulation metadata.
Parameter	A parameter with value and associated units.
SensorSpecification	Sensor specification abstract base class.

Measurement

Measurement(
    *, data: NDArray, time: NDArray, sample_rate: float
)

Sensor measurement data.

Time sampled sensor measurement data. Measurement data can be timestamped with a time of validity for each measurement datum or can be uniformly sampled at a fixed rate. Measurements can consist of any number of channels (e.g. 3-axis sensors have 3 channels). There is no assumption that channels are independent, measurement data in each channel may be correlated or duplicated (such as results when non-orthogonal sensing axes measure a common input).

Use the from methods to construct an instance. Do not initialize an instance directly.

Methods:

Name	Description
from_timestamped_data	Construct a Measurement from timestamped data.
from_sampled_data	Construct a Measurement from uniformly sampled data.
from_measurements	Construct a Measurement from a collection of Measurements.

Attributes:

Name	Type	Description
data
time
sample_rate
num_measurements	int	The number of measurement samples.
num_channels	int	The number of independent channels or axes of measurement.

data instance-attribute

data = data

time instance-attribute

time = time

sample_rate instance-attribute

sample_rate = sample_rate

num_measurements property

num_measurements: int

The number of measurement samples.

num_channels property

num_channels: int

The number of independent channels or axes of measurement.

from_timestamped_data classmethod

from_timestamped_data(
    *,
    data: ArrayLike,
    time: ArrayLike,
    sample_rate: float | None = None,
) -> Self

Construct a Measurement from timestamped data.

Measurement data can be any array-like input with shape in ((N,), (N,1), (N,1,1), (N,M), (N,M,1)) where N is the time index of samples and M is the channel (or axis) index.

If sample_rate is input, the time input is checked for consistency with it. If sample_rate is None, the median sample rate of the time input is used. If only one data point is input, sample_rate must be supplied because it cannot be calculated.

The inputs are copied to prevent unexpected side effects.

Input shape

A 3-axis gyro sampled at 100Hz for 1 second will result in data with shape=(100,3) or shape=(100,3,1). This is 100 samples with 3 channels.

Sample rate inconsistencies

Sample rate inconsistencies must be avoided in inertial algorithms that require numerical differentiation, integration, or interpolation.

Parameters:

Name	Type	Description	Default
data	ArrayLike	Array of measurements.	required
time	ArrayLike	Array of unique, strictly increasing times corresponding to each measurement sample.	required
sample_rate	float | None	Expected sample rate (Hz).	None

Returns:

Name	Type	Description
measurement	Self	Measurement instance.

from_sampled_data classmethod

from_sampled_data(
    *, data: ArrayLike, sample_rate: float
) -> Self

Construct a Measurement from uniformly sampled data.

Measurement data can be any array-like input with shape in ((N,), (N,1), (N,1,1), (N,M), (N,M,1)) where N is the time index of samples and M is the channel (or axis) index.

A time span is constructed internally using the sample_rate input such that a unique timestamp is associated with each measurement sample.

The inputs are copied to prevent unexpected side effects.

Input shape

A 3-axis gyro sampled at 100Hz for 1 second will result in data with shape=(100,3) or shape=(100,3,1). This is 100 samples with 3 channels.

Parameters:

Name	Type	Description	Default
data	ArrayLike	Array of measurements.	required
sample_rate	float	Measurement sample rate (Hz).	required

Returns:

Name	Type	Description
measurement	Self	Measurement instance.

from_measurements classmethod

from_measurements(measurements: list[Self]) -> Self

Construct a Measurement from a collection of Measurements.

An efficient strategy for accumulating data is to store intermediate values in a list (or other container). This occurs, for example, when incrementally simulating Gyro, Accelerometer, or IMU outputs. This method allows for merging the result into a single Measurement instance once complete. See the example below.

Inputs do not need to be of the same dimension but they must have consistent sample rates, channel counts, and timestamps. The sample rate and time inputs are checked for consistency as described in the from_timestamped_data method.

Incremental simulation

# Simulating a gyro in a loop
gyro = Gyro(model, specification)
data = []
while simulating is True:
    datum = gyro.simulate(angular_rate=...)
    data.append(datum)

# Merge all measurements once complete
angular_rate = Measurement.from_list([datum.angular_rate for datum in data])

Parameters:

Name	Type	Description	Default
measurements	list[Self]	List of Measurement instances.	required

Returns:

Name	Type	Description
measurement	Self	Measurement instance.

Sensor

Sensor(
    model: SensorModel,
    specification: SensorSpecification,
    rng: Generator | int | None = None,
    mode: str = "batch",
    max_duration: float | None = None,
)

Bases: ABC

An abstract base class for representing inertial sensors.

Accelerometers and gyroscope inherit common attributes and methods.

Sensors requires a model which specifies which sources of error to simulate; a specification which includes the parameters necessary to model deterministic and stochastic errors; and optionally a random number generator or seed to control determinism and repeatability of the simulation.

Parameters:

Name	Type	Description	Default
model	SensorModel	Model options.	required
specification	SensorSpecification	Sensor specification.	required
rng	Generator | int | None	Random number generator or seed. See numpy.random.default_rng.	None
mode	str	One of batch (default) or real-time.	'batch'
max_duration	float | None	The maximum duration to precompute noise samples. If simulating in real-time mode, the maximum number of calls to the _simulate_from_rate() method that can be made is max_duration * sample_rate.	None

Attributes:

Name	Type	Description
state	SimulationState	Simulation state.

state property

state: SimulationState

Simulation state.

Return the simulation state. The state includes the sensor model; the sensor specification; the random number generator state at initialization; and the value of all internal sensor parameters required to replicate the simulated measurement outputs.

SensorModel

SensorModel()

Specify which sources of error to simulate.

By default all sources of error are simulated.

Default specifications

Sensor specification parameters default to zero (or identity). Unspecified parameters will have no effect on the simulation result regardless of the settings here.

Classes:

Name	Description
DataInterfaceModel	Specify which data interface options to simulate.
MisalignmentModel	Specify which misalignment options to simulate.
InputLimitsModel	Specify which input limits options to simulate.
BiasModel	Specify which bias options to simulate.
NoiseModel	Specify which random noise options to simulate.
ScaleFactorModel	Specify which scale factor options to simulate.

Methods:

Name	Description
reset	Reset model parameters to their defaults.
set_all	Set all model parameters.

Attributes:

Name	Type	Description
data_interface
misalignment
input_limits
bias
noise
scale_factor

data_interface instance-attribute

data_interface = DataInterfaceModel()

misalignment instance-attribute

misalignment = MisalignmentModel()

input_limits instance-attribute

input_limits = InputLimitsModel()

bias instance-attribute

bias = BiasModel()

noise instance-attribute

noise = NoiseModel()

scale_factor instance-attribute

scale_factor = ScaleFactorModel()

DataInterfaceModel dataclass

DataInterfaceModel(
    *,
    simulate_sample_rate: bool = True,
    simulate_quantization: bool = True,
    simulate_delta_outputs: bool = False,
)

Specify which data interface options to simulate.

Attributes:

Name	Type	Description
simulate_sample_rate	bool
simulate_quantization	bool
simulate_delta_outputs	bool

simulate_sample_rate class-attribute instance-attribute

simulate_sample_rate: bool = True

simulate_quantization class-attribute instance-attribute

simulate_quantization: bool = True

simulate_delta_outputs class-attribute instance-attribute

simulate_delta_outputs: bool = False

MisalignmentModel dataclass

MisalignmentModel(*, simulate_random: bool = True)

Specify which misalignment options to simulate.

Attributes:

Name	Type	Description
simulate_random	bool

simulate_random class-attribute instance-attribute

simulate_random: bool = True

InputLimitsModel dataclass

InputLimitsModel(
    *,
    simulate_minimum: bool = True,
    simulate_maximum: bool = True,
)

Specify which input limits options to simulate.

Attributes:

Name	Type	Description
simulate_minimum	bool
simulate_maximum	bool

simulate_minimum class-attribute instance-attribute

simulate_minimum: bool = True

simulate_maximum class-attribute instance-attribute

simulate_maximum: bool = True

BiasModel dataclass

BiasModel(
    *,
    simulate_fixed: bool = True,
    simulate_random: bool = True,
    simulate_temperature: bool = True,
)

Specify which bias options to simulate.

Attributes:

Name	Type	Description
simulate_fixed	bool
simulate_random	bool
simulate_temperature	bool

simulate_fixed class-attribute instance-attribute

simulate_fixed: bool = True

simulate_random class-attribute instance-attribute

simulate_random: bool = True

simulate_temperature class-attribute instance-attribute

simulate_temperature: bool = True

NoiseModel dataclass

NoiseModel(
    *,
    simulate_quantization: bool = True,
    simulate_random_walk: bool = True,
    simulate_bias_instability: bool = True,
    simulate_rate_random_walk: bool = True,
    simulate_rate_ramp: bool = True,
)

Specify which random noise options to simulate.

Attributes:

Name	Type	Description
simulate_quantization	bool
simulate_random_walk	bool
simulate_bias_instability	bool
simulate_rate_random_walk	bool
simulate_rate_ramp	bool

simulate_quantization class-attribute instance-attribute

simulate_quantization: bool = True

simulate_random_walk class-attribute instance-attribute

simulate_random_walk: bool = True

simulate_bias_instability class-attribute instance-attribute

simulate_bias_instability: bool = True

simulate_rate_random_walk class-attribute instance-attribute

simulate_rate_random_walk: bool = True

simulate_rate_ramp class-attribute instance-attribute

simulate_rate_ramp: bool = True

ScaleFactorModel dataclass

ScaleFactorModel(
    *,
    simulate_fixed: bool = True,
    simulate_random: bool = True,
)

Specify which scale factor options to simulate.

Attributes:

Name	Type	Description
simulate_fixed	bool
simulate_random	bool

simulate_fixed class-attribute instance-attribute

simulate_fixed: bool = True

simulate_random class-attribute instance-attribute

simulate_random: bool = True

reset

reset() -> None

Reset model parameters to their defaults.

set_all

set_all(*, value: bool) -> None

Set all model parameters.

All model parameters will be set to the input value, True or False.

Parameters:

Name	Type	Description	Default
value	bool	True or False.	required

SensorState dataclass

SensorState(
    *,
    data_interface: DataInterfaceState = DataInterfaceState(),
    input_limits: InputLimitsState = InputLimitsState(),
    misalignment: MisalignmentState = MisalignmentState(),
    bias: BiasState = BiasState(),
    noise: NoiseState = NoiseState(),
    scale_factor: ScaleFactorState = ScaleFactorState(),
)

Simulation internal state.

Fixed (non-random) simulation parameters are stored once. Random simulation parameters are stored for each time step of the Measurement output. Parameters that are not simulated (as determined by the SensorModel or IMUModel) default to None.

Classes:

Name	Description
DataInterfaceState	Data interface simulation internal state.
MisalignmentState	Misalignment simulation internal state.
InputLimitsState	Input limits simulation internal state.
BiasState	Bias simulation internal state.
NoiseState	Random noise simulation internal state.
ScaleFactorState	Scale factor error simulation internal state.

Attributes:

Name	Type	Description
data_interface	DataInterfaceState
input_limits	InputLimitsState
misalignment	MisalignmentState
bias	BiasState
noise	NoiseState
scale_factor	ScaleFactorState

data_interface class-attribute instance-attribute

data_interface: DataInterfaceState = field(
    default_factory=DataInterfaceState
)

input_limits class-attribute instance-attribute

input_limits: InputLimitsState = field(
    default_factory=InputLimitsState
)

misalignment class-attribute instance-attribute

misalignment: MisalignmentState = field(
    default_factory=MisalignmentState
)

bias class-attribute instance-attribute

bias: BiasState = field(default_factory=BiasState)

noise class-attribute instance-attribute

noise: NoiseState = field(default_factory=NoiseState)

scale_factor class-attribute instance-attribute

scale_factor: ScaleFactorState = field(
    default_factory=ScaleFactorState
)

DataInterfaceState dataclass

DataInterfaceState(
    *,
    quantization: NDArray | None = None,
    delta_quantization: NDArray | None = None,
)

Data interface simulation internal state.

Attributes:

Name	Type	Description
quantization	NDArray | None
delta_quantization	NDArray | None

quantization class-attribute instance-attribute

quantization: NDArray | None = None

delta_quantization class-attribute instance-attribute

delta_quantization: NDArray | None = None

MisalignmentState dataclass

MisalignmentState(
    *,
    fixed: NDArray | None = None,
    random: NDArray | None = None,
    total: NDArray | None = None,
)

Misalignment simulation internal state.

Attributes:

Name	Type	Description
fixed	NDArray | None
random	NDArray | None
total	NDArray | None

fixed class-attribute instance-attribute

fixed: NDArray | None = None

random class-attribute instance-attribute

random: NDArray | None = None

total class-attribute instance-attribute

total: NDArray | None = None

InputLimitsState dataclass

InputLimitsState(
    *,
    minimum: NDArray | None = None,
    maximum: NDArray | None = None,
)

Input limits simulation internal state.

Attributes:

Name	Type	Description
minimum	NDArray | None
maximum	NDArray | None

minimum class-attribute instance-attribute

minimum: NDArray | None = None

maximum class-attribute instance-attribute

maximum: NDArray | None = None

BiasState dataclass

BiasState(
    *,
    fixed: NDArray | None = None,
    random: NDArray | None = None,
    temperature: NDArray | None = None,
)

Bias simulation internal state.

Attributes:

Name	Type	Description
fixed	NDArray | None
random	NDArray | None
temperature	NDArray | None

fixed class-attribute instance-attribute

fixed: NDArray | None = None

random class-attribute instance-attribute

random: NDArray | None = None

temperature class-attribute instance-attribute

temperature: NDArray | None = None

NoiseState dataclass

NoiseState(
    *,
    quantization: NDArray | None = None,
    random_walk: NDArray | None = None,
    bias_instability: NDArray | None = None,
    rate_random_walk: NDArray | None = None,
    rate_ramp: NDArray | None = None,
)

Random noise simulation internal state.

Attributes:

Name	Type	Description
quantization	NDArray | None
random_walk	NDArray | None
bias_instability	NDArray | None
rate_random_walk	NDArray | None
rate_ramp	NDArray | None

quantization class-attribute instance-attribute

quantization: NDArray | None = None

random_walk class-attribute instance-attribute

random_walk: NDArray | None = None

bias_instability class-attribute instance-attribute

bias_instability: NDArray | None = None

rate_random_walk class-attribute instance-attribute

rate_random_walk: NDArray | None = None

rate_ramp class-attribute instance-attribute

rate_ramp: NDArray | None = None

ScaleFactorState dataclass

ScaleFactorState(
    fixed: NDArray | None = None,
    random: NDArray | None = None,
)

Scale factor error simulation internal state.

Attributes:

Name	Type	Description
fixed	NDArray | None
random	NDArray | None

fixed class-attribute instance-attribute

fixed: NDArray | None = None

random class-attribute instance-attribute

random: NDArray | None = None

SimulationState dataclass

SimulationState(
    *,
    model: SensorModel,
    specification: SensorSpecification,
    rng: Mapping,
    sensor: SensorState = SensorState(),
)

Simulation metadata.

Inputs and internal state sufficient to regenerate simulation results. Sensor model options, and sensor specification parameters are user inputs. Along with the state field of the numpy.random.BitGenerator stored in the random number generator, they are sufficient to duplicate a simulation. The state data records the fixed and random errors applied to the simulation input that resulted in the output.

Attributes:

Name	Type	Description
model	SensorModel
specification	SensorSpecification
rng	Mapping
sensor	SensorState

model instance-attribute

model: SensorModel

specification instance-attribute

specification: SensorSpecification

rng instance-attribute

rng: Mapping

sensor class-attribute instance-attribute

sensor: SensorState = field(default_factory=SensorState)

Parameter

Parameter(value: ArrayLike, units: str)

A parameter with value and associated units.

Parameters are used to set sensor specifications to ensure unit conversions are handled correctly. Parameter attributes are read only so that the value and units cannot be changed independently.

Attributes:

Name	Type	Description
value	NDArray	Numeric value of the parameter (typically an array with each element applicable to one axis of the sensor).
units	str	String representing the units of the value (e.g. "rad/s" or "m/s/s").

Methods:

Name	Description
per_axis	Return a new Parameter with the value applied on a per-axis basis.
to_si_units	Return a new parameter in SI units.

value property

value: NDArray

value: A numeric value or array of values.

units property

units: str

units: The units of measurement of the associated value.

per_axis

per_axis(axes: int) -> Parameter

Return a new Parameter with the value applied on a per-axis basis.

If the parameter is specified as a single value, return a new parameter with an array of value replicated across the requested number of axes. If the parameter value is already a vector of the correct size and shape it is unchanged. The units field is unchanged.

Parameters:

Name	Type	Description	Default
axes	int	Number of axes.	required

Returns:

Name	Type	Description
parameter	Parameter	New Parameter instance. The original is unchanged.

to_si_units

to_si_units() -> Parameter

Return a new parameter in SI units.

Returns a new Parameter object with the value and units fields converted to SI units.

Supported units

This function only supports common inertial sensor units. It does not support conversion of arbitrary units. The numerator of the units string can include any of "deg" for degrees, "%", "ppm" for parts-per-million, "ft" for feet or "g" for units of standard gravity. The denominator(s) can include any of "/h" for per hour, "/sqrt(h)" for per square-root hour, "/s/sqrt(Hz)" for per second per square root Hertz and "/F" for per degree Fahrenheit.

Returns:

Name	Type	Description
parameter	Parameter	New Parameter instance. The original is unchanged.

SensorSpecification

SensorSpecification(axes: int = NUM_CARTESIAN_AXES)

Bases: ABC

Sensor specification abstract base class.

A generic inertial sensor specification that includes data interface, input limits, noise coefficients, biases, scale factors, and sensor misalignments.

Derived classes must implement the abstract attributes and methods.

Classes:

Name	Description
DataInterface	An abstract base class for data interface parameters.
InputLimits	Sensor input limits.
Noise	Sensor noise terms.
Bias	Sensor bias terms.
ScaleFactor	Sensor scale factor terms.
Misalignment	Sensor misalignment.

Attributes:

Name	Type	Description
axes	int	Number of independent sensing axes of the sensor.
manufacturer	str	Manufacturer of the sensor.
model	str	Model number/identifier of the sensor.
version	str	Version number/identifier of the sensor.
data_interface	DataInterface	Sensor data interface specifications.
input_limits	InputLimits	Sensor input limits specification.
noise	Noise	Sensor noise specification.
bias	Bias	Sensor bias specification.
scale_factor	ScaleFactor	Sensor scale factor specification.
misalignment	Misalignment	A sensor misalignment specification.

axes property

axes: int

Number of independent sensing axes of the sensor.

manufacturer property writable

manufacturer: str

Manufacturer of the sensor.

model property writable

model: str

Model number/identifier of the sensor.

version property writable

version: str

Version number/identifier of the sensor.

data_interface deletable property writable

data_interface: DataInterface

Sensor data interface specifications.

input_limits abstractmethod property

input_limits: InputLimits

Sensor input limits specification.

noise abstractmethod property

noise: Noise

Sensor noise specification.

bias abstractmethod property

bias: Bias

Sensor bias specification.

scale_factor property

scale_factor: ScaleFactor

Sensor scale factor specification.

misalignment property

misalignment: Misalignment

A sensor misalignment specification.

DataInterface

DataInterface(axes: int)

Bases: ABC

An abstract base class for data interface parameters.

The data interface of the sensor. The sensor interface includes the data frequency, which is the frequency at which the sensor transmits new data, and the data type, which is one of rate or delta.

Derived classes should set appropriate defaults and handle units in the setter methods.

Attributes:

Name	Type	Description
sample_rate	Parameter	The frequency at which new data is output from the sensor.
delta_sample_rate	Parameter	The frequency at which delta type data is output from the sensor.
quantization	Parameter | None	Data interface rate output quantization.
delta_quantization	Parameter | None	Data interface delta output quantization.
delta_stride	int	Integer number of rate outputs per delta output.

sample_rate property writable

sample_rate: Parameter

The frequency at which new data is output from the sensor.

Units must be "Hz". Default value = Parameter(100, "Hz").

delta_sample_rate property writable

delta_sample_rate: Parameter

The frequency at which delta type data is output from the sensor.

Units must be "Hz" and must be a integer divisor of sample_rate. Default value = Parameter(0, "Hz") meaning no delta outputs.

quantization abstractmethod property writable

quantization: Parameter | None

Data interface rate output quantization.

Outputs will be quantized at simulated digital levels. Use this when the parameters of the analog to digital conversion are known. If the sensor to simulate has been characterized experimentally, e.g. by the Allan deviation method, use Noise.quantization instead. Do not use both.

delta_quantization abstractmethod property writable

delta_quantization: Parameter | None

Data interface delta output quantization.

Delta (integrated) outputs will be quantized at simulated digital levels. Use this when the parameters of the analog to digital conversion are known. If the sensor to simulate has been characterized experimentally, e.g. by the Allan deviation method, use Noise.quantization instead. Do not use both.

delta_stride property

delta_stride: int

Integer number of rate outputs per delta output.

InputLimits

InputLimits(axes: int)

Bases: ABC

Sensor input limits.

The extreme values of the input (negative and positive) within which performance is of the specified accuracy. Simulated outputs outside of this range are truncated to these limits.

Derived classes should set appropriate defaults and handle units in the setter methods.

Attributes:

Name	Type	Description
minimum	Parameter	Minimum negative input.
maximum	Parameter	Maximum positive input.

minimum abstractmethod property writable

minimum: Parameter

Minimum negative input.

Simulated outputs less than this value will be truncated to this value.

maximum abstractmethod property writable

maximum: Parameter

Maximum positive input.

Simulated outputs greater than this value will be truncated to this value.

Noise

Noise(axes: int)

Bases: ABC

Sensor noise terms.

Common inertial sensor noise terms describing quantization, random walk, bias instability, rate random walk, and rate ramp. See Reference [20] and Standard [05] & Standard [06] for details.

Each of these noise terms can be determined experimentally from Allan variance/deviation plots or from data sheets and direct knowledge of the sensor. Not all terms will be applicable to all sensors.

Derived classes should set appropriate defaults and handle units in the setter methods.

Attributes:

Name	Type	Description
quantization	Parameter	Quantization noise.
random_walk	Parameter	Random walk noise.
bias_instability	Parameter	Bias instability noise.
rate_random_walk	Parameter	Rate random walk noise.
rate_ramp	Parameter	Rate ramp noise.

quantization abstractmethod property writable

quantization: Parameter

Quantization noise.

Uniformly distributed random noise arising from digital quantization of the input. Use this parameter when the sensor to simulate has been characterized experimentally, e.g. by the Allan deviation method. If the parameters of the analog to digital converter are known explicitly, use ScaleFactor.quantization instead. Do not use both.

random_walk abstractmethod property writable

random_walk: Parameter

Random walk noise.

Random white noise in the signal that when integrated results in error buildup. Also known equivalently as noise density.

bias_instability abstractmethod property writable

bias_instability: Parameter

Bias instability noise.

The random variation in bias as computed over specified finite sampling time and averaging time intervals. Also known equivalently as bias in-run stability and flicker noise.

rate_random_walk abstractmethod property writable

rate_random_walk: Parameter

Rate random walk noise.

Random white noise in the signal derivative that results in error buildup.

rate_ramp abstractmethod property writable

rate_ramp: Parameter

Rate ramp noise.

Linear increase in the signal over long averaging time intervals.

Bias

Bias(axes: int)

Bases: ABC

Sensor bias terms.

Bias is the non-zero output of a sensor at rest, or equivalently, the output that has no correlation with the input. It is comprised of a fixed component (that can be calibrated), a random component (that may vary from turn-on to turn-on or with changing conditions), and a temperature dependent component.

Derived classes should set appropriate defaults and handle units in the setter methods.

Attributes:

Name	Type	Description
fixed	Parameter	Fixed bias.
repeatability	Parameter	Random bias.
temperature	Parameter	Temperature bias.

fixed abstractmethod property writable

fixed: Parameter

Fixed bias.

A fixed bias that is constant across all conditions. For many sensors, this may be removed by factory calibration in which case this parameter can represent any known residual error in that calibration.

repeatability abstractmethod property writable

repeatability: Parameter

Random bias.

The standard deviation of a random bias component that varies with each turn-on of the sensor and/or varies across external conditions. This parameter may represent unknown residuals from the factory calibration of a fixed bias.

temperature abstractmethod property writable

temperature: Parameter

Temperature bias.

A linear coefficient relating change in sensor temperature to a change in bias.

ScaleFactor

ScaleFactor(axes: int)

Sensor scale factor terms.

Scale factor is the ratio of change in output to change in input at the analog sensing elements.

A perfect sensor has a linear analog response with a scale of 1.0. Imperfect sensors may have a non-unit scale.

Attributes:

Name	Type	Description
fixed	Parameter	Fixed scale factor error.
repeatability	Parameter	Random scale factor error.

fixed property writable

fixed: Parameter

Fixed scale factor error.

A fixed offset from the ideal unit scale factor (1.0) that is constant across all conditions. For many sensors, this may be removed by factory calibration in which case this parameter can represent any known residual error in that calibration. Units are ratios of similar quantities so must be one of: "dimensionless", "%", or "ppm". Default value = Parameter([0.0,0.0,0.0], "dimensionless").

repeatability property writable

repeatability: Parameter

Random scale factor error.

The standard deviation of a random scale factor error that varies with each turn-on of the sensor and/or varies across external conditions. This parameter may represent unknown residuals from the factory calibration of fixed scale factor. Units are ratios of similar quantities so must be one of: "dimensionless", "%", or "ppm". Default value = Parameter([0.0,0.0,0.0], "dimensionless").

Misalignment

Misalignment(axes: int)

Sensor misalignment.

Misalignment is the offset between the ideal orthogonal input reference axes (IRA) and the actual sensitive input axis (IA) of the sensor. It is comprised of a fixed component (that can be calibrated) and a random component (that may vary from turn-on to turn-on or with changing conditions).

See Standard [05] and Standard [06] for details.

Attributes:

Name	Type	Description
fixed	Parameter	Fixed sensor alignment.
repeatability	Parameter	Random sensor misalignment.

fixed property writable

fixed: Parameter

Fixed sensor alignment.

Coordinate transform matrix converting 3-dimensional input reference axes (IRA) to N-dimensional input axes (IA). IRA are also known as platform axes and the IA are also known as accelerometer, gyro, or sensor axes. The resulting matrix is Nx3 where N is the number of measurement axes of the device. For an ideal sensor this will typically be an identity matrix. For real sensors, the deviation from identity represents the misalignment. This fixed misalignment may be removed by factory calibration in which case this parameter can represent any residual error in that calibration. Units must be "dimensionless". For sensors with <= 3 axes, the default value is a one-to-one map of input axes to the available output axes. For example, in a default 2-axis sensor input x-y axes map to output x-y axes: Parameter([[1,0,0],[0,1,0]],"dimensionless"). The input z-axis is not sensed. For sensors with > 3 axes, inputs are duplicated in sequence to fill the output. For example, by default a 4-axis sensor will duplicate the x input: Parameter([[1,0,0],[0,1,0],[0,0,1],[1,0,0]],"dimensionless"). This is typically not how redundant sensor designs are aligned so users should take care to supply the correct input in these cases. An example of a single axis sensor with a fixed, known misalignment is: Parameter([0.999,0.02,-0.04],"dimensionless"). This maps IRA inputs to a single output with a known misalignment. Default value = Parameter(np.eye(3), "rad").

repeatability property writable

repeatability: Parameter

Random sensor misalignment.

Standard deviation of a (small) random angle offset applied to the each input axis (IA). Each axis is independently rotated, meaning that the result is non-orthogonal. The random offset is applied as a rotation vector with components sampled independently around each of the 3 input reference axes (IRA). For example, a single axis sensor has a default fixed axis of: Parameter([1,0,0],"dimensionless"). That axis will be rotated according to:

rotation_vector = repeatability * rng.std_normal(shape=(3,1))
axis = Rotation.from_rotation_vector(rotation_vector) @ [1,0,0]

The result will be a slightly misaligned axis such as: Parameter([0.999,0.02,-0.04],"dimensionless"). This process is repeated for each axis. This parameter may represent an unknown residual from the factory calibration or an offset that varies with changing conditions like packaging stress and shock. Units must be one of: "rad" or "deg". Default value = Parameter([0.0,0.0,0.0], "rad") per axis.