"use strict";

var signals = gtl.options.record.signalsModel;
var options = gtl.options;
var record = gtl.options.record;
var point = gtl.options.point;

// Файл импорта функций
var imp = gtl.import("functions_for_balance.js");

// ***** БАЛАНСИРОВОЧНЫЙ КАЛЬКУЛЯТОР. ДВЕ ПЛОСКОСТИ с фазой *****
// **************************************************************

// Получение входных сигналов

	// Настройки для датчика оборотов
		var freq_default = 5; // предполагаемая частота вращения
		var filter_freq = gtl.add_filter_iir(gtl.analog_inputs[record.tachoOptions.tachoChannel]); // объявление переменной фильтра
		filter_freq.kind = gtl.filter_iir.butterworth; // тип окна
		filter_freq.type = gtl.filter_iir.bandpass; // тип фильтра (полосовой)
		filter_freq.order = 6; // порядок фильтра
		filter_freq.width = freq_default * 0.2; // полоса пропускания 20%
		filter_freq.frequency = freq_default; // центральная частота фильтра

	// Определение частоты вращения по фильтру предполагаемой частоты
		var FREQ = gtl.add_value_freq(filter_freq);
		FREQ.time = 1; // длина отрезка сигнала
		FREQ.avg_cnt = 3; // усреднение частоты вращения
	// Определение частоты вращения по параметру freq.dc
		var freq = gtl.add_value_freq(gtl.analog_inputs[record.tachoOptions.tachoChannel]);
		freq.time = 1; // длина отрезка сигнала
		freq.avg_cnt = 3; // усреднение
		freq.dc = -0.05; // уровень, при переходе через который считаются периоды

	// Канал 0
		// ФИЛЬТР 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра
			var filter0_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[0]);
			filter0_2_1000.kind = gtl.filter_iir.butterworth;
			filter0_2_1000.type = gtl.filter_iir.bandpass;
			filter0_2_1000.order = 6;
			filter0_2_1000.frequency = 502; // центральная частота полосового фильтра
			filter0_2_1000.width = 1000; // ширина полосы фильтра
			var filter0_2_1000v = gtl.add_intg(filter0_2_1000); // интегрирование
			filter0_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)
		// Спектр виброскорости для получения 1-й гармоники частоты вращения
			var AUSPv0 = gtl.add_ausp(filter0_2_1000v); // объявление переменной спектра
			AUSPv0.color = 0x00ff0000; // цвет спектра
			AUSPv0.name = "AUSPv0"; // имя спектра
			AUSPv0.frequency = 1000; // граничная частота спектра
			AUSPv0.lines = AUSPv0.frequency * 2; // разрешение спектра (количество линий)
			AUSPv0.average = 4; // количество усреднений
			AUSPv0.unit = gtl.spec.unit; // отображение амплитуды в мм/с
			AUSPv0.smoothing_factor = 100; // усреднение средней линии
			AUSPv0.smoothed_line_color = 0xff004dff; // цвет средней линии
			AUSPv0.peak_level = 0.000001; // порог обнаружения гармоник (необходим самый минимальный)
			AUSPv0.tolerance = AUSPv0.resolution; // диапазон поиска гармоник +/-
		// СКЗv
			var RMSv0_2_1000 = gtl.add_value_rms(filter0_2_1000v);
			RMSv0_2_1000.time = 1;
			RMSv0_2_1000.avg_cnt = 3;
		// Фаза 1-й гармоники частоты вращения (виброскорости)
			var delta_phase_F1v0 = gtl.add_delta_phase_spec(filter0_2_1000v, gtl.analog_inputs[record.tachoOptions.tachoChannel]);
			delta_phase_F1v0.max_frequency = 1000;
			delta_phase_F1v0.resolution = AUSPv0.resolution;
			delta_phase_F1v0.frequency = 5.5; // частота, на которой вычисляем дельта-фазу
			// delta_phase_F1v0.frequency = FREQ.value; // частота, на которой вычисляем дельта-фазу
			// delta_phase_F1v0.frequency = freq.value; //частота, на которой вычисляем дельта-фазу
		// Формирование объекта apfc для получения амплитуды и фазы
			var apfc0 = gtl.add_apfc(
				{
				"src1" : gtl.analog_inputs[0],
				"src2" : gtl.analog_inputs[record.tachoOptions.tachoChannel],
				"name" : "coh",
				"color" : 0xff0000,
				"visible" : true,
				"freq" : AUSPv0.frequency,
				"window" : gtl.spec.rectangular,
				"resolution" : AUSPv0.frequency / AUSPv0.lines,
				"average" : 1,
				"overlap" : 0,
				"afc" : gtl.apfc.magnitude,
				"pfc" : gtl.apfc.deg
				}
		  	);
		// Объявление переменных массивов
			var level_AUSPv0 = []; // массив амплитуд гармоник канала 0
			var delta_phase_AUSPv0 = []; // массив разностей фаз гармоник канала 0 относительно тахо
			var index_AUSPv0 = []; // массив индексов гармоник канала 0
			var frequency_AUSPv0 = []; // массив частот (перевод индексов) гармоник канала 0
			var AUSPv_data0 = []; // массив спектра
			var AUSPv_base0 = []; // массив средней линии спектра
		
	// Канал 1
		// ФИЛЬТР 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра
			var filter1_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[1]);
			filter1_2_1000.kind = gtl.filter_iir.butterworth;
			filter1_2_1000.type = gtl.filter_iir.bandpass;
			filter1_2_1000.order = 6;
			filter1_2_1000.frequency = 502; // центральная частота полосового фильтра
			filter1_2_1000.width = 1000; // ширина полосы фильтра
			var filter1_2_1000v = gtl.add_intg(filter1_2_1000); // интегрирование
			filter1_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)
		// Спектр виброскорости для получения 1-й гармоники частоты вращения
			var AUSPv1 = gtl.add_ausp(filter1_2_1000v); // объявление переменной спектра
			AUSPv1.color = 0x00ff0000; // цвет спектра
			AUSPv1.name = "AUSPv1"; // имя спектра
			AUSPv1.frequency = 1000; // граничная частота спектра
			AUSPv1.lines = AUSPv1.frequency * 2; // разрешение спектра (количество линий)
			AUSPv1.average = 4; // количество усреднений
			AUSPv1.unit = gtl.spec.unit; // отображение амплитуды в мм/с
			AUSPv1.smoothing_factor = 100; // усреднение средней линии
			AUSPv1.smoothed_line_color = 0xff004dff; // цвет средней линии
			AUSPv1.peak_level = 0.000001; // порог обнаружения гармоник (необходим самый минимальный)
			AUSPv1.tolerance = AUSPv1.resolution; // диапазон поиска гармоник +/-
		// СКЗv
			var RMSv1_2_1000 = gtl.add_value_rms(filter1_2_1000v);
			RMSv1_2_1000.time = 1;
			RMSv1_2_1000.avg_cnt = 3;
		// Фаза 1-й гармоники частоты вращения (виброскорости)
			var delta_phase_F1v1 = gtl.add_delta_phase_spec(filter1_2_1000v, gtl.analog_inputs[record.tachoOptions.tachoChannel]);
			delta_phase_F1v1.max_frequency = 1000;
			delta_phase_F1v1.resolution = AUSPv1.resolution;
			delta_phase_F1v1.frequency = 5.5; // частота, на которой вычисляем дельта-фазу
			// delta_phase_F1v1.frequency = FREQ.value; // частота, на которой вычисляем дельта-фазу
			// delta_phase_F1v1.frequency = freq.value; //частота, на которой вычисляем дельта-фазу
		// Формирование объекта apfc для получения амплитуды и фазы
    		var apfc1 = gtl.add_apfc(
        		{
          		"src1" : gtl.analog_inputs[1],
          		"src2" : gtl.analog_inputs[record.tachoOptions.tachoChannel],
          		"name" : "coh",
        		"color" : 0xff0000,
        		"visible" : true,
    			"freq" : AUSPv1.frequency,
        		"window" : gtl.spec.rectangular,
        		"resolution" : AUSPv1.frequency / AUSPv1.lines,
        		"average" : 1,
        		"overlap" : 0,
        		"afc" : gtl.apfc.magnitude,
        		"pfc" : gtl.apfc.deg
        		}
      		);
		// Объявление переменных массивов
			var level_AUSPv1 = []; // массив амплитуд гармоник канала 1
			var delta_phase_AUSPv1 = []; // массив разностей фаз гармоник канала 1 относительно тахо
			var index_AUSPv1 = []; // массив индексов гармоник канала 1
			var frequency_AUSPv1 = []; // массив частот (перевод индексов) гармоник канала 1
			var AUSPv_data1 = []; // массив спектра
			var AUSPv_base1 = []; // массив средней линии спектра


