export function getFreq(args) {
    let FR = {}; //объект данных по частоте вращения
    switch (record.tachoOptions.tachoState) {
        case 0:
            if (args != undefined) {
                let __src = args.src; //источник сигнала частоты вращения
                let __frq = args.freq; //граничная частота фильтрации сигнала
                let __time = args.time; //интервал измерения частоты вращения
                let __avg = args.avg; //количество отсчетов для усреднения
                let __dc = args.dc; //порог срабатывания счетчика        

                let __fltr = gtl.add_filter_iir(__src);
                __fltr.kind = gtl.filter_iir.butterworth;
                __fltr.type = gtl.filter_iir.lowpass;
                __fltr.order = 10;
                __fltr.frequency = __frq;

                let __freq = gtl.add_value_freq(__fltr);
                __freq.time = __time;
                __freq.avg_cnt = __avg;
                __freq.dc = __dc;
                FR["value"] = __freq.value * options.tachoRatio;
                FR["values"] = __freq.values;
                FR["time"] = args.time * args.avg;
            } else {
                FR["value"] = 0;
                FR["values"] = [0];
                FR["time"] = 0;
            };
            break;
        case 1:
            FR["value"] = record.tachoOptions.tachoValue * options.tachoRatio;
            FR["values"] = [0];
            FR["time"] = 0;
            break;
        case 2:
            FR["value"] = record.tachoOptions.tachoFromInfo * options.tachoRatio;
            FR["values"] = [0];
            FR["time"] = 0;
            break;
    };
    return FR;
}; //определение частоты вращения в зависимости от источника тахо сигнала

export function freqIstab(src) {
    let __max = Math.max(...src.values);
    let __min = Math.min(...src.values);
    let __instab = (__max - __min) / src.value;
    return __instab;
}; //нестабильность частоты вращения в %

//параметры подшипника качения
var rbModelName = options.rbModelName || "No Name";
var rbVendor = options.rbVendor || "No Vendor";
var rb_inner = options.rbInnerD || 0; //диаметр внутреннего кольца
var rb_outer = options.rbOuterD || 0; //диаметр наружного кольца
var rb_roller = options.rbRollerD || 0; //диаметр тела качения
var rb_rollerCount = options.rbRollerCount || 0; //количество тел качения
var rb_angle = (options.rbAngle * Math.PI) / 180 || 0; //угол контакта тел качения (рад.)
var rb_cage = (rb_inner + rb_outer) / 2; //диаметр сепаратора (средний диаметр)

//определение вспомогательных коэффициентов k1 и k2 для подшипников качения
let rb_k1 = 0.5 * (1 - (rb_roller / rb_cage) * Math.cos(rb_angle));
let rb_k2 = 0.5 * (1 + (rb_roller / rb_cage) * Math.cos(rb_angle));
export function FREQ(freq) { return freq }; //частота вращения
export function FTF(freq) { return rb_k1 * freq }; //частота вращения сепаратора (FTF)
export function BPFO(freq) { return rb_k1 * freq * rb_rollerCount }; //частота перекатывания тел качения по наружному кольцу (BPFO)
export function BPFI(freq) { return rb_k2 * freq * rb_rollerCount }; //частота перекатывания тел качения по внутреннему кольцу (BPFI)
export function BSF(freq) { return 2 * freq * (rb_cage / rb_roller) * rb_k1 * rb_k2 }; //частота вращения (контакта) тел качения (BSF)
export function freqNess() {
    let R = (rb_inner / 2) + (rb_roller / 2); //расстояние до центра тяжести тела качения
    let __fness = (Math.sqrt(9.81 / (4 * (Math.PI ** 2) * R / 1000))) / rb_k1;
    return __fness;
}; //минимально необходимая частота вращения для компенсации силы тяжести центробежной силой

//параметры ШВП
var bsModelName = options.bsModelName || "No Name";
var bsVendor = options.bsVendor || "No Vendor";
var bs_inner = options.bsInnerD || 0; //диаметр внутреннего кольца
var bs_outer = options.bsOuterD || 0; //диаметр наружного кольца
var bs_roller = options.bsRollerD || 0; //диаметр тела качения
var bs_rollerCount = options.bsRollerCount || 0; //количество тел качения
var bs_angle = (options.bsAngle * Math.PI) / 180 || 0; //угол контакта тел качения (рад.)
var bs_cage = (bs_inner + bs_outer) / 2; //средний диаметр

