"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 fnc = gtl.import("user-functions.js");

// Цвета (для справки)
// #ff0000 - красный
// #00ff00 - салатовый
// #0fae1a - зелёный
// #0000ff - синий
// #00ddff - голубой
// #ff3dcc - фиолетовый
// #ffff00 - жёлтый

// ***** БАЛАНСИРОВОЧНЫЙ КАЛЬКУЛЯТОР. ОДНА ПЛОСКОСТЬ с фазой (использование ДКВ) *****
// ***********************************************************************************

// Объявление графических плоскостей для построения графиков
	let plot_pfc = gtl.plots.add("ФЧХ"); // фазо-частотная характеристика
	let plot_ausp = gtl.plots.add("Спектр виброскорости"); // объект для спектра
	let plot_vibr = gtl.plots.add("Векторы вибрации"); // объект для векторов вибрации
	let plot_disb = gtl.plots.add("Расположение дисбаланса"); // объект для дисбаланса

	// gtl.log.info("размер массива AUSPv_pl", AUSPv_pl.data.length);
	// gtl.log.info("размер массива pfc_pl", pfc_pl.data.length);

// Переменные основные
// параметр вибрации (модуль вектора) - виброскорость (мм/с)
// угол (фаза) вектора - градусы
// масса груза (модуль ветора) - граммы
// DCI - Dynamic Coefficient of Influence (динамический коэффициент влияния)
// * - значение получаем из измерительного блока при нажатии кнопки
// ** - значение вводится пользователем
// *** - значение получаем в результате расчёта программы балансировки
// значение переменной с нижним подчёркиванием (..._) берётся из "дополнительных опций"; если оно не задано, то рассчитывается в скрипте

let R = gtl.options.customOptions.R;					// радиус установки грузов ** (для вычисления массы пробного груза)
let P = gtl.options.customOptions.P; 					// масса ротора, кг ** (для вычисления массы пробного груза)
let G = gtl.options.customOptions.G; 					// класс точности балансировки, мм/с ** (ГОСТ 1940)
let n = gtl.options.customOptions.n; 					// скорость вращения, об/мин ** (для вычисления массы пробного груза и допустимого остаточного дисбаланса)
let U_per;												// допустимый остаточный дисбаланс *** (ГОСТ 1940)
let U_res;												// остаточный дисбаланс *** (ГОСТ 1940)

let A0_ = gtl.options.customOptions.A0; 				// модуль вектора начальной вибрации */**
let A0 = A0_;											// модуль вектора начальной вибрации */** (конечное значение)
let A0_phase_ = gtl.options.customOptions.A0_phase;		// фаза вектора начальной вибрации */**
let A0_phase = A0_phase_; 								// фаза вектора начальной вибрации */** (конечное значение)
let DCI_ = gtl.options.customOptions.DCI;				// модуль (мм/с/граммы) динамического коэффициента влияния **/***
let DCI = DCI_;											// модуль (мм/с/граммы) динамического коэффициента влияния **/*** (конечное значение)
let DCI_phase_ = gtl.options.customOptions.DCI_phase;	// фаза динамического коэффициента влияния **/***
let DCI_phase = DCI_phase_;								// фаза динамического коэффициента влияния **/*** (конечное значение)
let Mb = gtl.options.customOptions.Mb;					// масса применённого балансировочного груза **/*** (конечное значение)
let Mb_corner = gtl.options.customOptions.Mb_corner;	// угол применённого балансировочного груза **/*** (конечное значение)
let Mb_calc;											// модуль расчётного вектора балансировочного груза ***
let Mb_corner_calc;										// угол расчётного вектора балансировочного груза ***
let Mdisb;												// масса дисбаланса ***
let Mdisb_corner;										// угол расположения дисбаланса ***

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

let Mb_corner_calc_X;	// угол наклона расчётного вектора Mb к оси X
let Mb_corner_calc_Y;	// угол наклона расчётного вектора Mb к оси Y
let Mb_1_calc_X;		// начальная координата расчётного вектора Mb по оси X
let Mb_2_calc_X;		// конечная координата расчётного вектора Mb по оси X
let Mb_1_calc_Y;		// начальная координата расчётного вектора Mb по оси Y
let Mb_2_calc_Y;		// конечная координата расчётного вектора Mb по оси Y