// Переменные основные
// параметр вибрации (модуль вектора) - виброскорость (мм/с)
// угол (фаза) вектора - градусы
// масса груза (модуль ветора) - граммы
// * - значение получаем из измерительного блока при нажатии кнопки
// ** - значение вводится пользователем
// *** - значение получаем в результате расчёта программы балансировки
var A0 = 8;				// модуль вектора начальной вибрации в точке A */**
var A0_phase = 150;		// фаза вектора начальной вибрации в точке A */**
var B0 = 9;				// модуль вектора начальной вибрации в точке B */**
var B0_phase = 40;		// фаза вектора начальной вибрации в точке B */**
var m11_test = 60;		// модуль вектора пробного груза при 1-ом пуске в плоскости 1*
var m11_test_corner = 250;// угол вектора пробного груза при 1-ом пуске в плоскости 1 *
var m22_test = 60;		// модуль вектора пробного груза при 2-ом пуске в плоскости 2 *
var m22_test_corner = 250;// угол вектора пробного груза при 2-ом пуске в плоскости 2 *
var A1 = 9.1;				// модуль вектора вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 */**
var A1_phase = 120;		// фаза вектора вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 */**
var dA1;			// модуль вектора дельты вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 ***
var dA1_phase;		// фаза вектора дельты вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 ***
var B1 = 6.3;				// модуль вектора вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 */**
var B1_phase = 189;		// фаза вектора вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 */**
var dB1_phase;		// фаза вектора дельты вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 ***
var dB1;			// модуль вектора дельты вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 ***
var A2 = 8.1;				// модуль вектора вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 */**
var A2_phase = 95;		// фаза вектора вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 */**
var dA2;			// модуль вектора дельты вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 ***
var dA2_phase;		// фаза вектора дельты вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 ***
var B2 = 5.8;				// модуль вектора вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 */**
var B2_phase = 165;		// фаза вектора вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 */**
var dB2;			// модуль вектора дельты вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 ***
var dB2_phase;		// фаза вектора дельты вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 ***
var DCI_A1;			// модуль (мм/с/граммы) ДКВ груза m11_test в плоскости 1 на вибрацию в точке A **/***
var DCI_A1_phase;	// фаза ДКВ груза m11_test в плоскости 1 на вибрацию в точке A **/***
var DCI_B1;			// модуль (мм/с/граммы) ДКВ груза m11_test в плоскости 1 на вибрацию в точке B **/***
var DCI_B1_phase;	// фаза ДКВ груза m11_test в плоскости 1 на вибрацию в точке B **/***
var DCI_A2;			// модуль (мм/с/граммы) ДКВ груза m22_test в плоскости 2 на вибрацию в точке A **/***
var DCI_A2_phase;	// фаза ДКВ груза m22_test в плоскости 2 на вибрацию в точке A **/***
var DCI_B2;			// модуль (мм/с/граммы) ДКВ груза m22_test в плоскости 2 на вибрацию в точке B **/***
var DCI_B2_phase;	// фаза ДКВ груза m22_test в плоскости 2 на вибрацию в точке B **/***
var Mb1;			// модуль вектора балансировочного груза в плоскости 1 ***
var Mb1_corner;		// угол вектора балансировочного груза в плоскости 1 ***
var Mb2;			// модуль вектора балансировочного груза в плоскости 2 ***
var Mb2_corner;		// угол вектора балансировочного груза в плоскости 2 ***

// Переменные вспомогательные
var A0_phase_X;			// угол наклона вектора A0 к оси X
var A0_phase_Y;			// угол наклона вектора A0 к оси Y
var A0_1_X;				// начальная координата вектора A0 по оси X
var A0_2_X;				// конечная координата вектора A0 по оси X
var A0_1_Y;				// начальная координата вектора A0 по оси Y
var A0_2_Y;				// конечная координата вектора A0 по оси Y

var B0_phase_X;			// угол наклона вектора B0 к оси X
var B0_phase_Y;			// угол наклона вектора B0 к оси Y
var B0_1_X;				// начальная координата вектора B0 по оси X
var B0_2_X;				// конечная координата вектора B0 по оси X
var B0_1_Y;				// начальная координата вектора B0 по оси Y
var B0_2_Y;				// конечная координата вектора B0 по оси Y

var A1_phase_X;			// угол наклона вектора A1 к оси X
var A1_phase_Y;			// угол наклона вектора A1 к оси Y
var A1_1_X;				// начальная координата вектора A1 по оси X
var A1_2_X;				// конечная координата вектора A1 по оси X
var A1_1_Y;				// начальная координата вектора A1 по оси Y
var A1_2_Y;				// конечная координата вектора A1 по оси Y

var dA1_1_X;			// начальная координата вектора dA1 по оси X
var dA1_2_X;			// конечная координата вектора dA1 по оси X
var dA1_1_Y;			// начальная координата вектора dA1 по оси Y
var dA1_2_Y;			// конечная координата вектора dA1 по оси Y

var A2_phase_X;			// угол наклона вектора A2 к оси X
var A2_phase_Y;			// угол наклона вектора A2 к оси Y
var A2_1_X;				// начальная координата вектора A2 по оси X
var A2_2_X;				// конечная координата вектора A2 по оси X
var A2_1_Y;				// начальная координата вектора A2 по оси Y
var A2_2_Y;				// конечная координата вектора A2 по оси Y

var dA2_1_X;			// начальная координата вектора dA2 по оси X
var dA2_2_X;			// конечная координата вектора dA2 по оси X
var dA2_1_Y;			// начальная координата вектора dA2 по оси Y
var dA2_2_Y;			// конечная координата вектора dA2 по оси Y

var B1_phase_X;			// угол наклона вектора A1 к оси X
var B1_phase_Y;			// угол наклона вектора A1 к оси Y
var B1_1_X;				// начальная координата вектора A1 по оси X
var B1_2_X;				// конечная координата вектора A1 по оси X
var B1_1_Y;				// начальная координата вектора A1 по оси Y
var B1_2_Y;				// конечная координата вектора A1 по оси Y

var dB1_1_X;			// начальная координата вектора dB1 по оси X
var dB1_2_X;			// конечная координата вектора dB1 по оси X
var dB1_1_Y;			// начальная координата вектора dB1 по оси Y
var dB1_2_Y;			// конечная координата вектора dB1 по оси Y

var B2_phase_X;			// угол наклона вектора A1 к оси X
var B2_phase_Y;			// угол наклона вектора A1 к оси Y
var B2_1_X;				// начальная координата вектора A1 по оси X
var B2_2_X;				// конечная координата вектора A1 по оси X
var B2_1_Y;				// начальная координата вектора A1 по оси Y
var B2_2_Y;				// конечная координата вектора A1 по оси Y

var dB2_1_X;			// начальная координата вектора dB2 по оси X
var dB2_2_X;			// конечная координата вектора dB2 по оси X
var dB2_1_Y;			// начальная координата вектора dB2 по оси Y
var dB2_2_Y;			// конечная координата вектора dB2 по оси Y

var m11_test_corner_X;	// угол наклона вектора m11_test к оси X
var m11_test_corner_Y;	// угол наклона вектора m11_test к оси Y
var m11_test_1_X;		// начальная координата вектора m11_test по оси X
var m11_test_2_X;		// конечная координата вектора m11_test по оси X
var m11_test_1_Y;		// начальная координата вектора m11_test по оси Y
var m11_test_2_Y;		// конечная координата вектора m11_test по оси Y

var m22_test_corner_X;	// угол наклона вектора m22_test к оси X
var m22_test_corner_Y;	// угол наклона вектора m22_test к оси Y
var m22_test_1_X;		// начальная координата вектора m22_test по оси X
var m22_test_2_X;		// конечная координата вектора m22_test по оси X
var m22_test_1_Y;		// начальная координата вектора m22_test по оси Y
var m22_test_2_Y;		// конечная координата вектора m22_test по оси Y


// ***** РАСЧЁТЫ *****
// gtl.diagnostic.interval = 10;
gtl.diagnostic.interval = AUSPv0.acq_time;

let state = record.tachoOptions.tachoState; // начальное состояние после выбора источника тахо сигнала