//определение вспомогательных коэффициентов k1 и k2 для ШВП
let bs_k1 = 0.5 * (1 - (bs_roller / bs_cage) * Math.cos(bs_angle));
let bs_k2 = 0.5 * (1 + (bs_roller / bs_cage) * Math.cos(bs_angle));
export function BSFTF(freq) { return bs_k1 * freq }; //частота вращения сепаратора (перемещения тел качения)
export function BSNUT(freq) { return bs_k1 * freq * bs_rollerCount }; //частота перекатывания тел качения по гайке
export function BSSCR(freq) { return bs_k2 * freq * bs_rollerCount }; //частота перекатывания тел качения по винту
export function BSBAL(freq) { return 2 * freq * (bs_cage / bs_roller) * bs_k1 * bs_k2 }; //частота вращения (контакта) тел качения

//параметры редуктора
var gtZ1 = options.gtZ1 || 0; //количество зубьев шестерни
var gtZ2 = options.gtZ2 || 0; //количество зубьев зубчатого колеса
export function GTFZ(freq) { return freq * gtZ1 }; //зубцовая частота
export function GTF2(freq) { return freq * (gtZ1 / gtZ2) }; //частота вращения второго вала редуктора

//параметры ременной передачи
var bdD1 = options.bdD1 || 0; //диаметр ведущего шкива
var bdD2 = options.bdD2 || 0; //диаметр ведомого шкива
var bdL = options.bdL || 0; //длинна ремня
export function BDF2(freq) { return freq * (bdD1 / bdD2) }; //частота вращения ведомого шкива
export function BDFB(freq) { return freq * (Math.PI * bdD1 / bdL) }; //частота вращения ремня

//параметры зубчатой ременной передачи
var cbdZ1 = options.cbdZ1 || 0; //количество зубьев ведущего шкива
var cbdZ2 = options.cbdZ2 || 0; //количество зубьев ведомого шкива
var cbdZ3 = options.cbdZ3 || 0; //количество зубьев ремня
export function CBFZ(freq) { return freq * cbdZ1 }; //зубцовая частота
export function CBDF2(freq) { return freq * (cbdZ1 / cbdZ2) }; //частота вращения ведомого шкива
export function CBDFB(freq) { return freq * (cbdZ1 / cbdZ3) }; //частота вращения ремня

//параметры насоса
var pmBlades = options.pmBlades || 0; //количество лопастей насосного колеса
export function PMFBLD(freq) { return freq * pmBlades }; //лопастная частота

//параметры планетарной передачи
var pgZ1 = options.pgZ1 || 0; //количество зубьев солнца
var pgZ2 = options.pgZ2 || 0; //количество зубьев саттелитов
var pgZ3 = options.pgZ3 || 0; //количество зубьев короны
var pgN = options.pgN || 0; //количество саттелитов
export function PGF2(freq) { return (0.5 * freq * pgZ1) / (pgZ1 + pgZ2) }; //частота вращения выходного вала планетарной передачи
export function PGFSAT(freq) { return (0.5 * freq) * (pgZ1 / pgZ2) * ((pgZ1 + 2 * pgZ2) / (pgZ1 + pgZ2)) }; //частота вращения саттелита
export function PGFZ(freq) { return pgZ2 * PGFSAT(freq) }; //зубцовая частота

//параметры турбины
var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины
export function TRFBLD(freq) { return freq * trBlades }; //лопастная частота

//параметры электродвигателя
//var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины

