GRR(Gauge Repeatability and Reproducibility)

描述

GRR是Gauge Repeatability and Reproducibility的缩写，意思是测量系统的重复性和复现性，需要在相同的归零条件下，在短时间内取得数据。

目的

GRR的目的就是要降低量测误差，使量测值之 尽量接近 （真值之标准差）

条件

来自百度

为计算重复性(Repeatability)，在其取得数据时应符合下列条件：
◆同一人员 ◆相同的归零条件
◆同一产品 ◆同一位置
◆同样的环境条件　 ◆数据要在短时间内取得
重复性的目的只是要获知设备的变异性。
再现性(Reproducibility)则希望获知不同条件下的变异，因此取得数据时应符合下列条件：
◆不同的人员 　 ◆相同的归零条件
◆ 相同的位置 　 ◆相同的环境
◆数据宜在较长期间内取得
根据数据类型不同Gauge R&R评估分为计数型Discrete(离散型）和计量型Continuous（连续型）

C#代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Common.Arithmetic
{
    /// <summary>
    /// Gauge Repeatability and Reproducibility 测量系统的可重复性和再现性
    /// </summary>
    public class GRR
    {
        protected const double D4_2 = 3.27;
        protected const double D4_3 = 2.58;
        protected const double K1_2 = 4.56;
        protected const double K1_3 = 3.05;
        protected const double K2_2 = 3.65;
        protected const double K2_3 = 2.7;
        protected const double Sigma = 5.15;

        protected double[][][] _values;
        protected double _usl;
        protected double _lsl;
        protected int _ops;
        protected int _trs;
        protected int _pts;

        protected double _rr;
        protected double _ev;
        protected double _av;
        protected double _R_dbr;
        protected double[,] _ranges;
        protected double _X_bar;
        /// <summary>
        /// 上限
        /// </summary>
        public double USL { get { return _usl; } }
        /// <summary>
        /// 下限
        /// </summary>
        public double LSL { get { return _lsl; } }
        /// <summary>
        /// 操作人数
        /// </summary>
        public int Operators { get { return _ops; } }
        /// <summary>
        /// 重复次数
        /// </summary>
        public int Trials { get { return _trs; } }
        /// <summary>
        /// 物料数量
        /// </summary>
        public int Parts { get { return _pts; } }
        /// <summary>
        /// Tolerance公差
        /// </summary>
        public double T { get { return _usl - _lsl; } }
        /// <summary>
        /// Equipment Variation设备变差
        /// </summary>
        public double EV { get { return _ev; } }
        /// <summary>
        /// Appraiser Variation人员变差
        /// </summary>
        public double AV { get { return _av; } }
        public double RR { get { return _rr; } }
        public double GageRR { get { return (100 * _rr) / T; ; } }
        public double Repeatability { get { return 100 * (_ev / T); } }
        public double Reproducibility { get { return 100 * (_av / T); } }
        public double Sigma_ev { get { return _ev / Sigma; } }
        public double Sigma_av { get { return _av / Sigma; } }
        public double Sigma_rr { get { return _rr / Sigma; } }
        /// <summary>
        /// Gage R&R
        /// </summary>
        /// <param name="values">[Operators][Parts][Trials]</param>
        /// <param name="lsl">lsl</param>
        /// <param name="usl">usl</param>
        public GRR(double[][][] values,double lsl,double usl)
        {
            _values = values;
            _lsl = lsl;
            _usl = usl;
            _ops = values.Length;
            _pts = values[0].Length;
            _trs = values[0][0].Length;
            _ranges = new double[_ops,_pts];

            calXbar();
            calRdbr();
            calEV();
            calAV();
            calRR();
        }

        protected void calXbar()
        {
            double[] opsAvg = new double[_ops];
            for (int i = 0; i < _ops; i++)
            {                
                for (int j = 0; j < _pts; j++)
                {
                    for(int k=0;k<_trs;k++)
                    {
                        opsAvg[i] += _values[i][j][k];
                    }
                }
                opsAvg[i] /= (_pts * _trs);
            }
            _X_bar = Max(opsAvg) - Min(opsAvg);
        }

        protected void calRdbr()
        {
            for(int i=0;i<_ops;i++)
            {
                for(int j=0;j< _pts;j++)
                {
                    _ranges[i, j] = Max(_values[i][j]) - Min(_values[i][j]);
                }
            }
            double sum1 = 0;
            for (int i = 0; i < _ops; i++)
            {
                double sum2 = 0;
                for (int j = 0; j < _pts; j++)
                {
                   sum2+= _ranges[i, j];
                }
                sum1 += sum2 / _pts;
            }
            _R_dbr= sum1 / _ops;
        }
        /// <summary>
        /// 找出数组中的最大值
        /// </summary>
        /// <param name="trails"></param>
        /// <returns></returns>
        protected double Max(double[] trails)
        {
            double rtn=double.MinValue;
            foreach(double val in trails)
            {
                if(val>rtn)
                {
                    rtn = val;
                }
            }
            return rtn;
        }
        /// <summary>
        /// 找出数组中的最小值
        /// </summary>
        /// <param name="trails"></param>
        /// <returns></returns>
        protected double Min(double[] trails)
        {
            double rtn = double.MaxValue;
            foreach (double val in trails)
            {
                if (val < rtn)
                {
                    rtn = val;
                }
            }
            return rtn;
        }
        protected void calEV()
        {
            _ev = _R_dbr * (K1_3);
        }

        protected void calAV()
        {
            _av = (_X_bar * ( K2_3)) * (_X_bar * (K2_3)) - (_ev * _ev / (_pts * _trs));
        }

        protected void calRR()
        {
            _rr = Math.Sqrt(_ev * _ev + _av * _av);
        }
    }
}

无聊用C#写的一个简单GRR计算，未验证！！！
计算公式来源保密，且未经验证，所以也未加解释，防止侵权，有兴趣的可以自己琢磨琢磨，或者私信我。