function diagnose() {

  // Нестабильность частоты вращения
  var freq_max = Math.max(...freq.values);
  var freq_min = Math.min(...freq.values);
  var instability = ((freq_max - freq_min) / freq.value) * 100; // * 100%

  switch (state) {

    case 0: // считаем частоту вращения и настраиваем спектры
        var freq_max = Math.max(...freq.values);
        var freq_min = Math.min(...freq.values);
        var instability = (freq_max - freq_min) / freq.value;

        // if (instability > imp.tolerance()) {
        if (instability > 0.3) {
            gtl.log.info("Критическая нестабильность частоты вращения, %", instability * 100);
            gtl.log.info("Результат:", "Диагностика прервана");
            //gtl.diagnostic.stop(); //принудительная остановка диагностики

            let __result = {
                Result: false
            };
            gtl.results = __result;
        };

        // Определение минимально необходимой длительности сигнала для проведения диагностики
        gtl.diagnostic.interval = AUSPv0.acq_time;
        state = 3;
        break;

    case 1: // Частота вращения фиксированная
        // Определение минимально необходимой длительности сигнала для проведения диагностики
        gtl.diagnostic.interval = AUSPv0.acq_time;
        state = 3;
        break;

    case 2: // Частота вращения из поля INFO (виброметр)
        // Определение минимально необходимой длительности сигнала для проведения диагностики
        gtl.diagnostic.interval = AUSPv0.acq_time;
        state = 3;
        break;

    case 3: // Выполняем анализ спектов
        // Очистка партретов спектров
        AUSPv0.clear_harms_sets();
		AUSPv1.clear_harms_sets();



  // Спектр виброскорости
    // Набор гармоник частоты вращения F1v0 (виброскорость) Канал 0
	  var F1v0_harms = AUSPv0.add_harms_set(freq.value, 1, 0x00ff0000, 1); // красный цвет
	  for (let i=0; i <= 0; i++)
	  {F1v0_harms.harms[i].tolerance = (1+i) * freq.value * 0.1}; // коридор обнаружения гармоник
	  F1v0_harms.name = "F1v0 (гарм. ряд част. вращ.)";
	// Набор гармоник частоты вращения F1v1 (виброскорость) Канал 1
	  var F1v1_harms = AUSPv1.add_harms_set(freq.value, 1, 0x00ff0000, 1); // красный цвет
	  for (let i=0; i <= 0; i++)
	  {F1v1_harms.harms[i].tolerance = (1+i) * freq.value * 0.1}; // коридор обнаружения гармоник
	  F1v1_harms.name = "F1v1 (гарм. ряд част. вращ.)";	
	  // 1-я гармоника F1v для каналов 0 и 1
		  // Проверка наличия оборотной гармоники необходимости проведения баалнсировки
		  if (F1v0_harms.harms[0].is_present == true) // обнаружения оборотной гармоники
				{var F1v0 = F1v0_harms.harms[0].level;
			  var F1v0_test_ampl = "амплитуда частоты вращения определена";}
		  else {var F1v0_test_ampl = "амплитуда частоты вращения НЕ определена";}
		  if (F1v1_harms.harms[0].is_present == true) // обнаружения оборотной гармоники
				{var F1v1 = F1v1_harms.harms[0].level;
			  var F1v1_test_ampl = "амплитуда частоты вращения определена";}
		  else {var F1v1_test_ampl = "амплитуда частоты вращения НЕ определена";}
		  if ((F1v0 >= RMSv0_2_1000.value * 0.4) || // вклад оборотной гармоники в СКЗv
		  	(F1v1 >= RMSv1_2_1000.value * 0.4))
				{var F1v_test_balance = "необходимо провести балансировку";}
		  else {var F1v_test_balance = "проведение балансировки не требуется или нецелесообразно";}


  // ТЕСТИРОВАНИЕ (получение фазы и амплитуды оборотной гармоники из массивов)
	// Запись в массив значений уровня спектра (канал 0)
	for (let i = 0; i < AUSPv0.data.length; i++) {
		// Массив уровней (старый метод)
		// level_AUSPv0.push(AUSPv0.data[i] - AUSPv0.base[i]);
	
		// Разница фаз гармоник
		delta_phase_AUSPv0.push(apfc0.phase[i]);

		// Амплитуда гармоник
		level_AUSPv0.push(apfc0.data[i]);

		// Индексы гармоник
		index_AUSPv0.push(i);

		// Частоты гармоник
		frequency_AUSPv0.push(i * (AUSPv0.frequency / AUSPv0.lines));

		// Запись массивов AUSPv.data и AUSPv.base
		AUSPv_data0.push(AUSPv0.data[i]);
		AUSPv_base0.push(AUSPv0.base[i]);
	}

	// Запись в массив значений уровня спектра (канал 1)
	for (let i = 0; i < AUSPv1.data.length; i++) {
		// Массив уровней (старый метод)
		// level_AUSPv1.push(AUSPv1.data[i] - AUSPv1.base[i]);
	
		// Разница фаз гармоник
		delta_phase_AUSPv1.push(apfc1.phase[i]);

		// Амплитуда гармоник
		level_AUSPv1.push(apfc1.data[i]);

		// Индексы гармоник
		index_AUSPv1.push(i);

		// Частоты гармоник
		frequency_AUSPv1.push(i * (AUSPv1.frequency / AUSPv1.lines));

		// Запись массивов AUSPv.data и AUSPv.base
		AUSPv_data1.push(AUSPv1.data[i]);
		AUSPv_base1.push(AUSPv1.base[i]);
	}

  var F_find = freq.value; // искомая частота
  var F_find_round_min = Math.round(F_find); // округление значения искомой частоты до ближайшего
  var F_find_round_max = Math.round(F_find) + AUSPv0.resolution; // округление значения искомой частоты в большую сторону
  var F_find_round0;
 	if (level_AUSPv0[frequency_AUSPv0.indexOf(F_find_round_min)] >= level_AUSPv0[frequency_AUSPv0.indexOf(F_find_round_max)])
		{F_find_round0 = F_find_round_min;}
	else {F_find_round0 = F_find_round_max;}
  var F_find_round1;
 	if (level_AUSPv1[frequency_AUSPv0.indexOf(F_find_round_min)] >= level_AUSPv1[frequency_AUSPv0.indexOf(F_find_round_max)])
		{F_find_round1 = F_find_round_min;}
	else {F_find_round1 = F_find_round_max;}

  var ind_F_find0 = frequency_AUSPv0.indexOf(F_find_round0); // индекс искомой частоты (канал 0)
  var ind_F_find1 = frequency_AUSPv1.indexOf(F_find_round1); // индекс искомой частоты (канал 1)


  gtl.log.info("искомая частота, Гц", F_find);
  gtl.log.info("верхняя граница поиска частоты, Гц", F_find_round_max);
  gtl.log.info("нижняя граница поиска частоты, Гц", F_find_round_min);
  gtl.log.info("AUSPv.lines", AUSPv0.lines);
  gtl.log.info("AUSPv.frequency", AUSPv0.frequency);

// лог канала 0
  gtl.log.info("искомая частота округлённая до ближ (канал 0), Гц", F_find_round0);
  gtl.log.info("индекс искомой частоты (канал 0)", ind_F_find0);
  gtl.log.info("уровень искомой частоты (канал 0)", level_AUSPv0[ind_F_find0]);
  gtl.log.info("фаза искомой частоты (канал 0)", delta_phase_AUSPv0[ind_F_find0]);
  gtl.log.info("проверка уровня AUSPv.data (канал 0)", AUSPv_data0[ind_F_find0] - AUSPv_base0[ind_F_find0]);
  gtl.log.info("размер массива frequency_AUSPv (канал 0)", frequency_AUSPv0.length);

// лог канала 1
  gtl.log.info("искомая частота округлённая до ближ (канал 1), Гц", F_find_round1);
  gtl.log.info("индекс искомой частоты (канал 1)", ind_F_find1);
  gtl.log.info("уровень искомой частоты (канал 1)", level_AUSPv1[ind_F_find1]);
  gtl.log.info("фаза искомой частоты (канал 1)", delta_phase_AUSPv1[ind_F_find1]);
  gtl.log.info("проверка уровня AUSPv.data (канал 1)", AUSPv_data1[ind_F_find1] - AUSPv_base1[ind_F_find1]);
  gtl.log.info("размер массива frequency_AUSPv (канал 1)", frequency_AUSPv1.length);


		  
//РАСЧЁТЫ

// определение угла наклона вектора A0 к осям X и Y
if (A0_phase <= 90) {
A0_phase_X = 90 - A0_phase}
	if (A0_phase <= 180) {
	A0_phase_X = A0_phase - 90}
		if (A0_phase <= 270) {
		A0_phase_X = 270 - A0_phase}
			if (A0_phase <= 360) {
			A0_phase_X = A0_phase - 270}
if (A0_phase <= 90) {
A0_phase_Y = A0_phase}
	if (A0_phase <= 180) {
	A0_phase_Y = 180 - A0_phase}
		if (A0_phase <= 270) {
		A0_phase_Y = A0_phase - 180}
			if (A0_phase <= 360) {
			A0_phase_Y = 360 - A0_phase}
// определение координат вектора A0
A0_1_X = 0;
if (A0_phase <= 180) {A0_2_X = Math.abs(Math.cos(A0_phase_X * 3.1415/180)) * A0
	} else {A0_2_X = Math.abs(Math.cos(A0_phase_X * 3.1415/180)) * A0 * (-1)}
A0_1_Y = 0;
if (A0_phase <= 90 || A0_phase >= 270) {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * 3.1415/180)) * A0
	} else {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * 3.1415/180)) * A0 * (-1)}