let Mb_corner_X;	// угол наклона вектора Mb к оси X
let Mb_corner_Y;	// угол наклона вектора Mb к оси Y
let Mb_1_X;			// начальная координата вектора Mb по оси X
let Mb_2_X;			// конечная координата вектора Mb по оси X
let Mb_1_Y;			// начальная координата вектора Mb по оси Y
let Mb_2_Y;			// конечная координата вектора Mb по оси Y

let Mdisb_corner_X;// угол наклона вектора Mdisb к оси X
let Mdisb_corner_Y;// угол наклона вектора Mdisb к оси Y
let Mdisb_1_X;		// начальная координата вектора Mdisb по оси X
let Mdisb_2_X;		// конечная координата вектора Mdisb по оси X
let Mdisb_1_Y;		// начальная координата вектора Mdisb по оси Y
let Mdisb_2_Y;		// конечная координата вектора Mdisb по оси Y

// ***** РАСЧЁТЫ *****
// gtl.diagnostic.interval = 15;
// gtl.diagnostic.interval = Math.max(AUSPv.acq_time, AUSPv_pl.acq_time) + 0.1;
gtl.diagnostic.interval = gtl.acq_time + 1;

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

function diagnose() {

// РАСЧЁТЫ (балансировочный калькулятор)
// ШАГ 2 - расположение дисбаланса:
	// вычисление положения дисбаланса и рекомендуемого балансировочного груза Mb_calc
	// ввод массы и угла установки балансировочного груза Mb
	// построение графиков расположения дисбаланса Mdisb, расчётного Mb_calc и введённого Mb балансировочного груза
	// из предыдущих шагов переносятся: амплитуда и фаза вибрации A0
	// построение графиков вибрации A0 и A2

		
	// определение угла наклона вектора 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
		var xA0_array = []; // массив координат точек вектора A0 по оси X
		var yA0_array = []; // массив координат точек вектора A0 по оси Y
		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)}
		xA0_array[0] = A0_1_X;
		xA0_array[1] = A0_2_X;
		yA0_array[0] = A0_1_Y;
		yA0_array[1] = A0_2_Y;

	// определение координат точек окружности графика для отображения векторов вибрации
		var xV_array = []; // массив координат точек окружности V по оси X
		var yV_array = []; // массив координат точек окружности V по оси Y
		var x0V = 0; // центр в начале координат
		var y0V = 0; // центр в начале координат
			for (let i=0; i<=359; i++ ) {
				xV_array.push(x0V + (Math.max(A0)+Math.max(A0)*0.1) * (Math.sin((i) * Math.PI / 180)));
				yV_array.push(y0V + (Math.max(A0)+Math.max(A0)*0.1) * (Math.cos((i) * Math.PI / 180)));}

	// определение модуля вектора Mb
		Mb_calc = A0 / DCI;
	// определение угла вектора Mb
		if ((A0_phase - DCI_phase + 180) < 360) {
			Mb_corner_calc = (A0_phase - DCI_phase + 180)
			} else {Mb_corner_calc = (A0_phase - DCI_phase + 180) - 360}
		// if ((m_test_corner + A0_phase - dA_phase + 180) < 360) {
		// 	Mb_corner = (m_test_corner + A0_phase - dA_phase + 180)
		// 	} else {Mb_corner = (m_test_corner + A0_phase - dA_phase + 180) - 360}
	// определение угла наклона вектора балансировочного груза Mb_calc к осям X и Y
		if (Mb_corner_calc <= 90) {
		Mb_corner_calc_X = 90 - Mb_corner_calc}
			if (Mb_corner_calc <= 180) {
			Mb_corner_calc_X = Mb_corner_calc - 90}
				if (Mb_corner_calc <= 270) {
				Mb_corner_calc_X = 270 - Mb_corner_calc}
					if (Mb_corner_calc <= 360) {
					Mb_corner_calc_X = Mb_corner_calc - 270}
		if (Mb_corner_calc <= 90) {
		Mb_corner_calc_Y = Mb_corner_calc}
			if (Mb_corner_calc <= 180) {
			Mb_corner_calc_Y = 180 - Mb_corner_calc}
				if (Mb_corner_calc <= 270) {
				Mb_corner_calc_Y = Mb_corner_calc - 180}
					if (Mb_corner_calc <= 360) {
					Mb_corner_calc_Y = 360 - Mb_corner_calc}
	// определение координат вектора балансировочного груза Mb_calc
		Mb_1_calc_X = 0;
		if (Mb_corner_calc <= 180) {Mb_2_calc_X = Math.abs(Math.cos(Mb_corner_calc_X * Math.PI/180)) * Mb_calc * (-1)
			} else {Mb_2_calc_X = Math.abs(Math.cos(Mb_corner_calc_X * Math.PI/180)) * Mb_calc}
		Mb_1_calc_Y = 0;
		if (Mb_corner_calc <= 90 || Mb_corner_calc >= 270) {Mb_2_calc_Y = Math.abs(Math.cos(Mb_corner_calc_Y * Math.PI/180)) * Mb_calc
			} else {Mb_2_calc_Y = Math.abs(Math.cos(Mb_corner_calc_Y * Math.PI/180)) * Mb_calc * (-1)}

	// определение угла наклона вектора балансировочного груза Mb к осям X и Y
		if (Mb_corner <= 90) {
		Mb_corner_X = 90 - Mb_corner}
			if (Mb_corner <= 180) {
			Mb_corner_X = Mb_corner - 90}
				if (Mb_corner <= 270) {
				Mb_corner_X = 270 - Mb_corner}
					if (Mb_corner <= 360) {
					Mb_corner_X = Mb_corner - 270}
		if (Mb_corner <= 90) {
		Mb_corner_Y = Mb_corner}
			if (Mb_corner <= 180) {
			Mb_corner_Y = 180 - Mb_corner}
				if (Mb_corner <= 270) {
				Mb_corner_Y = Mb_corner - 180}
					if (Mb_corner <= 360) {
					Mb_corner_Y = 360 - Mb_corner}
	// определение координат вектора балансировочного груза Mb
		Mb_1_X = 0;
		if (Mb_corner <= 180) {Mb_2_X = Math.abs(Math.cos(Mb_corner_X * Math.PI/180)) * Mb * (-1)
			} else {Mb_2_X = Math.abs(Math.cos(Mb_corner_X * Math.PI/180)) * Mb}
		Mb_1_Y = 0;
		if (Mb_corner <= 90 || Mb_corner >= 270) {Mb_2_Y = Math.abs(Math.cos(Mb_corner_Y * Math.PI/180)) * Mb
			} else {Mb_2_Y = Math.abs(Math.cos(Mb_corner_Y * Math.PI/180)) * Mb * (-1)}


	// определение массы дисбаланса
		Mdisb = Mb_calc; // равен массе балансировочного груза
	// определение угла расположения дисбаланса
		if ((Mb_corner_calc + 180) > 360) {
	 		Mdisb_corner = (Mb_corner_calc + 180) - 360}
		else if ((Mb_corner + 180) < 0) {
	 		Mdisb_corner = (Mb_corner_calc + 180) + 360}
		else {Mdisb_corner = (Mb_corner_calc + 180)}
	// определение угла наклона вектора дисбаланса Mdisb к осям X и Y
		if (Mdisb_corner <= 90) {
		Mdisb_corner_X = 90 - Mdisb_corner}
			if (Mdisb_corner <= 180) {
			Mdisb_corner_X = Mdisb_corner - 90}
				if (Mdisb_corner <= 270) {
				Mdisb_corner_X = 270 - Mdisb_corner}
					if (Mdisb_corner <= 360) {
					Mdisb_corner_X = Mdisb_corner - 270}
		if (Mdisb_corner <= 90) {
		Mdisb_corner_Y = Mdisb_corner}
			if (Mdisb_corner <= 180) {
			Mdisb_corner_Y = 180 - Mdisb_corner}
				if (Mdisb_corner <= 270) {
				Mdisb_corner_Y = Mdisb_corner - 180}
					if (Mdisb_corner <= 360) {
					Mdisb_corner_Y = 360 - Mdisb_corner}
	// определение координат вектора дисбаланса Mdisb
		Mdisb_1_X = 0;
		if (Mdisb_corner <= 180) {Mdisb_2_X = Math.abs(Math.cos(Mdisb_corner_X * Math.PI/180)) * Mdisb * (-1)
			} else {Mdisb_2_X = Math.abs(Math.cos(Mdisb_corner_X * Math.PI/180)) * Mdisb}
		Mdisb_1_Y = 0;
		if (Mdisb_corner <= 90 || Mdisb_corner >= 270) {Mdisb_2_Y = Math.abs(Math.cos(Mdisb_corner_Y * Math.PI/180)) * Mdisb
			} else {Mdisb_2_Y = Math.abs(Math.cos(Mdisb_corner_Y * Math.PI/180)) * Mdisb * (-1)}


