Beispiel #1
0
        // ----------------------------------------------------------------------------------
        // -------- ОСНОВНАЯ ФУНКЦИЯ РАСЧЕТА ------------------------------------------------
        // весовых коэффициентов калибровки датчика с помощью МНК
        // ----------------------------------------------------------------------------------
        public Matrix <double> CalcCalibrCoef(Matrix <double> Rmtx, Matrix <double> Umtx, Matrix <double> Pmtx, Matrix <double> Tmtx, double Pmax, Matrix <double> gammaP, Matrix <double> gammaT)
        {
            Matrix <double> resultBmtx;           // Возвращаемое значение - Матрица калибровочных коэффициентов
            //// -1 если не верные данные о погрешностях из текстового файла
            //// -2 если не верные входные данные (не согласованые матрицы)
            //// -3 если маскимальный ВПИ! равен 0
            //// -4 если рассчитанная матрица допустимых отклонений Fdop имеет нулевые значения



            Matrix <double> Kp;        // Матрица коэффициентов пернастройки(стартовая)

            Matrix <double> Fdop;      // Матрица допустимых отклонений Fdop (стартовая)
            Matrix <double> Fr;        // Матрица допустимых отклонений Fdop (расчетная)

            Matrix <double> Fkn1;      // Матрица фактических отклонений Fkn1 (стартовая с единичными весами)
            Matrix <double> Fkn;       //Рассчитываем фактические отклонения Fkn (расчетная)

            Matrix <double> M1;        // Матрица весов (стартовая, единичная)
            Matrix <double> M;         // Матрица весов (расчетная)
            Matrix <double> M_opt;     // Матрица весов (оптимальная)
            double          maxValueM; // максимальное значение веса матрицы M

            Matrix <double> B1;        // Матрица весовых коэффициентов (стартовая, для единичных весов)
            Matrix <double> B;         // Матрица весовых коэффициентов (расчетная, промежуточная)

            int Ndop;                  // Количество точек в допуске
            int Nmax;                  // Общее количество точек (число элементов в матрице)

            int    Kf_opt;             // Оптимальный Kf
            double Kmult_opt;          // Оптимальный Kmult

            int  Tdw_out_res;          // Промежуточный счетчик циклов подряд без решения
            int  Tdw_out_res_max;      // Предельное значение промежуточного счетчика циклов подряд без решения
            bool Exit_dw;              // Критерий выхода из цикла do -while



            // ---------- ЭТАП-1 ------------------------------------------------------------
            // ПОДГОТОВКА ДАННЫХ ДЛЯ РАСЧЕТА
            // ------------------------------------------------------------------------------

            // Определяем количество строк и столбцов входных матриц
            int rowP = Pmtx.RowCount;           // Количество строк матрицы Pmtx
            int colP = Pmtx.ColumnCount;        // Количество столбцов матрицы Pmtx

            int rowU = Umtx.RowCount;           // Количество строк матрицы Umtx
            int colU = Umtx.ColumnCount;        // Количество столбцов матрицы Umtx

            int rowR = Rmtx.RowCount;           // Количество строк матрицы Rmtx
            int colR = Rmtx.ColumnCount;        // Количество столбцов матрицы Rmtx

            int colT = Tmtx.ColumnCount;        // Количество столбцов матрицы Rmtx


            // Проверяем на соответствие размерности матриц
            if ((rowP != rowU) || (rowU != rowR) || (colP != colU) || (colU != colR) || (colR != colT))
            {
                resultBmtx = DenseMatrix.Create(1, 1, -2);  // возвращаем: -2 не верные входные данные
                return(resultBmtx);
            }

            // Проверка данныхпогрешностей Pa, Pb, Ta, Tb, из текстового файла
            if ((gammaP.ColumnCount < 2) || (gammaP.RowCount != 3) || (gammaT.ColumnCount != 2) || (gammaT.RowCount != 1))
            {
                resultBmtx = DenseMatrix.Create(1, 1, -1);  // возвращаем: -1 не верные данные о погрешностях из текстового файла
                return(resultBmtx);
            }

            // Проверка Pmax на ноль
            if (Pmax == 0)
            {
                resultBmtx = DenseMatrix.Create(1, 1, -3);  // возвращаем: -3 маскимальный ВПИ! равен 0 - это ошибка
                return(resultBmtx);
            }


            // Если размерности входных данных согласованы
            // Определяем общее количество точек (число элементов в матрице)
            Nmax = rowP * colP;

            // Нормируем матрицу P
            //Это можно перенести пораньше, сразу после формирования матрицы P и определения Pmax
            Matrix <double> Pn = DenseMatrix.Create(rowP, colP, 0);

            for (int i = 0; i < rowP; i++)
            {
                for (int j = 0; j < colP; j++)
                {
                    Pn[i, j] = Pmtx.At(i, j) / Pmax;
                }
            }

            // Формируем единичную матрицу весов M
            M1    = DenseMatrix.Create(rowP, colP, 1);
            M_opt = M1;

            // Рассчитываем матрицу коэффициентов B1(при единичной матрице весов М)
            B1 = CalcB(rowP, colP, M1, Pn, Umtx, Rmtx);
            if ((B1.RowCount == 1) && (B1.At(0, 0) == -1))
            {
                resultBmtx = DenseMatrix.Create(1, 1, 0);  // возвращаем: -1 решения нет
                return(resultBmtx);
            }

            // ФОРМИРОВАНИЕ СТАРТОВОЙ РАСЧЕТНОЙ ГРАНИЦЫ
            // Составляем матрицу коэффициентов пернастройки, где все Kp = 0
            Kp = DenseMatrix.Create(rowP, colP, 0);
            double Kpmax = -1;

            // Составляем матрицу коэффициентов пернастройки Kp, кроме точек, где P(i, j) == 0
            for (int i = 0; i < rowP; i++)
            {
                for (int j = 0; j < colP; j++)
                {
                    if (Pmtx.At(i, j) != 0)
                    {
                        Kp[i, j] = Pmax / Math.Abs(Pmtx.At(i, j));        //abs(P(i, j)), чтобы обеспечить универсальность формулы относителньо вида давления(ДД, ДИВ, ДА и пр)
                        {
                            if (Kp[i, j] > Kpmax)
                            {
                                Kpmax = Kp.At(i, j);
                            }
                        }
                    }
                }
            }

            // Ограничение на Kpmax
            if (Kpmax > Kpmax_dop)
            {
                Kpmax = Kpmax_dop;
            }

            // Окончательное формирование матрицы коэффициентов пернастройки Kp
            for (int i = 0; i < rowP; i++)
            {
                for (int j = 0; j < colP; j++)
                {
                    if ((Kp.At(i, j) == 0) || (Kp.At(i, j) > Kpmax))
                    {
                        Kp[i, j] = Kpmax;
                    }
                }
            }

            // Рассчитываем матрицу допустимых отклонений Fdop(размерностью N, K)
            // Внутри функции должно быть определение какой тип датчика (ЭнИ - 100 или ЭнИ - 12, или может быть другой новый тип)
            Fdop = CalcFdop(rowP, colP, Kf, Kp, Tmtx, Tnku, gammaP, gammaT);

            // Проверка рассчитанной матрицы допустимых отклонений Fdop на отсутствие нулевых элементов
            // Если нулевые элементы есть, следовательно нет решения, выходим из функции (возвращаем -1)
            int  ind  = 0;
            bool flag = true;

            while ((ind < rowP) && (flag))
            {
                for (int j = 0; j < colP; j++)
                {
                    if (Fdop.At(ind, j) == 0)
                    {
                        flag = false;
                        break;
                    }
                }
                ind = ind + 1;
            }

            if (flag == false)
            {
                resultBmtx = DenseMatrix.Create(1, 1, -4);  // возвращаем: -4
                return(resultBmtx);
            }

            //Рассчитываем фактические отклонения Fkn(формула 5, стр. 10)
            Fkn1 = CalcFkn(rowP, colP, B1, Rmtx, Umtx, Pn, Kp);



            // ---------- ЭТАП - 2 --------------------------------------------------------
            // ОСНОВНОЙ АЛГОРИТМ РАСЧЕТА
            // ПОИСК Kf
            // ----------------------------------------------------------------------------

            // Флаг решение false - не найдено, true - найдено
            bool   flagFindR    = false;
            bool   flagExitCalc = false;
            double dM           = 0;

            maxValueM = 0;
            Kf_opt    = 6;

            for (int Kf = 1; Kf < Kpmax_dop; Kf++)  // Изменил предельное значение "10" на "Kpmax_dop"
            {
                // Рассчитываем матрицу допустимых отклонений Fdop для заданного Kf
                Fdop = CalcFdop(rowP, colP, Kf, Kp, Tmtx, Tnku, gammaP, gammaT);

                // Формируем расчетную матрицу Fr(на старте она равна допускаемой Fdop)
                Fr = Fdop;

                // Формируем матрицу единичных весовов М (на старте она равна единичной матрице)
                M = M1;
                M = DenseMatrix.Create(rowP, colP, 1);

                // Вычисляем матрицу фактических отклонений Fkn(на старте она равна фактическим отклонениям при единичных весовых коэффициентах)
                Fkn = Fkn1;

                // Определяем кол - во точек в допуске
                Ndop = CalcNdop(rowP, colP, Fkn1, Fr);

                // Если не все точки в допуске
                if (Ndop < Nmax)
                {
                    //maxValueM = 0;
                    // Организуем цикл по а до Amax
                    for (int a = 0; a < Amax; a++)
                    {
                        flagExitCalc = false;

                        // Перерассчитываем веса матрицы М
                        for (int N = 0; N < rowP; N++)
                        {
                            for (int K = 0; K < colP; K++)
                            {
                                // нужна проверка для Fr(N, K) не равно нулю, если равно, то выходим из расчета
                                if (Fr.At(N, K) != 0)
                                {
                                    dM      = KdM * (Fkn.At(N, K) - Fr.At(N, K)) * M.At(N, K) / Fr.At(N, K);
                                    M[N, K] = Math.Round(M.At(N, K) + dM, 4);
                                    //M[N, K] = M.At(N, K) + dM;
                                }
                                else
                                {
                                    flagExitCalc = true;
                                    break;
                                }
                            }
                            if (flagExitCalc)
                            {
                                break;
                            }
                        }

                        // Перерассчитываем коэф.полинома В для новой матрицы весом М
                        B = CalcB(rowP, colP, M, Pn, Umtx, Rmtx);

                        // Перерассчитываем фактические отклонения Fkn для новых коэф В
                        Fkn = CalcFkn(rowP, colP, B, Rmtx, Umtx, Pn, Kp);

                        // Определяем кол - во точек в допуске
                        Ndop = CalcNdop(rowP, colP, Fkn, Fr);

                        // Если все точки в допуске решение найдено
                        if (Ndop == Nmax)
                        {
                            flagFindR = true;
                            break;
                        }
                        // если нет
                        else
                        {
                            // Находим максимальное значение эл.матрицы М
                            maxValueM = maxValMatrix(M);

                            // Проверяем превышают ли веса М максимально допустимое Mmax
                            if (maxValueM > Mmax)
                            {
                                // если да, то выходим из цикла по Amax
                                break;
                            }
                        } // для  if (Ndop == Nmax)
                    }     //  for (int a = 0; a < Amax; a++)
                }
                else
                {
                    // Решение найдено, устанавливаем флаг
                    flagFindR = true;
                } // для if (Ndop ~= Nmax)



                //  Если решение найдено(флаг = 1) выходим из цикла
                if (flagFindR)
                {
                    Kf_opt = Kf;
                    break;
                }
            } // для for Kf = 1 : 1 : 10

            if ((Kf == Kpmax_dop) && (flagFindR == false))
            {
                // Изменил в условие "Kf == 10" на условие "Kf == Kpmax_dop" ПЕРЕИМЕНОВАТЬ Kf в Kf_opt до конца кода
                Kf_opt = 6;
            }

            // Рассчитываем матрицу допустимых отклонений Fdop для заданного Kf
            Fdop = CalcFdop(rowP, colP, Kf_opt, Kp, Tmtx, Tnku, gammaP, gammaT);



            // ---------- ЭТАП - 3 -----------------------------------------------------
            //  ОСНОВНОЙ АЛГОРИТМ РАСЧЕТА
            // ПОИСК ОПТИМАЛЬНОГО РЕШЕНИЯ
            // -------------------------------------------------------------------------

            //  Рассчет r_opt
            double r = 0;
            double r_opt;

            maxValueM = 0;

            for (int N = 0; N < rowP; N++)
            {
                for (int K = 0; K < colP; K++)
                {
                    r = r + Math.Abs(Fkn1.At(N, K) / Fdop.At(N, K));
                }
            }
            r_opt = r / Nmax;


            double Kmult = 1;

            while (Kmult >= 0.1)
            {
                // Задаем, обновляем переменные
                //Tdw = 0;                    // счетчик всех циклов do -while
                //Tdw_opt = 0;                 // количество найденных не оптимальных решений подряд
                //Tdw_opt_max = 50;           // макс.кол - во решений в допуске но НЕ оптимальных
                Tdw_out_res     = 0;        // промежуточный счетчик циклов подряд без решения
                Tdw_out_res_max = 50;       // предельное значение промежуточного счетчика циклов подряд без решения
                //Tdw_out_res_sum = 0;        // общий счетчик циклов в сумме без решения
                //Tdw_out_res_sum_max = 100;  // предельное количество циклов в сумме без решения
                //Res_count = 0;              // счетчик найденных решений
                //Res_count_max = 100;        // максимальное количество найденных решений
                Exit_dw = false;            // критерий выхода из цикла do -while

                // Формируем матрицу единичных весовов М
                M = M1;
                //M = DenseMatrix.Create(rowP, colP, 1);

                // Вычисляем матрицу фактических отклонеий Fkn
                Fkn = Fkn1;

                // Формируем стартовую рассчетную границу(для заданного Kmult)
                Fr = Fdop.Multiply(Kmult);

                while (Exit_dw == false)
                {
                    flagExitCalc = false;
                    //Tdw = Tdw + 1;   // Считаем количество всех циклов do -while
                    //Tdw_out_res_sum = Tdw_out_res_sum + 1;     // Считаем количество всех циклов do -while в сумме без решения, независимо от того было ли найдено решение или нет

                    // Расчет коэффициентов B
                    B = CalcB(rowP, colP, M, Pn, Umtx, Rmtx);

                    // Рассчитываем фактические отклонения Fkn(формула 5, стр. 10)
                    Fkn = CalcFkn(rowP, colP, B, Rmtx, Umtx, Pn, Kp);


                    // Определяем кол - во точек в допуске
                    Ndop = CalcNdop(rowP, colP, Fkn, Fr);

                    // Если все точки в допуске решение найдено
                    if (Ndop == Nmax)
                    {
                        //Tdw_opt = Tdw_opt + 1;    // Считаем количество найденных решений подряд, как только решение отсутствует, параметр обнуляется
                        // Расчет среднего значения относительного отклонения по модулю
                        r = 0;

                        for (int N = 0; N < rowP; N++)
                        {
                            for (int K = 0; K < colP; K++)
                            {
                                r = Math.Round(r + Math.Abs(Fkn.At(N, K) / Fdop.At(N, K)), 4);
                            }
                        }
                        r = r / Nmax;

                        // Сравниваем текущую r с r_opt, если r меньше, то перезаписываем r_opt
                        if (r < r_opt)
                        {
                            // Оптимальное решение найдено
                            r_opt     = r;
                            M_opt     = M;
                            Kmult_opt = Kmult;
                            //Tdw_opt = 0;
                        }

                        // Считаем общее количество найденных решений, независимо от того, было ли отсутствие решения
                        //Res_count = Res_count + 1;
                        Tdw_out_res = 0;   // обнуляем промежуточный счетчик циклов без решения, в связи с найденным решением
                        // Понижение расчетной границы Fr
                        Fr = CalcFr_cur(rowP, colP, Fr, Fkn, deltaFdop_min, Fr_min, deltaFkn_min);

                        //если не все точки в допуске(решение не найдено)
                    }
                    else
                    {
                        // увеличиваем промежуточный счетчик циклов без решения
                        Tdw_out_res = Tdw_out_res + 1;
                    }


                    // Перерассчитываем веса матрицы М
                    for (int N = 0; N < rowP; N++)
                    {
                        for (int K = 0; K < colP; K++)
                        {
                            // нужна проверка для Fr(N, K) не равно нулю, если равно, то выходим из расчета
                            if (Fr.At(N, K) != 0)
                            {
                                dM      = KdM * (Fkn.At(N, K) - Fr.At(N, K)) * M.At(N, K) / Fr.At(N, K);
                                M[N, K] = M.At(N, K) + dM;
                                nm++;
                            }
                            else
                            {
                                flagExitCalc = true;
                                break;
                            }
                        }
                        if (flagExitCalc)
                        {
                            break;
                        }
                    }


                    // Находим максимальное значение элементов матрицы М
                    maxValueM = maxValMatrix(M);

                    // Проверка условий выхода их цикла do -while
                    // 1.Если общее количество найденных решений Res_count, независимо от того, было ли отсутствие решения, больше, чем максимальное
                    // значение этого параметра Res_count_max, то выход из do -while
                    // 2.Если максимальное значение элементов матрицы М maxVal больше, чем Mmax, то выходим
                    // 3.Если общий счетчик циклов в сумме без решения
                    // Tdw_out_res_sum больше, чем допускаемое количество Tdw_out_res_sum_max, то выходим
                    // 4.Если количество найденных не оптимальных решений подряд Tdw_opt больше, чем допускаемое количество Tdw_opt_max, то выходим.

                    if ((maxValueM > Mmax) || (Tdw_out_res > Tdw_out_res_max))
                    {
                        Exit_dw = true;  // критерий выхода из цикла do -while
                    }
                } // для while(Exit_dw == 0)

                Kmult = Kmult - 0.3;
            } // для for Kmult = 1 : -0.1 : 0.1



            // ----------ЭТАП - 4--------------------
            // ОБРАБОТКА РЕЗУЛЬТАТОВ
            // --------------------------------------
            nm = nm + 0;
            // Расчет коэффициентов B
            Matrix <double> BmtxRes = DenseMatrix.Create(24, 1, 0);

            // Расчет коэффициентов B
            BmtxRes = CalcB(rowP, colP, M_opt, Pn, Umtx, Rmtx);

            // Рассчитываем фактические отклонения Fkn(формула 5, стр. 10)
            Fkn = CalcFkn(rowP, colP, BmtxRes, Rmtx, Umtx, Pn, Kp);

            resultBmtx = DenseMatrix.Create(24, 1, 0);
            resultBmtx = BmtxRes;
            return(resultBmtx);

            // КОНЕЦ РАСЧЕТА //



            /*
             *
             *
             *
             * // ФУНКЦИЯ ОБНУЛЕНИЯ ДАТЧИКА
             * //-------------------------------------------------------------------------
             * // В этой функции серьезные проблемы с универсальностью. Буду думать уже в
             * // отпуске. Не успел подумать. Точка по давлению 0 может отсутствовать! И
             * // как быть в этом случае. Обнулить ближайшую к нулю точку по давлению? Буду
             * // думать.А можно точку ноль аппроксимировать и потом обнулять ?
             * // Пока это работает для ДД, ДИ, ДВ.
             * //-------------------------------------------------------------------------
             *
             * // Ищем координаты точки с нулевым давлением и на НКУ.
             * int col = -1;
             * for (int i = 0; i < Tmtx.ColumnCount; i++)
             * {
             *  if (Tmtx.At(0, i) == 23)
             *  {
             *      col = i+1;
             *      break;
             *  }
             * }
             * if (col == -1)
             * {
             *  resultBmtx = DenseMatrix.Create(1, 1, -4);
             *  return resultBmtx;
             * }
             *
             *
             * int row = -1;
             * for (int i = 0; i < rowP; i++)
             * {
             *  if (Pmtx.At(i, col) == 0)
             *  {
             *      row = i+1;
             *      break;
             *  }
             * }
             * if (row == -1)
             * {
             *  resultBmtx = DenseMatrix.Create(1, 1, -5);
             *  return resultBmtx;
             * }
             *
             * // Ищем фактические отклонения, но с учетом знака(не по модулю как в CalcFkn)
             * Matrix<double> Fkn_sign = DenseMatrix.Create(rowP, colP, 0);
             *
             * // цикл по N(строкам матриц M, P, R, U)
             * for (int N = 0; N < rowP; N++)
             * {
             *  // цикл по K(столбцам матриц M, P, R, U)
             *  for (int K = 0; K < colP; K++)
             *  {
             *      double Fi = 0;
             *      int m = 0;
             *      // цикл по j
             *      for (int j = 0; j < 6; j++)
             *      {
             *          // цикл по i
             *          for (int i = 0; i < 4; i++)
             *          {
             *              Fi = Fi + BmtxRes.At(m,0) * Math.Pow(Rmtx.At(N, K), i) * Math.Pow(Umtx.At(N, K), j);
             *              m = m + 1;
             *          }
             *      }
             *      Fkn_sign[N, K] = (Fi - Pn.At(N, K)) * 100 * Kp.At(N, K);
             *  }
             * }
             *
             *
             * // Обнуляем фактические отклонения по значению на НКУ и в 0 точке
             * for (int N = 0; N < rowP; N++)
             *  {
             *  for (int K = 0; K < colP; K++)
             *  {
             *      Fkn[N, K] = Math.Abs(Fkn_sign.At(N, K) / Kp.At(N, K) - Fkn_sign.At(row, col) / Kp.At(row, col)) * Kp.At(N, K);
             *  }
             * }
             *
             * // Тип датчика
             *
             * Vector<double> code_acc = DenseVector.Create(gammaTa.RowCount, 0);
             * code_acc = gammaTa.Column(0, 0, gammaTa.RowCount);
             *
             * int code_opt = -1;
             *
             * // окончательная допускаемая граница по которой определяем код точности с учетом коэф. запаса
             * Matrix<double> Fdop_res = DenseMatrix.Create(rowP, colP, 0);
             * Matrix<double> gamma_P = DenseMatrix.Create(1, 2, 0);
             * Matrix<double> gamma_T = DenseMatrix.Create(1, 2, 0);
             *
             * for (int cc = 1; cc < code_acc.Count; cc++)
             * {
             *  curCode = Convert.ToInt32(gammaPa.At(cc, 0));
             *  for (int i = 0; i < rowP; i++)
             *  {
             *      for (int j = 0; j < colP; j++)
             *      {
             *          if (Kp.At(i, j) < Kf)
             *          {
             *              // Получаем коэффициенты а и b осн.приведенной погрешности
             *              gamma_P = CalcGammaP(Kp.At(i, j), curCode, gammaPa, gammaPb);
             *              // Получаем коэффициенты а и b доп.температурной погрешности
             *              gamma_T = CalcGammaT(curCode, sens, gammaTa, gammaTb);
             *              // Расчет Fdop
             *              Fdop_res[i, j] = ((gamma_P.At(0, 0) + gamma_P.At(0, 1) * Kp.At(i, j)) + (gamma_T.At(0, 0) + gamma_T.At(0, 1) * Kp.At(i, j)) * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10))*(0.5 + 0.05 * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10)) * 0.9;
             *          }
             *
             *          else
             *          {
             *              // Получаем коэффициенты а и b осн.приведенной погрешности
             *              gamma_P = CalcGammaP(Kf, curCode, gammaPa, gammaPb);
             *              // Получаем коэффициенты а и b доп.температурной погрешности
             *              gamma_T = CalcGammaT(curCode, sens, gammaTa, gammaTb);
             *              // Расчет Fdop
             *              Fdop_res[i, j] = ((gamma_P.At(0, 0) + gamma_P.At(0, 1) * Kf) + (gamma_T.At(0, 0) + gamma_T.At(0, 1) * Kf) * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10)) *(0.5 + 0.05 * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10)) * 0.9;
             *          }
             *      }
             *  }
             *
             *  Ndop = CalcNdop(rowP, colP, Fkn, Fdop_res);
             *
             *
             *  if (Ndop == Nmax)
             *  {
             *      code_opt = curCode;
             *      break;
             *  }
             * }
             *
             * if (code_opt == -1)
             * {
             *  resultBmtx = DenseMatrix.Create(1, 1, -1);  // возвращаем: -6 не попали ни в какой код точности
             *  return resultBmtx;
             * }
             *
             * resultBmtx = DenseMatrix.Create(24, 1, 0);
             * resultBmtx = BmtxRes;
             * return resultBmtx;*/
        }