// определение угла наклона вектора B0 к осям X и Y
if (B0_phase <= 90) {
B0_phase_X = 90 - B0_phase}
	if (B0_phase <= 180) {
	B0_phase_X = B0_phase - 90}
		if (B0_phase <= 270) {
		B0_phase_X = 270 - B0_phase}
			if (B0_phase <= 360) {
			B0_phase_X = B0_phase - 270}
if (B0_phase <= 90) {
B0_phase_Y = B0_phase}
	if (B0_phase <= 180) {
	B0_phase_Y = 180 - B0_phase}
		if (B0_phase <= 270) {
		B0_phase_Y = B0_phase - 180}
			if (B0_phase <= 360) {
			B0_phase_Y = 360 - B0_phase}
// определение координат вектора B0
B0_1_X = 0;
if (B0_phase <= 180) {B0_2_X = Math.abs(Math.cos(B0_phase_X * 3.1415/180)) * B0
	} else {B0_2_X = Math.abs(Math.cos(B0_phase_X * 3.1415/180)) * B0 * (-1)}
B0_1_Y = 0;
if (B0_phase <= 90 || B0_phase >= 270) {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * 3.1415/180)) * B0
	} else {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * 3.1415/180)) * B0 * (-1)}

// определение угла наклона вектора m11_test к осям X и Y
if (m11_test_corner <= 90) {
m11_test_corner_X = 90 - m11_test_corner}
	if (m11_test_corner <= 180) {
	m11_test_corner_X = m11_test_corner - 90}
		if (m11_test_corner <= 270) {
		m11_test_corner_X = 270 - m11_test_corner}
			if (m11_test_corner <= 360) {
			m11_test_corner_X = m11_test_corner - 270}
if (m11_test_corner <= 90) {
m11_test_corner_Y = m11_test_corner}
	if (m11_test_corner <= 180) {
	m11_test_corner_Y = 180 - m11_test_corner}
		if (m11_test_corner <= 270) {
		m11_test_corner_Y = m11_test_corner - 180}
			if (m11_test_corner <= 360) {
			m11_test_corner_Y = 360 - m11_test_corner}
// определение координат вектора m11_test
m11_test_1_X = 0;
if (m11_test_corner <= 180) {m11_test_2_X = Math.abs(Math.cos(m11_test_corner_X * 3.1415/180)) * m11_test * (-1)
	} else {m11_test_2_X = Math.abs(Math.cos(m11_test_corner_X * 3.1415/180)) * m11_test}
m11_test_1_Y = 0;
if (m11_test_corner <= 90 || m11_test_corner >= 270) {m11_test_2_Y = Math.abs(Math.cos(m11_test_corner_Y * 3.1415/180)) * m11_test
	} else {m11_test_2_Y = Math.abs(Math.cos(m11_test_corner_Y * 3.1415/180)) * m11_test * (-1)}

// определение угла наклона вектора A1 к осям X и Y
if (A1_phase <= 90) {
A1_phase_X = 90 - A1_phase}
	if (A1_phase <= 180) {
	A1_phase_X = A1_phase - 90}
		if (A1_phase <= 270) {
		A1_phase_X = 270 - A1_phase}
			if (A1_phase <= 360) {
			A1_phase_X = A1_phase - 270}
if (A1_phase <= 90) {
A1_phase_Y = A1_phase}
	if (A1_phase <= 180) {
	A1_phase_Y = 180 - A1_phase}
		if (A1_phase <= 270) {
		A1_phase_Y = A1_phase - 180}
			if (A1_phase <= 360) {
			A1_phase_Y = 360 - A1_phase}
// определение координат вектора A1
A1_1_X = 0;
if (A1_phase <= 180) {A1_2_X = Math.abs(Math.cos(A1_phase_X * 3.1415/180)) * A1
	} else {A1_2_X = Math.abs(Math.cos(A1_phase_X * 3.1415/180)) * A1 * (-1)}
A1_1_Y = 0;
if (A1_phase <= 90 || A1_phase >= 270) {A1_2_Y = Math.abs(Math.cos(A1_phase_Y * 3.1415/180)) * A1
	} else {A1_2_Y = Math.abs(Math.cos(A1_phase_Y * 3.1415/180)) * A1 * (-1)}

// определение угла наклона вектора B1 к осям X и Y
if (B1_phase <= 90) {
B1_phase_X = 90 - B1_phase}
	if (B1_phase <= 180) {
	B1_phase_X = B1_phase - 90}
		if (B1_phase <= 270) {
		B1_phase_X = 270 - B1_phase}
			if (B1_phase <= 360) {
			B1_phase_X = B1_phase - 270}
if (B1_phase <= 90) {
B1_phase_Y = B1_phase}
	if (B1_phase <= 180) {
	B1_phase_Y = 180 - B1_phase}
		if (B1_phase <= 270) {
		B1_phase_Y = B1_phase - 180}
			if (B1_phase <= 360) {
			B1_phase_Y = 360 - B1_phase}
// определение координат вектора B1
B1_1_X = 0;
if (B1_phase <= 180) {B1_2_X = Math.abs(Math.cos(B1_phase_X * 3.1415/180)) * B1
	} else {B1_2_X = Math.abs(Math.cos(B1_phase_X * 3.1415/180)) * B1 * (-1)}
B1_1_Y = 0;
if (B1_phase <= 90 || B1_phase >= 270) {B1_2_Y = Math.abs(Math.cos(B1_phase_Y * 3.1415/180)) * B1
	} else {B1_2_Y = Math.abs(Math.cos(B1_phase_Y * 3.1415/180)) * B1 * (-1)}

// определение модуля вектора dA1
dA1_1_X = A0_2_X;
dA1_2_X = A1_2_X;
dA1_1_Y = A0_2_Y;
dA1_2_Y = A1_2_Y;
dA1 = Math.sqrt(Math.pow(dA1_2_X - dA1_1_X, 2) + Math.pow(dA1_2_Y - dA1_1_Y, 2));
// определение фазы вектора dA1
if ((dA1_2_Y < dA1_1_Y) && (dA1_2_X < dA1_1_X)) {
	dA1_phase = 180 + (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / 3.1415)}
if ((dA1_2_Y > dA1_1_Y) && (dA1_2_X > dA1_1_X)) {
	dA1_phase = (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / 3.1415)}
if ((dA1_2_Y > dA1_1_Y) && (dA1_2_X < dA1_1_X)) {
	dA1_phase = 360 - (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / 3.1415)}
if ((dA1_2_Y < dA1_1_Y) && (dA1_2_X > dA1_1_X)) {
	dA1_phase = 180 - (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / 3.1415)}
	if (dA1_phase > 360) {dA1_phase = dA1_phase - 360}

// определение модуля вектора dB1
dB1_1_X = B0_2_X;
dB1_2_X = B1_2_X;
dB1_1_Y = B0_2_Y;
dB1_2_Y = B1_2_Y;
dB1 = Math.sqrt(Math.pow(dB1_2_X - dB1_1_X, 2) + Math.pow(dB1_2_Y - dB1_1_Y, 2));
// определение фазы вектора dB1
if ((dB1_2_Y < dB1_1_Y) && (dB1_2_X < dB1_1_X)) {
	dB1_phase = 180 + (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / 3.1415)}
if ((dB1_2_Y > dB1_1_Y) && (dB1_2_X > dB1_1_X)) {
	dB1_phase = (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / 3.1415)}
if ((dB1_2_Y > dB1_1_Y) && (dB1_2_X < dB1_1_X)) {
	dB1_phase = 360 - (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / 3.1415)}
if ((dB1_2_Y < dB1_1_Y) && (dB1_2_X > dB1_1_X)) {
	dB1_phase = 180 - (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / 3.1415)}
	if (dB1_phase > 360) {dB1_phase = dB1_phase - 360}

// определение угла наклона вектора m22_test к осям X и Y
if (m22_test_corner <= 90) {
m22_test_corner_X = 90 - m22_test_corner}
	if (m22_test_corner <= 180) {
	m22_test_corner_X = m22_test_corner - 90}
		if (m22_test_corner <= 270) {
		m22_test_corner_X = 270 - m22_test_corner}
			if (m22_test_corner <= 360) {
			m22_test_corner_X = m22_test_corner - 270}
if (m22_test_corner <= 90) {
m22_test_corner_Y = m22_test_corner}
	if (m22_test_corner <= 180) {
	m22_test_corner_Y = 180 - m22_test_corner}
		if (m22_test_corner <= 270) {
		m22_test_corner_Y = m22_test_corner - 180}
			if (m22_test_corner <= 360) {
			m22_test_corner_Y = 360 - m22_test_corner}