// Координаты масс для визуализации
	// определение координат точек окружности обозначения массы введённого балансировочного груза Mb
		var x_Mb_array = []; // массив координат точек окружности расчётного Mb по оси X
		var y_Mb_array = []; // массив координат точек окружности расчётного Mb по оси Y
		var x0_Mb = Mb_2_X; // центр по X
		var y0_Mb = Mb_2_Y; // центр по Y
			for (let i=0; i<=359; i++ ) {
				x_Mb_array.push(x0_Mb + (Math.max(Mb_calc,Mb,Mdisb)*0.1 * (Math.sin((i) * Math.PI / 180))));
				y_Mb_array.push(y0_Mb + (Math.max(Mb_calc,Mb,Mdisb)*0.1 * (Math.cos((i) * Math.PI / 180))));}
	// определение координат точек окружности обозначения массы расчётного балансировочного груза Mb_calc
		var x_Mb_calc_array = []; // массив координат точек окружности Mb_calc по оси X
		var y_Mb_calc_array = []; // массив координат точек окружности Mb_calc по оси Y
		var x0_Mb_calc = Mb_2_calc_X; // центр по X
		var y0_Mb_calc = Mb_2_calc_Y; // центр по Y
			for (let i=0; i<=359; i++ ) {
				x_Mb_calc_array.push(x0_Mb_calc + (Math.max(Mb_calc,Mb,Mdisb)*0.1 * (Math.sin((i) * Math.PI / 180))));
				y_Mb_calc_array.push(y0_Mb_calc + (Math.max(Mb_calc,Mb,Mdisb)*0.1 * (Math.cos((i) * Math.PI / 180))));}
	// определение координат точек окружности обозначения массы дисбаланса Mdisb
		var x_Mdisb_array = []; // массив координат точек окружности Mdisb по оси X
		var y_Mdisb_array = []; // массив координат точек окружности Mdisb по оси Y
		var x0_Mdisb = Mdisb_2_X; // центр по X
		var y0_Mdisb = Mdisb_2_Y; // центр по Y
			for (let i=0; i<=359; i++ ) {
				x_Mdisb_array.push(x0_Mdisb + (Math.max(Mb_calc,Mb,Mdisb)*0.1 * (Math.sin((i) * Math.PI / 180))));
				y_Mdisb_array.push(y0_Mdisb + (Math.max(Mb_calc,Mb,Mdisb)*0.1 * (Math.cos((i) * Math.PI / 180))));}
	// определение координат точек окружности графика для отображения расположения дисбаланса
		var xD_array = []; // массив координат точек окружности D по оси X
		var yD_array = []; // массив координат точек окружности D по оси Y
		var x0D = 0; // центр в начале координат
		var y0D = 0; // центр в начале координат
			for (let i=0; i<=359; i++ ) {
				xD_array.push(x0D + (Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.1) * (Math.sin((i) * Math.PI / 180)));
				yD_array.push(y0D + (Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.1) * (Math.cos((i) * Math.PI / 180)));}		

	// Вычисление допустимого остаточного дисбаланса
		U_per = (1000 * (G * P)) / (Math.PI * n / 30);
	// Остаточный дисбаланс
		U_res = Mdisb * R;



