gtld2-diag-scripts/classes/spmClass.js

export class spmClass {
    constructor(args) {
        this.src1 = args.src1;
        this.src2 = args.src2;
        this.frq = args.freq;
        this.d = args.d_inner;
        this.visible = args.visible;
        this.cpt = this.todB(this.src1.values); //переводим значения массива в дБ
        this.max = this.todB(this.src2.values); //переводим значения массива в дБ
    }

    todB(arr, type) {
        let __limit = 3e-4; //пороговое значение
        if (type != undefined) {
            switch (type) {
                case 0: __limit = 1e-6; break;
                case 1: __limit = 1e-9; break;
                case 2: __limit = 1e-12; break;
                default:
                    break;
            };
        };

        return arr.map((item) => (item = 20 * Math.log10(item / __limit)));
    } //перевод линейных величин в дБ

    getdBi(d = this.d, rpm = this.frq * 60) {
        const a = 3.135283064375708;
        const b = 4.999746694992378;
        const k = -58.16048390995372;

        function getLogUnitValue(lin_unit_value, base, k, c) {
            return c * Math.log(lin_unit_value) / Math.log(base) + k;
        };

        function getDLogUnitValue(d) {
            const base = 0.5921510231527015;
            const k = -3.015055963296224;
            const c = -0.9111115009540;
            return getLogUnitValue(d, base, k, c);
        };

        function getRpmLogUnitValue(rpm) {
            const base = 6.69896278136537;
            const k = -0.008927920952982967;
            const c = 3.3041976536011;
            return getLogUnitValue(rpm, base, k, c);
        };

        return a * getDLogUnitValue(d) + b * getRpmLogUnitValue(rpm) + k;
    } //расчет естественного уровня вибрации dBi

    getdBc() {
        return Math.sqrt(this.cpt.reduce((acc, item) => (acc + item ** 2), 0) / this.cpt.length);
    } //вычисляем ковровый уровень (СКЗ) в дБ

    getdBm() {
        return Math.max(...this.max);
    } //вычисляем максимальную амплитуду импульсов в дБ

    getdBn() {
        return this.getdBm() - this.getdBi()
    } //нормализованное значение амплитуды в дБ

    getLR() {
        let __max0 = this.max.slice(0) //делаем копию массива для сортировки
        let __maxSort = __max0.sort((a, b) => (b - a)); //сортируем массив по убыванию
        let __max40 = __maxSort.slice(0, 40); //выделяем 40 первых (максимальных) значений из массива
        return __max40.reduce((acc, item) => (acc + item), 0) / __max40.length;
    } //определяем LR (среднее из 40 импульсов)

    getHR() {
        let __max1000 = this.max.slice(0, this.max.length / 2); //выделяем 1000 значений из массива
        return Math.sqrt(__max1000.reduce((acc, item) => (acc + item ** 2), 0) / __max1000.length); //вычисляем HR (СКЗ) в дБ
    } //вычисляем HR (СКЗ) в дБ

    getWave() {
        let __dBm = this.getdBm();
        let __dBc = this.getdBc();
        let __LR = this.getLR();
        let __HR = this.getHR();
        
        if (this.visible == true) {
            let __canvas = gtl.plots.add("Impulseform");

            __canvas.add({
                color: this.src2.color,
                name: this.src2.name,
                x: this.src2.time,
                y: this.max
            }); //рисуем форму импульсов SPM

            __canvas.add({
                color: 0xFFFF00,
                name: "dBc",
                x: this.src2.time,
                y: this.max.map((item) => (item = __dBc))
            }); //рисуем уровень dBc

            __canvas.add({
                color: 0xFF0000,
                name: "dBm",
                x: this.src2.time,
                y: this.max.map((item) => (item = __dBm))
            }); //рисуем уровень dBm

            __canvas.add({
                color: 0xFFA500,
                name: "HR",
                x: this.src2.time,
                y: this.max.map((item) => (item = __HR))
            }); //рисуем уровень HR

            __canvas.add({
                color: 0xFF00CC,
                name: "LR",
                x: this.src2.time,
                y: this.max.map((item) => (item = __LR))
            }); //рисуем уровень LR
        }

        return {
            dBm: __dBm,
            dBc: __dBc,
            LR: __LR,
            HR: __HR 
        }
    }

    getResult() {
        let __result = {}; //результат
        let __state = "Норма"; //общее состояние 
        let __dBn = this.getdBn();
        let __wav = this.getWave(); //рисуем форму сигнала и получаем пороги

        switch (true) {
            case (__dBn > 20) && (__dBn < 35):
                __state = "Предупреждение";
                break;
            case __dBn >= 35:
                __state = "Опасность";
                break;
            default:
                break;
        };

        __result = {
            dBm: __wav.dBm,
            dBc: __wav.dBc,
            LR: __wav.LR,
            HR: __wav.HR,
            state: __state 
        };

        return __result
    } //оценка общего состояния
}