// определение координат вектора m22_test
m22_test_1_X = 0;
if (m22_test_corner <= 180) {m22_test_2_X = Math.abs(Math.cos(m22_test_corner_X * 3.1415/180)) * m22_test * (-1)
	} else {m22_test_2_X = Math.abs(Math.cos(m22_test_corner_X * 3.1415/180)) * m22_test}
m22_test_1_Y = 0;
if (m22_test_corner <= 90 || m22_test_corner >= 270) {m22_test_2_Y = Math.abs(Math.cos(m22_test_corner_Y * 3.1415/180)) * m22_test
	} else {m22_test_2_Y = Math.abs(Math.cos(m22_test_corner_Y * 3.1415/180)) * m22_test * (-1)}

// определение угла наклона вектора A2 к осям X и Y
if (A2_phase <= 90) {
A2_phase_X = 90 - A2_phase}
	if (A2_phase <= 180) {
	A2_phase_X = A2_phase - 90}
		if (A2_phase <= 270) {
		A2_phase_X = 270 - A2_phase}
			if (A2_phase <= 360) {
			A2_phase_X = A2_phase - 270}
if (A2_phase <= 90) {
A2_phase_Y = A2_phase}
	if (A2_phase <= 180) {
	A2_phase_Y = 180 - A2_phase}
		if (A2_phase <= 270) {
		A2_phase_Y = A2_phase - 180}
			if (A2_phase <= 360) {
			A2_phase_Y = 360 - A2_phase}
// определение координат вектора A2
A2_1_X = 0;
if (A2_phase <= 180) {A2_2_X = Math.abs(Math.cos(A2_phase_X * 3.1415/180)) * A2
	} else {A2_2_X = Math.abs(Math.cos(A2_phase_X * 3.1415/180)) * A2 * (-1)}
A2_1_Y = 0;
if (A2_phase <= 90 || A2_phase >= 270) {A2_2_Y = Math.abs(Math.cos(A2_phase_Y * 3.1415/180)) * A2
	} else {A2_2_Y = Math.abs(Math.cos(A2_phase_Y * 3.1415/180)) * A2 * (-1)}

// определение угла наклона вектора B2 к осям X и Y
if (B2_phase <= 90) {
B2_phase_X = 90 - B2_phase}
	if (B2_phase <= 180) {
	B2_phase_X = B2_phase - 90}
		if (B2_phase <= 270) {
		B2_phase_X = 270 - B2_phase}
			if (B2_phase <= 360) {
			B2_phase_X = B2_phase - 270}
if (B2_phase <= 90) {
B2_phase_Y = B2_phase}
	if (B2_phase <= 180) {
	B2_phase_Y = 180 - B2_phase}
		if (B2_phase <= 270) {
		B2_phase_Y = B2_phase - 180}
			if (B1_phase <= 360) {
			B2_phase_Y = 360 - B2_phase}
// определение координат вектора B2
B2_1_X = 0;
if (B2_phase <= 180) {B2_2_X = Math.abs(Math.cos(B2_phase_X * 3.1415/180)) * B2
	} else {B2_2_X = Math.abs(Math.cos(B2_phase_X * 3.1415/180)) * B2 * (-1)}
B2_1_Y = 0;
if (B2_phase <= 90 || B2_phase >= 270) {B2_2_Y = Math.abs(Math.cos(B2_phase_Y * 3.1415/180)) * B2
	} else {B2_2_Y = Math.abs(Math.cos(B2_phase_Y * 3.1415/180)) * B2 * (-1)}