// Графики вибрации
	plot_vibr.add(
        {
        	color: 0x0000ff,
        	name: "Вибрация_A0",
        	x: xA0_array,
        	y: yA0_array,
        });	
	plot_vibr.add(
        {
        	color: 0x00ffffff,
        	name: "График векторов вибрации",
        	x: xV_array,
        	y: yV_array,
        });
	plot_vibr.add(
		{
			color: 0x00ffffff,
			name: "границы",
			x: [-(Math.max(A0)+Math.max(A0)*0.2), -(Math.max(A0)+Math.max(A0)*0.2), (Math.max(A0)+Math.max(A0)*0.2), (Math.max(A0)+Math.max(A0)*0.2)],
			y: [(Math.max(A0)+Math.max(A0)*0.2), -(Math.max(A0)+Math.max(A0)*0.2), -(Math.max(A0)+Math.max(A0)*0.2), (Math.max(A0)+Math.max(A0)*0.2)]
		});

	plot_disb.add(
        {
        	color: 0x00ff00,
        	name: "Балансировочный груз расчётный",
        	x: x_Mb_calc_array,
        	y: y_Mb_calc_array,
        });
	plot_disb.add(
        {
        	color: 0x0fae1a,
        	name: "Балансировочный груз введённый",
        	x: x_Mb_array,
        	y: y_Mb_array,
        });	
	plot_disb.add(
        {
        	color: 0xff0000,
        	name: "Дисбаланс",
        	x: x_Mdisb_array,
        	y: y_Mdisb_array,
        });	
	plot_disb.add(
        {
        	color: 0x00ffffff,
        	name: "График расположения дисбаланса",
        	x: xD_array,
        	y: yD_array,
        });
	plot_disb.add(
		{
			color: 0x00ffffff,
			name: "границы",
			x: [-(Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2), -(Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2), (Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2), (Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2)],
			y: [(Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2), -(Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2), -(Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2), (Math.max(Mb_calc,Mb,Mdisb)+Math.max(Mb_calc,Mb,Mdisb)*0.2)]
		});