export function specParams(freq) {
    let __fltr = {}; //объект расчетных параметров полосового фильтра
    let __spec = {}; //объект расчетных параметров спектра
    let __tol = 0; //коридор обнаружения гармоники
    let __frq = 200; //граничная частота спектра
    let __lines = 400; //количество линий спектра

    let __filter = bpfFreq(freq); //центральная частота полосового фильтра 
    let __width = bpfWidth(3, __filter); //ширина полосового фильтра для спектра огибающей

    function bpfFreq(rps) {
        let __filter = 1850 * Math.sqrt(rps);
        //let __filter = 6013.41 * Math.log(0.266935 * rps + 1.1201); 
        return __filter;
    };

    function bpfWidth(n, filter) {
        let kf = (2 ** (1 / n) - 1) / ((2 ** (1 / n)) ** 0.5); //коэффициент для полосового фильтра
        let __wdt = kf * filter;
        return __wdt;
    };

    function getStandart(value) {
        let arr = [50, 100, 200, 400, 800, 1600, 3200, 6400, 12800];
        let __res = 0;
        arr.some((elem, i) => { if (value <= elem) { __res = arr[i]; return __res; }; });
        return __res;
    };

    switch (options.objectType) {
        case 0: //объект не выбран
            break;
        case 1: //подшипник скольжения
            __tol = 0;
            __frq = 20 * freq;
            __lines = __frq / (freq / 8);
            break;
        case 2: //подшипник качения
            __tol = (2 * FTF(freq)) / (5 * BPFO(freq));
            __frq = getStandart(5 * BPFI(freq) + 4 * freq);
            __lines = getStandart(__frq / (freq / 8));
            break;
        case 3: //ШВП
            __tol = (2 * BSFTF(freq)) / (5 * BSNUT(freq));
            __frq = getStandart(5 * BSSCR(freq) + 4 * freq);
            __lines = getStandart(__frq / (freq / 8));
            break;
        case 4: //редуктор
            __tol = (2 * freq) / (5 * GTFZ(freq));
            __frq = getStandart(3 * GTFZ(freq) + 4 * freq);
            __lines = getStandart(__frq / (freq / 8));
            break;
        case 5: //ременная передача
            __tol = 0;
            __frq = getStandart(400);
            __lines = getStandart(__frq / (BDFB(freq) / 4));
            break;
        case 6: //зубчатый ремень
            __tol = 0;
            __frq = getStandart(400);
            __lines = getStandart(__frq / (CBDFB(freq) / 4));
            break;
        case 7: //помпа (насос)
            __tol = 0;
            __frq = getStandart(3 * PMFBLD(freq) + 4 * freq);
            __lines = getStandart(__frq / (freq / 8));
            break;
        case 8: //планетарый редуктор
            __tol = (2 * PGF2(freq)) / (5 * PGFZ(freq));
            __frq = getStandart(3 * PGFZ(freq) + 4 * freq);
            __lines = getStandart(__frq / (PGF2(freq) / 8));
            break;
        case 9: //турбина
            __tol = 0;
            __frq = getStandart(3 * TRFBLD(freq) + 4 * freq);
            __lines = getStandart(__frq / (freq / 8));
            break;
        case 10: //электродвигатель
            __tol = 0;
            __frq = getStandart(400);
            __lines = getStandart(__frq / (freq / 8));
            break;
    };

    __fltr["frequency"] = __filter;
    __fltr["width"] = __width;
    __spec["frequency"] = __frq;
    __spec["lines"] = __lines;
    __spec["resolution"] = __frq / __lines;
    __spec["tolerance"] = __tol;

    return {
        filter: __fltr,
        spec: __spec
    };
}; //рассчетные параметры спектра вибрации

export function specSquare(spec, L, R) {
    let base = spec.base; //массив значений средней линии
    let data = spec.data; //массив значений амплитуд
    let lines = spec.data.length; //количества линий спектра 
    let res = spec.resolution; //частотное разрешения спектра (высота прямоугольной трапеции)  
    let peaks = spec.peaks; //массив обнаруженных гармоник (объекты)
    let start = 0; //стартовый индекс в массиве
    let end = lines; //конечный индекс в массиве
    let s0 = 0; //площадь под базовой линией
    let s1 = 0; //площадь всего спектра
    let s2 = 0; //площадь над базовой линией
    let s3 = 0; //площадь обнаруженных гармоник
    if (L != undefined) { start = Math.round(L / res) };
    if (R != undefined) { end = Math.round(R / res) };

    for (let i = start; i <= end - 1; i++) {
        s0 += 0.5 * (base[i] + base[i + 1]) * res;
        s1 += 0.5 * (data[i] + data[i + 1]) * res;
        if ((s1 - s0) >= 0) { s2 += s1 - s0 };
        if (i <= peaks.length - 1) { s3 += res * peaks[i].level };
    };

    return {
        base: s0,
        spec: s1,
        harm: s2,
        peak: s3
    };
}; //определение площадей спектра

export function modFactor(options) {
    let dl = (options.ampl - options.base); //разность уровней гармонической и случайной составляющей вибрации  
    let df = options.spec.frequency / options.fltr.width; //отношение граничной частоты спектра к ширине фильтра 
    let mod = Math.sqrt((10 ** (dl / 10) - 1) * df);
    return mod;
}; //определение глубины модуляции ВЧ составляющих

export function deepFactor(ampl, base) {
    let deep = (ampl - base) / (ampl + base) * 100;
    return deep;
}; //определение условной глубины модуляции

export function amplFactor(ampl, base) {
    let crest = (ampl / base);
    return crest;
}; //определение амплитудного коэффициента