Object-oriented Software for Uncertainty Propagation Keith D. McCroan US EPA National Air and Radiation Environmental Laboratory

Disclaimers The views and opinions of the author expressed here do not necessarily reflect those of the Environmental Protection Agency Reference here to any commercial product, process, or service does not imply its endorsement by the Environmental Protection Agency

Motivation Most of us recognize the importance of good uncertainty evaluation Uncertainty propagation involves calculus, and many people forget their calculus after graduation (or before) At best the math is usually tedious So, sometimes uncertainty evaluation may be done incorrectly, incompletely, or not at all

Believe It or Not The most straightforward aspect of uncertainty evaluation is uncertainty propagation The complexity of uncertainty propagation arises mostly through the repeated application of simple rules In fact, uncertainty propagation is so “easy” that it can be done automatically in a shared software module, such as a Windows ® DLL

In a Nutshell What follows is an approach for implementing automatic uncertainty propagation in a language, like C++, that allows the definition of new data types, with function and operator overloading It permits the application programmer to focus on calculating results, while a software library propagates uncertainties in the background

Terminology For terminology and symbols, we follow the “GUM” (Guide to the Expression of Uncertainty in Measurement) In particular, we use the terms standard uncertainty and combined standard uncertainty to mean “1-sigma uncertainty” and “total propagated (1-sigma) uncertainty”

Mathematical Model Uncertainty propagation begins with a mathematical model of the measurement The model is written abstractly as Y=f(X 1,X 2,…,X N ) where X 1,X 2,…,X N are input quantities and Y is the output quantity A simple radiochemistry example might be: A=(N S /t S  N B /t B ) / (EVRD)

Input & Output Estimates For each measurement, particular values x 1,x 2,…,x N, called input estimates, are plugged into the model and the output estimate, y, is calculated as y=f(x 1,x 2,…,x N ) Input estimates are often the “raw data” Output estimates are the results of calculations

Uncertainty Propagation Formula The combined standard uncertainty of y is obtained from the equation: This equation may be intimidating to anyone who is uncomfortable with calculus But it is actually straightforward

Propagating Uncertainty The uncertainty propagation formula may be straightforward, but applying it can be tedious… …especially if there are many input estimates and some of them are correlated The biggest difficulty is in the calculation of the partial derivatives,  f /  x i (also called sensitivity coefficients)

Differentiation The rules for calculating derivatives of the functions typically used in laboratory measurements are well known and can be implemented in software The uncertainty-propagation library is primarily a derivative calculator (with a few other functions thrown in)

Some Differentiation Rules (Examples)

New Data Types The library exports 2 data types, which may be used in an application program: Input estimate Output estimate In C++, these data types are implemented as classes (called InpEst and OutEst)

Syntax The syntax for calculating with input estimates and output estimates is the same as for ordinary floating-point numbers E.g. one may write the following C++ code: A=(NS/tS  NB/tB) / (E*V*R*D); The syntax is the same regardless of whether the variables on the right are “floats”, input estimates, or output estimates The difference is in the semantics

The Client Application: Declares variables of type “input estimate” and “output estimate” as necessary Assigns values and standard uncertainties to the input estimates Specifies the covariance for each pair of correlated input estimates Calculates intermediate and final results (output estimates) using these variables

The Payoff The uncertainties and covariances of the calculated results are then available almost for free (i.e., with little effort) The client application calls a library function to return the uncertainty of an output estimate It can call another function to evaluate covariances (if needed)

C++ Examples InpEst x1,x2,x3,x4; // Declare input estimates // Here are some of the ways to assign values // & uncertainties to input estimates x1 = InpEst(10, 2);// Value  uncertainty x2 = Poi(240);// Poisson distribution x3 = Rect(100, 3);// Rectangular dist. x4 = Tri(300, 5);// Triangular dist.

Covariances The covariance of any pair of input estimates may be specified. For example: Set_u(x1, x2) = 40; Alternatively, the correlation coefficient may be specified: Set_r(x1, x2) = 0.92;

Output Estimates When the application performs a calculation involving input estimates and/or output estimates, the result is an output estimate Both intermediate results and final results are output estimates

Sensitivity Coefficients Each output estimate has a value and an array of sensitivity coefficients There is 1 sensitivity coefficient for each input estimate on which the value of the output estimate depends The library propagates sensitivity coefficients in the background, without help from the programmer

Combined Standard Uncertainty The library propagates sensitivity coefficients automatically, but it calculates uncertainties only upon request When an output estimate is calculated and stored in a variable, the application can obtain its combined standard uncertainty with a function call

Example Assume input estimates Ns, Nb, ts, and tb have been given values, and R is a variable of type “output estimate”. Calculate: R = Ns / ts  Nb / tb; The variable R acquires the value indicated And it automatically acquires 4 sensitivity coefficients: one for each of the input estimates from which it was calculated

Example: Continued When the result is calculated and stored in the variable R, the application can obtain its combined standard uncertainty using the expression u(R) The library applies the uncertainty propagation formula to evaluate u(R) for the application

Simplistic Example int main() { InpEst Ns, Nb, Eff, V, Y;// Declare variables: input estimates OutEst A;// Declare variable: output estimate float ts, tb;// Declare variables: floating-point numbers ts = tb = 6000;// Count times Ns = Poi(240);// Gross count (Poisson) Nb = Poi(86);// Blank count (Poisson) Eff = InpEst(0.364, 0.022);// Efficiency V = InpEst(1, 0.004);// Aliquant size Y = InpEst(0.84, 0.02);// Yield A = (Ns/ts - Nb/tb) / (Eff*V*Y);// Final result cout<<“The answer is “<<m(A)<<“+  ”<<u(A)<<endl; // Show results return 0; }

The program prints: The answer is Output

Summary The right software makes uncertainty propagation easy -- for arbitrary measurement models The propagation can be done automatically in a shared library module You (and your programmer) can focus on calculating results and let the library propagate uncertainties for you

For More Information A handout is available here for more details of the implementation All code is in the public domain: available at

Questions?