gtl.log.info("Mb (балансировочный груз расчёт)",Mb_calc);
gtl.log.info("Mb_corner (угол установки груза расчёт)",Mb_corner_calc);
gtl.log.info("Mb (балансировочный груз введён)",Mb);
gtl.log.info("Mb_corner (угол установки груза введён)",Mb_corner);
gtl.log.info("Mdisb (дисбаланс)",Mdisb);
gtl.log.info("Mdisb_corner (угол расположения дисбаланса)",Mdisb_corner);
gtl.log.info("A0",A0);
gtl.log.info("A0_phase",A0_phase);
gtl.log.info("модуль ДКВ", DCI);
gtl.log.info("фаза ДКВ", DCI_phase);

gtl.log.info("Допустимый остаточный дисбаланс", U_per);
gtl.log.info("Остаточный дисбаланс", U_res);

    // Выдача результата (results)
    let __result = {
		_001_Част_вращ_обмин: n,
		_002_Ампл_вибр_пуска_A0: A0,
		_003_Фаза_вибр_пуска_A0: A0_phase,
		_004_Масса_дисбаланса: Mdisb,
		_005_Угол_дисбаланса: Mdisb_corner,
		_006_Масса_баланс_груза_введён: Mb,
		_007_Угол_баланс_груза_введён: Mb_corner,
		_008_Масса_баланс_груза_расч: Mb_calc,
		_009_Угол_баланс_груза_расч: Mb_corner_calc,
		_010_Модуль_ДКВ: DCI,
		_011_Фаза_ДКВ: DCI_phase,
		_012_Допуст_ост_дисб_г_мм: U_per,
		_013_Остат_дисб_г_мм: U_res
	  };

gtl.results = {"result": __result};

gtl.diagnostic.stop();

// break;

// default:
// 	break;
// }
}