Glossary#

composite model#: A model consisting of multiple inter-related Prognostics Models, where the input of one model is a function of the output or state of another. This is a tool for representing system-of-systems. Composite models are implemented using the progpy.CompositeModel class.
controller#: A closed loop future loading method. Calculates future loading as a function of state, like the progpy.loading.controllers.LQR controller used by the progpy.models.aircraft_model.SmallRotorcraft model.
data-driven model#: A model where the behavior is learned from data. In ProgPy, data-driven models derive from the parent class progpy.data_models.DataModel. A common example of data-driven models is models using neural networks (e.g., progpy.data_models.LSTMStateTransitionModel).
direct-prediction model#: A model where the time of event is directly estimated from the current state and/or future load, instead of predicted through simulation to threshold. These are implemented using the progpy.PrognosticsModel.time_to_event() method.
event#: Something that can be predicted (e.g., system failure). An event has either occurred or not. See also: threshold
event state#: Progress towards event occurring. Defined as a number where an event state of 0 indicates the event has occurred and 1 indicates no progress towards the event (i.e., fully healthy operation for a failure event). For a gradually occurring event (e.g., discharge) the number will progress from 1 to 0 as the event nears. In prognostics, event state is frequently called “State of Health”.
future load#: input (i.e., loading) expected to be applied to a system at future times. In ProgPy, future load is typically provided as a function of time and state, f(time, state) -> load
future loading noise#: Noise applied in the user provided future load function. This is used to represent uncertainty in how the system is loaded in the future.
hidden state#: state that is not directly measurable
input#: Control or loading applied to the system being modeled (e.g., current drawn from a battery). Input is frequently denoted by u.
measurement noise#: Noise applied in the output method. Measurement noise is used to represent uncertainty in your measurements. This can represent such things as uncertainty in the logic of the model’s output method or sensor noise.
model#: A subclass of progpy.PrognosticsModel the describes the behavior of a system. Models are typically physics-based, data-driven (i.e., subclasses of progpy.data_models.DataModel), or some hybrid approach (e.g., physics informed machine learning).
output#: Measured sensor values from a system (e.g., voltage and temperature of a battery). Output is frequently denoted by z.
parameters#: Parameters describe a system. They are used to specialize a generic model to the specific system of interest.
performance metric#: Performance characteristics of a system that are a function of system state, but are not directly measured.
physics-based model#: A model where behavior is described by the physics of the system. Physics-based models are typically parameterized, so that exact behavior of the system can be configured or learned (through parameter estimation).
prediction#: A prediction of something (e.g., input, state, output, event state, etc.), with uncertainty, at one or more future times, as a result of a predictor prediction step (progpy.predictors.Predictor.predict()). For example- a prediction of the future state of a system at certain specified savepoints, returned from prediction using a progpy.predictors.MonteCarlo predictor.
predictor#: An algorithm that is used to predict future states, given the initial state, a model, and an estimate of future load. E.g., progpy.predictors.MonteCarlo.
process noise#: Noise applied in the state transition method. Process noise is used to represent uncertainty in the state transition process (e.g., uncertainty in the quality of your model or your model configuration parameters, environmental effects)
prognostics#: Prediction of (a) future performance and/or (b) the time at which one or more events of interest occur, for a system or a system of systems
state#: Internal variables (typically hidden states) used to represent the state of the system- can be same as inputs/outputs but do not have to be. State is frequently denoted as x
state estimation#: State estimation is the process from which the internal model state (x) is estimated using input (i.e., loading) and output (i.e., sensor data). State estimation is necessary for cases where model state isn’t directly measurable (i.e., hidden state) or where there is sensor noise. Most state estimators estimate the state with some representation of uncertainty. An algorithm that performs state estimation is called a state estimator and is included in the progpy.state_estimators package
state estimator#: An algorithm that is used to estimate the state of the system, given measurements and a model, defined in the progpy.state_estimators subpackage (e.g., progpy.state_estimators.UnscentedKalmanFilter).
state-transition model#: A model where the time of event is predicted through simulation to threshold. Most prognostic models are state-transition models.
surrogate#: A model that approximates the behavior of another model. Often used to generate a faster version of a model (e.g., for resource-constrained applications or to be used in optimization) or to test a data model. Generated using progpy.PrognosticsModel.generate_surrogate() method.
system-of-systems#: A system consisting of multiple inter-related systems, where one system affects the others. In ProgPy, system-of-systems are reporsented using composite models. Composite models are implemented using the progpy.CompositeModel class.
threshold#: The conditions under which an event is considered to have occurred.
time of event#: The time at which an event is predicted to occur (i.e., when threshold is reached). Sometimes abbreviated as ToE. When the event of interest is failure, this is frequently referred to as End of Life (EOL).
time of measurement#: The time at which the last measurement was performed that was used for state estimation. Sometimes abbreviated as ToM or \(t_m\).
time of prediction#: The time at which a prediction is performed. Sometimes abbreviated as ToP or \(t_p\).
time to event#: The time remaining until time of event. Sometimes abbreviated as TtE. When the event of interest is failure, this is frequently referred to as Remaining Useful Life (RUL). \(TtE = ToE - t\) where \(t\) is the current time. Sometimes abbreviated as TtE.
trajectory#: Path a vehicle takes through space, represented by a set of 4-dimensional points (position + time), represented by the progpy.utils.traj_gen.Trajectory class.