// определение модуля вектора dA2
dA2_1_X = A0_2_X;
dA2_2_X = A2_2_X;
dA2_1_Y = A0_2_Y;
dA2_2_Y = A2_2_Y;
dA2 = Math.sqrt(Math.pow(dA2_2_X - dA2_1_X, 2) + Math.pow(dA2_2_Y - dA2_1_Y, 2));
// определение фазы вектора dA2
if ((dA2_2_Y < dA2_1_Y) && (dA2_2_X < dA2_1_X)) {
	dA2_phase = 180 + (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
if ((dA2_2_Y > dA2_1_Y) && (dA2_2_X > dA2_1_X)) {
	dA2_phase = (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
if ((dA2_2_Y > dA2_1_Y) && (dA2_2_X < dA2_1_X)) {
	dA2_phase = 360 - (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
if ((dA2_2_Y < dA2_1_Y) && (dA2_2_X > dA2_1_X)) {
	dA2_phase = 180 - (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
	if (dA2_phase > 360) {dA2_phase = dA2_phase - 360}

// определение модуля вектора dB2
dB2_1_X = B0_2_X;
dB2_2_X = B2_2_X;
dB2_1_Y = B0_2_Y;
dB2_2_Y = B2_2_Y;
dB2 = Math.sqrt(Math.pow(dB2_2_X - dB2_1_X, 2) + Math.pow(dB2_2_Y - dB2_1_Y, 2));
// определение фазы вектора dB2
if ((dB2_2_Y < dB2_1_Y) && (dB2_2_X < dB2_1_X)) {
	dB2_phase = 180 + (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
if ((dB2_2_Y > dB2_1_Y) && (dB2_2_X > dB2_1_X)) {
	dB2_phase = (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
if ((dB2_2_Y > dB2_1_Y) && (dB2_2_X < dB2_1_X)) {
	dB2_phase = 360 - (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
if ((dB2_2_Y < dB2_1_Y) && (dB2_2_X > dB2_1_X)) {
	dB2_phase = 180 - (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
	if (dB2_phase > 360) {dB2_phase = dB2_phase - 360}

// определение модуля вектора DCI_A1
DCI_A1 = dA1 / m11_test;
// опредение фаза вектора DCI_A1
if ((dA1_phase - m11_test_corner) < 0) {
	DCI_A1_phase = (dA1_phase - m11_test_corner) + 360}
	else if ((dA1_phase - m11_test_corner) > 360) {
		DCI_A1_phase = (dA1_phase - m11_test_corner) - 360}
		else {DCI_A1_phase = (dA1_phase - m11_test_corner)}

// определение модуля вектора DCI_B1
DCI_B1 = dB1 / m11_test;
// опредение фаза вектора DCI_B1
if ((dB1_phase - m11_test_corner) < 0) {
	DCI_B1_phase = (dB1_phase - m11_test_corner) + 360}
	else if ((dB1_phase - m11_test_corner) > 360) {
		DCI_B1_phase = (dB1_phase - m11_test_corner) - 360}
		else {DCI_B1_phase = (dB1_phase - m11_test_corner)}

// определение модуля вектора DCI_A2
DCI_A2 = dA2 / m22_test;
// опредение фаза вектора DCI_A2
if ((dA2_phase - m22_test_corner) < 0) {
	DCI_A2_phase = (dA2_phase - m22_test_corner) + 360}
	else if ((dA2_phase - m22_test_corner) > 360) {
		DCI_A2_phase = (dA2_phase - m22_test_corner) - 360}
		else {DCI_A2_phase = (dA2_phase - m22_test_corner)}

// определение модуля вектора DCI_B2
DCI_B2 = dB2 / m22_test;
// опредение фаза вектора DCI_B2
if ((dB2_phase - m22_test_corner) < 0) {
	DCI_B2_phase = (dB2_phase - m22_test_corner) + 360}
	else if ((dB2_phase - m22_test_corner) > 360) {
		DCI_B2_phase = (dB2_phase - m22_test_corner) - 360}
		else {DCI_B2_phase = (dB2_phase - m22_test_corner)}

// формулы для определение векторов балансировочных грузов
// Mb1 = (B0 * DCI_A2 - A0 * DCI_B2) / (DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2)
// Mb2 = (A0 * DCI_B1 - B0 * DCI_A1) / (DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2)
// ... вычисления этих формул делим на этапы
// 1) В0 * DCI_A2
// 2) A0 * DCI_B2
// 3) A0 * DCI_B1
// 4) B0 * DCI_A1
// 5) В0 * DCI_A2 - A0 * DCI_B2
// 6) A0 * DCI_B1 - B0 * DCI_A1
// 7) DCI_A1 * DCI_B2
// 8) DCI_B1 * DCI_A2
// 9) DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2

// определение модуля вектора B0 * DCI_A2
var B0_DCI_A2 = B0 * DCI_A2;
// определение фазы вектора В0 * DCI_A2
var B0_DCI_A2_phase;
if ((B0_phase + DCI_A2_phase) >360) {
	B0_DCI_A2_phase = B0_phase + DCI_A2_phase - 360
	} else {B0_DCI_A2_phase = B0_phase + DCI_A2_phase}
// определение угла наклона вектора В0 * DCI_A2 к осям X и Y
var B0_DCI_A2_phase_X;
var B0_DCI_A2_phase_Y;
if (B0_DCI_A2_phase <= 90) {
	B0_DCI_A2_phase_X = 90 - B0_DCI_A2_phase}
	if (B0_DCI_A2_phase <= 180) {
		B0_DCI_A2_phase_X = B0_DCI_A2_phase - 90}
		if (B0_DCI_A2_phase <= 270) {
			B0_DCI_A2_phase_X = 270 - B0_DCI_A2_phase}
				if (B0_DCI_A2_phase <= 360) {
					B0_DCI_A2_phase_X = B0_DCI_A2_phase - 270}
if (B0_DCI_A2_phase <= 90) {
	B0_DCI_A2_phase_Y = B0_DCI_A2_phase}
	if (B0_DCI_A2_phase <= 180) {
		B0_DCI_A2_phase_Y = 180 - B0_DCI_A2_phase}
		if (B0_DCI_A2_phase <= 270) {
			B0_DCI_A2_phase_Y = B0_DCI_A2_phase - 180}
				if (B0_DCI_A2_phase <= 360) {
					B0_DCI_A2_phase_Y = 360 - B0_DCI_A2_phase}
// определение координат вектора В0 * DCI_A2
var B0_DCI_A2_1_X = 0;
var B0_DCI_A2_2_X;
if (B0_DCI_A2_phase <= 180) {B0_DCI_A2_2_X = Math.abs(Math.cos(B0_DCI_A2_phase_X * 3.1415/180)) * B0_DCI_A2
	} else {B0_DCI_A2_2_X = Math.abs(Math.cos(B0_DCI_A2_phase_X * 3.1415/180)) * B0_DCI_A2 * (-1)}
var B0_DCI_A2_1_Y = 0;
var B0_DCI_A2_2_Y;
if (B0_DCI_A2_phase <= 90 || B0_DCI_A2_phase >= 270) {B0_DCI_A2_2_Y = Math.abs(Math.cos(B0_DCI_A2_phase_Y * 3.1415/180)) * B0_DCI_A2
	} else {B0_DCI_A2_2_Y = Math.abs(Math.cos(B0_DCI_A2_phase_Y * 3.1415/180)) * B0_DCI_A2 * (-1)}

// определение модуля вектора A0 * DCI_B2
var A0_DCI_B2 = A0 * DCI_B2;
// определение фазы вектора A0 * DCI_B2
var A0_DCI_B2_phase;
if ((A0_phase + DCI_B2_phase) >360) {
	A0_DCI_B2_phase = A0_phase + DCI_B2_phase - 360
	} else {A0_DCI_B2_phase = A0_phase + DCI_B2_phase}
// определение угла наклона вектора A0 * DCI_B2 к осям X и Y
var A0_DCI_B2_phase_X;
var A0_DCI_B2_phase_Y;
if (A0_DCI_B2_phase <= 90) {
	A0_DCI_B2_phase_X = 90 - A0_DCI_B2_phase}
	if (A0_DCI_B2_phase <= 180) {
		A0_DCI_B2_phase_X = A0_DCI_B2_phase - 90}
		if (A0_DCI_B2_phase <= 270) {
			A0_DCI_B2_phase_X = 270 - A0_DCI_B2_phase}
				if (A0_DCI_B2_phase <= 360) {
					A0_DCI_B2_phase_X = A0_DCI_B2_phase - 270}
if (A0_DCI_B2_phase <= 90) {
	A0_DCI_B2_phase_Y = A0_DCI_B2_phase}
	if (A0_DCI_B2_phase <= 180) {
		A0_DCI_B2_phase_Y = 180 - A0_DCI_B2_phase}
		if (A0_DCI_B2_phase <= 270) {
			A0_DCI_B2_phase_Y = A0_DCI_B2_phase - 180}
				if (A0_DCI_B2_phase <= 360) {
					A0_DCI_B2_phase_Y = 360 - A0_DCI_B2_phase}
// определение координат вектора A0 * DCI_B2
var A0_DCI_B2_1_X = 0;
var A0_DCI_B2_2_X;
if (A0_DCI_B2_phase <= 180) {A0_DCI_B2_2_X = Math.abs(Math.cos(A0_DCI_B2_phase_X * 3.1415/180)) * A0_DCI_B2
	} else {A0_DCI_B2_2_X = Math.abs(Math.cos(A0_DCI_B2_phase_X * 3.1415/180)) * A0_DCI_B2 * (-1)}
var A0_DCI_B2_1_Y = 0;
var A0_DCI_B2_2_Y;
if (A0_DCI_B2_phase <= 90 || A0_DCI_B2_phase >= 270) {A0_DCI_B2_2_Y = Math.abs(Math.cos(A0_DCI_B2_phase_Y * 3.1415/180)) * A0_DCI_B2
	} else {A0_DCI_B2_2_Y = Math.abs(Math.cos(A0_DCI_B2_phase_Y * 3.1415/180)) * A0_DCI_B2 * (-1)}

// определение модуля вектора A0 * DCI_B1
var A0_DCI_B1 = A0 * DCI_B1;
// определение фазы вектора A0 * DCI_B1
var A0_DCI_B1_phase;
if ((A0_phase + DCI_B1_phase) >360) {
	A0_DCI_B1_phase = A0_phase + DCI_B1_phase - 360
	} else {A0_DCI_B1_phase = A0_phase + DCI_B1_phase}
// определение угла наклона вектора A0 * DCI_B1 к осям X и Y
var A0_DCI_B1_phase_X;
var A0_DCI_B1_phase_Y;
if (A0_DCI_B1_phase <= 90) {
	A0_DCI_B1_phase_X = 90 - A0_DCI_B1_phase}
	if (A0_DCI_B1_phase <= 180) {
		A0_DCI_B1_phase_X = A0_DCI_B1_phase - 90}
		if (A0_DCI_B1_phase <= 270) {
			A0_DCI_B1_phase_X = 270 - A0_DCI_B1_phase}
				if (A0_DCI_B1_phase <= 360) {
					A0_DCI_B1_phase_X = A0_DCI_B1_phase - 270}
if (A0_DCI_B1_phase <= 90) {
	A0_DCI_B1_phase_Y = A0_DCI_B1_phase}
	if (A0_DCI_B1_phase <= 180) {
		A0_DCI_B1_phase_Y = 180 - A0_DCI_B1_phase}
		if (A0_DCI_B1_phase <= 270) {
			A0_DCI_B1_phase_Y = A0_DCI_B1_phase - 180}
				if (A0_DCI_B1_phase <= 360) {
					A0_DCI_B1_phase_Y = 360 - A0_DCI_B1_phase}
// определение координат вектора A0 * DCI_B1
var A0_DCI_B1_1_X = 0;
var A0_DCI_B1_2_X;
if (A0_DCI_B1_phase <= 180) {A0_DCI_B1_2_X = Math.abs(Math.cos(A0_DCI_B1_phase_X * 3.1415/180)) * A0_DCI_B1
	} else {A0_DCI_B1_2_X = Math.abs(Math.cos(A0_DCI_B1_phase_X * 3.1415/180)) * A0_DCI_B1 * (-1)}
var A0_DCI_B1_1_Y = 0;
var A0_DCI_B1_2_Y;
if (A0_DCI_B1_phase <= 90 || A0_DCI_B1_phase >= 270) {A0_DCI_B1_2_Y = Math.abs(Math.cos(A0_DCI_B1_phase_Y * 3.1415/180)) * A0_DCI_B1
	} else {A0_DCI_B1_2_Y = Math.abs(Math.cos(A0_DCI_B1_phase_Y * 3.1415/180)) * A0_DCI_B1 * (-1)}

// определение модуля вектора B0 * DCI_A1
var B0_DCI_A1 = B0 * DCI_A1;
// определение фазы вектора A0 * DCI_B1
var B0_DCI_A1_phase;
if ((B0_phase + DCI_A1_phase) >360) {
	B0_DCI_A1_phase = B0_phase + DCI_A1_phase - 360
	} else {B0_DCI_A1_phase = B0_phase + DCI_A1_phase}
// определение угла наклона вектора B0 * DCI_A1 к осям X и Y
var B0_DCI_A1_phase_X;
var B0_DCI_A1_phase_Y;
if (B0_DCI_A1_phase <= 90) {
	B0_DCI_A1_phase_X = 90 - B0_DCI_A1_phase}
	if (B0_DCI_A1_phase <= 180) {
		B0_DCI_A1_phase_X = B0_DCI_A1_phase - 90}
		if (B0_DCI_A1_phase <= 270) {
			B0_DCI_A1_phase_X = 270 - B0_DCI_A1_phase}
				if (B0_DCI_A1_phase <= 360) {
					B0_DCI_A1_phase_X = B0_DCI_A1_phase - 270}
if (B0_DCI_A1_phase <= 90) {
	B0_DCI_A1_phase_Y = B0_DCI_A1_phase}
	if (B0_DCI_A1_phase <= 180) {
		B0_DCI_A1_phase_Y = 180 - B0_DCI_A1_phase}
		if (B0_DCI_A1_phase <= 270) {
			B0_DCI_A1_phase_Y = B0_DCI_A1_phase - 180}
				if (B0_DCI_A1_phase <= 360) {
					B0_DCI_A1_phase_Y = 360 - B0_DCI_A1_phase}
// определение координат вектора B0 * DCI_A1
var B0_DCI_A1_1_X = 0;
var B0_DCI_A1_2_X;
if (B0_DCI_A1_phase <= 180) {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1
	} else {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1 * (-1)}
var B0_DCI_A1_1_Y = 0;
var B0_DCI_A1_2_Y;
if (B0_DCI_A1_phase <= 90 || B0_DCI_A1_phase >= 270) {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1
	} else {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1 * (-1)}

// определение фазы вектора B0 * DCI_A1
var B0_DCI_A1_phase;
if ((B0_phase + DCI_A1_phase) >360) {
	B0_DCI_A1_phase = B0_phase + DCI_A1_phase - 360
	} else {B0_DCI_A1_phase = B0_phase + DCI_A1_phase}
// определение угла наклона вектора B0 * DCI_A1 к осям X и Y
var B0_DCI_A1_phase_X;
var B0_DCI_A1_phase_Y;
if (B0_DCI_A1_phase <= 90) {
	B0_DCI_A1_phase_X = 90 - B0_DCI_A1_phase}
	if (B0_DCI_A1_phase <= 180) {
		B0_DCI_A1_phase_X = B0_DCI_A1_phase - 90}
		if (B0_DCI_A1_phase <= 270) {
			B0_DCI_A1_phase_X = 270 - B0_DCI_A1_phase}
				if (B0_DCI_A1_phase <= 360) {
					B0_DCI_A1_phase_X = B0_DCI_A1_phase - 270}
if (B0_DCI_A1_phase <= 90) {
	B0_DCI_A1_phase_Y = B0_DCI_A1_phase}
	if (B0_DCI_A1_phase <= 180) {
		B0_DCI_A1_phase_Y = 180 - B0_DCI_A1_phase}
		if (B0_DCI_A1_phase <= 270) {
			B0_DCI_A1_phase_Y = B0_DCI_A1_phase - 180}
				if (B0_DCI_A1_phase <= 360) {
					B0_DCI_A1_phase_Y = 360 - B0_DCI_A1_phase}
// определение координат вектора B0 * DCI_A1
var B0_DCI_A1_1_X = 0;
var B0_DCI_A1_2_X;
if (B0_DCI_A1_phase <= 180) {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1
	} else {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1 * (-1)}
var B0_DCI_A1_1_Y = 0;
var B0_DCI_A1_2_Y;
if (B0_DCI_A1_phase <= 90 || B0_DCI_A1_phase >= 270) {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1
	} else {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1 * (-1)}

// определение модуля вектора B0 * DCI_A2 - A0 * DCI_B2
var B0_DCIA2_A0_DCIB2;
var B0_DCIA2_A0_DCIB2_1_X = A0_DCI_B2_2_X;
var B0_DCIA2_A0_DCIB2_1_Y = A0_DCI_B2_2_Y;
var B0_DCIA2_A0_DCIB2_2_X = B0_DCI_A2_2_X;
var B0_DCIA2_A0_DCIB2_2_Y = B0_DCI_A2_2_Y;
B0_DCIA2_A0_DCIB2 = Math.sqrt(Math.pow(B0_DCIA2_A0_DCIB2_2_X - B0_DCIA2_A0_DCIB2_1_X, 2) + Math.pow(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y, 2));
// определение фазы вектора B0 * DCI_A2 - A0 * DCI_B2
var B0_DCIA2_A0_DCIB2_phase;
if ((B0_DCIA2_A0_DCIB2_2_X > B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y >= B0_DCIA2_A0_DCIB2_1_Y)) {
	B0_DCIA2_A0_DCIB2_phase = (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415)}
if ((B0_DCIA2_A0_DCIB2_2_X <= B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y < B0_DCIA2_A0_DCIB2_1_Y)) {
	B0_DCIA2_A0_DCIB2_phase = (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415) + 180}
if ((B0_DCIA2_A0_DCIB2_2_X < B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y >= B0_DCIA2_A0_DCIB2_1_Y)) {
	B0_DCIA2_A0_DCIB2_phase = 360 - (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415)}
if ((B0_DCIA2_A0_DCIB2_2_X >= B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y < B0_DCIA2_A0_DCIB2_1_Y)) {
	B0_DCIA2_A0_DCIB2_phase = 180 - (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415)}

// определение модуля вектора A0 * DCI_B1 - B0 * DCI_A1
var A0_DCIB1_B0_DCIA1;
var A0_DCIB1_B0_DCIA1_1_X = B0_DCI_A1_2_X;
var A0_DCIB1_B0_DCIA1_1_Y = B0_DCI_A1_2_Y;
var A0_DCIB1_B0_DCIA1_2_X = A0_DCI_B1_2_X;
var A0_DCIB1_B0_DCIA1_2_Y = A0_DCI_B1_2_Y;
A0_DCIB1_B0_DCIA1 = Math.sqrt(Math.pow(A0_DCIB1_B0_DCIA1_2_X - A0_DCIB1_B0_DCIA1_1_X, 2) + Math.pow(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y, 2));
// определение фазы вектора A0 * DCI_B1 - B0 * DCI_A1
var A0_DCIB1_B0_DCIA1_phase;
if ((A0_DCIB1_B0_DCIA1_2_X > A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y >= A0_DCIB1_B0_DCIA1_1_Y)) {
	A0_DCIB1_B0_DCIA1_phase = (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415)}
if ((A0_DCIB1_B0_DCIA1_2_X <= A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y < A0_DCIB1_B0_DCIA1_1_Y)) {
	A0_DCIB1_B0_DCIA1_phase = (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415) + 180}
if ((A0_DCIB1_B0_DCIA1_2_X < A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y >= A0_DCIB1_B0_DCIA1_1_Y)) {
	A0_DCIB1_B0_DCIA1_phase = 360 - (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415)}
if ((A0_DCIB1_B0_DCIA1_2_X >= A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y < A0_DCIB1_B0_DCIA1_1_Y)) {
	A0_DCIB1_B0_DCIA1_phase = 180 - (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415)}

// определение модуля вектора DCI_A1 * DCI_B2
var DCIA1_DCIB2 = DCI_A1 * DCI_B2;
// определение фазы вектора DCI_A1 * DCI_B2
var DCIA1_DCIB2_phase;
if ((DCI_A1_phase + DCI_B2_phase) >360) {
	DCIA1_DCIB2_phase = DCI_A1_phase + DCI_B2_phase - 360
	} else {DCIA1_DCIB2_phase = DCI_A1_phase + DCI_B2_phase}
// определение угла наклона вектора DCI_A1 * DCI_B2 к осям X и Y
var DCIA1_DCIB2_phase_X;
var DCIA1_DCIB2_phase_Y;
if (DCIA1_DCIB2_phase <= 90) {
	DCIA1_DCIB2_phase_X = 90 - DCIA1_DCIB2_phase}
	if (DCIA1_DCIB2_phase <= 180) {
		DCIA1_DCIB2_phase_X = DCIA1_DCIB2_phase - 90}
		if (DCIA1_DCIB2_phase <= 270) {
			DCIA1_DCIB2_phase_X = 270 - DCIA1_DCIB2_phase}
				if (DCIA1_DCIB2_phase <= 360) {
					DCIA1_DCIB2_phase_X = DCIA1_DCIB2_phase - 270}
if (DCIA1_DCIB2_phase <= 90) {
	DCIA1_DCIB2_phase_Y = DCIA1_DCIB2_phase}
	if (DCIA1_DCIB2_phase <= 180) {
		DCIA1_DCIB2_phase_Y = 180 - DCIA1_DCIB2_phase}
		if (DCIA1_DCIB2_phase <= 270) {
			DCIA1_DCIB2_phase_Y = DCIA1_DCIB2_phase - 180}
				if (DCIA1_DCIB2_phase <= 360) {
					DCIA1_DCIB2_phase_Y = 360 - DCIA1_DCIB2_phase}
// определение координат вектора DCI_A1 * DCI_B2
var DCIA1_DCIB2_1_X = 0;
var DCIA1_DCIB2_2_X;
if (DCIA1_DCIB2_phase <= 180) {DCIA1_DCIB2_2_X = Math.abs(Math.cos(DCIA1_DCIB2_phase_X * 3.1415/180)) * DCIA1_DCIB2
	} else {DCIA1_DCIB2_2_X = Math.abs(Math.cos(DCIA1_DCIB2_phase_X * 3.1415/180)) * DCIA1_DCIB2 * (-1)}
var DCIA1_DCIB2_1_Y = 0;
var DCIA1_DCIB2_2_Y;
if (DCIA1_DCIB2_phase <= 90 || DCIA1_DCIB2_phase >= 270) {DCIA1_DCIB2_2_Y = Math.abs(Math.cos(DCIA1_DCIB2_phase_Y * 3.1415/180)) * DCIA1_DCIB2
	} else {DCIA1_DCIB2_2_Y = Math.abs(Math.cos(DCIA1_DCIB2_phase_Y * 3.1415/180)) * DCIA1_DCIB2 * (-1)}

// определение модуля вектора DCI_B1 * DCI_A2
var DCIB1_DCIA2 = DCI_B1 * DCI_A2;
// определение фазы вектора DCI_B1 * DCI_A2
var DCIB1_DCIA2_phase;
if ((DCI_B1_phase + DCI_A2_phase) >360) {
	DCIB1_DCIA2_phase = DCI_B1_phase + DCI_A2_phase - 360
	} else {DCIB1_DCIA2_phase = DCI_B1_phase + DCI_A2_phase}
// определение угла наклона вектора DCI_B1 * DCI_A2 к осям X и Y
var DCIB1_DCIA2_phase_X;
var DCIB1_DCIA2_phase_Y;
if (DCIB1_DCIA2_phase <= 90) {
	DCIB1_DCIA2_phase_X = 90 - DCIB1_DCIA2_phase}
	if (DCIB1_DCIA2_phase <= 180) {
		DCIB1_DCIA2_phase_X = DCIB1_DCIA2_phase - 90}
		if (DCIB1_DCIA2_phase <= 270) {
			DCIB1_DCIA2_phase_X = 270 - DCIB1_DCIA2_phase}
				if (DCIB1_DCIA2_phase <= 360) {
					DCIB1_DCIA2_phase_X = DCIB1_DCIA2_phase - 270}
if (DCIB1_DCIA2_phase <= 90) {
	DCIB1_DCIA2_phase_Y = DCIB1_DCIA2_phase}
	if (DCIB1_DCIA2_phase <= 180) {
		DCIB1_DCIA2_phase_Y = 180 - DCIB1_DCIA2_phase}
		if (DCIB1_DCIA2_phase <= 270) {
			DCIB1_DCIA2_phase_Y = DCIB1_DCIA2_phase - 180}
				if (DCIB1_DCIA2_phase <= 360) {
					DCIB1_DCIA2_phase_Y = 360 - DCIB1_DCIA2_phase}
// определение координат вектора DCI_B1 * DCI_A2
var DCIB1_DCIA2_1_X = 0;
var DCIB1_DCIA2_2_X;
if (DCIB1_DCIA2_phase <= 180) {DCIB1_DCIA2_2_X = Math.abs(Math.cos(DCIB1_DCIA2_phase_X * 3.1415/180)) * DCIB1_DCIA2
	} else {DCIB1_DCIA2_2_X = Math.abs(Math.cos(DCIB1_DCIA2_phase_X * 3.1415/180)) * DCIB1_DCIA2 * (-1)}
var DCIB1_DCIA2_1_Y = 0;
var DCIB1_DCIA2_2_Y;
if (DCIB1_DCIA2_phase <= 90 || DCIB1_DCIA2_phase >= 270) {DCIB1_DCIA2_2_Y = Math.abs(Math.cos(DCIB1_DCIA2_phase_Y * 3.1415/180)) * DCIB1_DCIA2
	} else {DCIB1_DCIA2_2_Y = Math.abs(Math.cos(DCIB1_DCIA2_phase_Y * 3.1415/180)) * DCIB1_DCIA2 * (-1)}

// определение модуля вектора DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2
var DCIA1_DCIB2_DCIB1_DCIA2;
var DCIA1_DCIB2_DCIB1_DCIA2_1_X = DCIB1_DCIA2_2_X;
var DCIA1_DCIB2_DCIB1_DCIA2_1_Y = DCIB1_DCIA2_2_Y;
var DCIA1_DCIB2_DCIB1_DCIA2_2_X = DCIA1_DCIB2_2_X;
var DCIA1_DCIB2_DCIB1_DCIA2_2_Y = DCIA1_DCIB2_2_Y;
DCIA1_DCIB2_DCIB1_DCIA2 = Math.sqrt(Math.pow(DCIA1_DCIB2_DCIB1_DCIA2_2_X - DCIA1_DCIB2_DCIB1_DCIA2_1_X, 2) + Math.pow(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y, 2));
// определение фазы вектора DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2
var DCIA1_DCIB2_DCIB1_DCIA2_phase;
if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X > DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y >= DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) {
	DCIA1_DCIB2_DCIB1_DCIA2_phase = (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415)}
if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X <= DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y < DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) {
	DCIA1_DCIB2_DCIB1_DCIA2_phase = (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415) + 180}
if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X < DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y >= DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) {
	DCIA1_DCIB2_DCIB1_DCIA2_phase = 360 - (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415)}
if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X >= DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y < DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) {
	DCIA1_DCIB2_DCIB1_DCIA2_phase = 180 - (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415)}

// определение массы корректирующей массы Mb1 (плоскость 1)
Mb1 = B0_DCIA2_A0_DCIB2 / DCIA1_DCIB2_DCIB1_DCIA2;
// опредение угла установки корректирующей массы Mb1 (плоскость 1)
if ((B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) < 0) {
	Mb1_corner = (B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) + 360}
	else if ((B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) > 360) {
		Mb1_corner = (B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) - 360}
		else {Mb1_corner = (B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase)}

// определение массы корректирующей массы Mb2 (плоскость 2)
Mb2 = A0_DCIB1_B0_DCIA1 / DCIA1_DCIB2_DCIB1_DCIA2;
// опредение угла установки корректирующей массы Mb2 (плоскость 2)
if ((A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) < 0) {
	Mb2_corner = (A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) + 360}
	else if ((A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) > 360) {
		Mb2_corner = (A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) - 360}
		else {Mb2_corner = (A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase)}
		
gtl.log.info("Mb1",Mb1);
gtl.log.info("Mb1_corner",Mb1_corner);
gtl.log.info("Mb2",Mb2);
gtl.log.info("Mb2_corner",Mb2_corner);
gtl.log.info("FREQ.value",FREQ.value);
gtl.log.info("freq.value (по dc)",freq.value);
gtl.log.info("F1v0.level",F1v0);
gtl.log.info("RMSv0_2_1000",RMSv0_2_1000.value);
gtl.log.info("F1v1.level",F1v1);
gtl.log.info("RMSv1_2_1000",RMSv1_2_1000.value);
gtl.log.info("F1v0_test_ampl",F1v0_test_ampl);
gtl.log.info("F1v1_test_ampl",F1v1_test_ampl);
gtl.log.info("F1v_test_balance",F1v_test_balance);
gtl.log.info("F1v_harms.harms[0].tolerance",F1v0_harms.harms[0].tolerance);
gtl.log.info("delta_phase_F1v0",delta_phase_F1v0.value);
gtl.log.info("delta_phase_F1v1",delta_phase_F1v1.value);
gtl.log.info("delta_phase_F1v.acq_time",delta_phase_F1v0.acq_time);
gtl.log.info("AUSPv0.acq_time",AUSPv0.acq_time);

    // Выдача результата (results)
    let __result = {
		Частота_вращения_F1_0: F_find_round0,
		Канал_вибрации_датчика1: "канал [0]",
		Амплитуда_гармоники_F1_датчика1: level_AUSPv0[ind_F_find0],
		Фаза_гармоники_F1_датчика1: delta_phase_AUSPv0[ind_F_find0],
		проверка_амплитуды_F1v_датчика1: AUSPv_data0[ind_F_find0] - AUSPv_base0[ind_F_find0],
		амплитуды_F1v_датчика1: F1v0,
		дельта_фаза_датчика1: delta_phase_F1v0.value,
		_:"-",
		Частота_вращения_F1_1: F_find_round1,
		Канал_вибрации_датчика2: "канал [1]",
		Амплитуда_гармоники_F1_датчика2: level_AUSPv1[ind_F_find1],
		Фаза_гармоники_F1_датчика2: delta_phase_AUSPv1[ind_F_find1],
		проверка_амплитуды_F1v_датчика2: AUSPv_data1[ind_F_find1] - AUSPv_base1[ind_F_find1],
		амплитуды_F1v_датчика2: F1v1,
		дельта_фаза_датчика2: delta_phase_F1v1.value,
	  };
gtl.results = __result;
gtl.diagnostic.stop();

break;

default:
	break;
}
}