gtld2-diag-scripts/peakVM.js

export function getCorr(src1, src2) {
    let X = 0; //аргумент 1
    let Y = 0; //аргумент 2
    let Z = 0; //аргумент 3
    let __avg1 = src1.reduce((acc, item) => (acc + item)) / src1.length; //среднее значение массива 1
    let __avg2 = src2.reduce((acc, item) => (acc + item)) / src2.length; //среднее значение массива 2

    for (let i = 0; i < arr1.length; i++) {
        X += (src1[i] - __avg1) * (src2[i] - __avg2);
        Y += (src1[i] - __avg1) ** 2;
        Z += (src2[i] - __avg2) ** 2;
    };

    return X / (Math.sqrt(Y) * Math.sqrt(Z));
}; //рассчет корреляции

export function getAutoCorr(options) {
    let result = {}; //результат
    let plot = []; //массив значений корреляции для графика
    let arr = options.src;
    let arr2 = arr.concat(arr); //расширяем массив данных
    let lag = 0.5;
    let X = 0; //аргумент 1
    let Y = 0; //аргумент 2

    if (options.lag <= 0.5) { lag = options.lag } else { lag = 0.5 };
    let T = Math.floor(arr.length * lag); //определяем количество индексов (шагов) для смещения массива
    let avg = arr.reduce((acc, item) => (acc + item)) / arr.length; //среднее значение массива
    Y = arr.reduce((acc, item) => (acc + (item - avg) ** 2), 0); //рассчитываем знаменатель функции

    for (let i = 0; i < T; i++) {
        X = 0;
        for (let j = 0; j < arr.length; j++) { X += (arr[j] - avg) * (arr2[j + i] - avg) };
        plot.push(X / Y); //записываем значение в массив коэффициентов
    }; //смещение массива

    let plot0 = plot.slice(Math.floor(0.01 * plot.length)); //убираем из массива первый 1% значений коэффициента (т.к. в нуле всегда значение 1.0)
    let akf_avg = plot0.reduce((acc, item) => (acc + Math.abs(item)), 0) / plot0.length; //среднее значение коэффициента
    let akf_sqr = plot0.reduce((acc, item) => (acc + item ** 2), 0); //сумма квадратов значений
    let akf_rms = Math.sqrt(akf_sqr / plot0.length); //СКЗ коэффициента 
    let akf_max = Math.max(...plot0); //определяем максимальное значение коэффициента

    result["avg"] = akf_avg;
    result["rms"] = akf_rms;
    result["ampl"] = akf_max;
    result["data"] = plot;

    //отрисовка графика на plot
    if (options.canvas != undefined) {
        options.canvas.add(
            {
                color: options.color,
                name: options.name,
                x: options.time,
                y: plot
            }
        );
    };

    return result;
}; //рассчет автокорреляции

export function getWave(options) {
    let __src = options.src; //источник данных
    let __canvas = options.canvas; //координатная плоскость для отрисовки
    let __allert = 0;
    let __fault = 0;
    if (options.lvl != undefined) {
        __allert = options.lvl;
        __fault = 2 * __allert;
    };

    __canvas.add(
        {
            color: __src.color,
            name: __src.name,
            x: __src.time,
            y: __src.values
        }
    ); //рисуем Waveform

    if (__allert != 0) {
        let __alr = __src.values.map((item) => (item = __allert));
        let __flt = __src.values.map((item) => (item = __fault));

        __canvas.add(
            {
                color: 0xFFFF00,
                name: "allert",
                x: __src.time,
                y: __alr
            }
        ); //рисуем линию предупреждения

        __canvas.add(
            {
                color: 0xFF0000,
                name: "fault",
                x: __src.time,
                y: __flt
            }
        ); //рисуем линию опасности
    };

    return {
        color: __src.color,
        name: __src.name,
        time: __src.time,
        values: __src.values
    }
}; //пиковая форма сигнала

export function getParams(freq) {
    let rpm = freq * 60; //частота в об/мин
    let wdt = 0; //граничная частота ФВЧ
    let frq = 40 * freq; //граничная частота спектра
    let lns = 800; //количество линий спектра
    let avg = 1; //количество усреднений спектра

    switch (true) {
        case rpm <= 700:
            wdt = 500;
            lns = 800;
            break;
        case (rpm > 700) && (rpm <= 1500):
            wdt = 1000;
            lns = 800;
            break;
        case (rpm > 1500) && (rpm <= 3000):
            wdt = 2000;
            lns = 1600;
            break;
        case (rpm > 3000) && (rpm <= 4000):
            wdt = 2000;
            lns = 1600;
        case rpm > 4000:
            wdt = 5000;
            lns = 1600;
        default:
            break;
    };
    return {
        filter: { frequency: wdt },
        spec: {
            frequency: frq,
            lines: lns,
            resolution: frq / lns,
            avg: avg
        }
    };
}; //рассчет параметров спектра

export function getLevels(freq) {
    let rpm = freq * 60; //частота в об/мин 
    let alr = 0; //уровень предупреждения, g
    switch (true) {
        case rpm <= 900:
            alr = 3.0 * (rpm / 900) ** 0.75;
            break;
        case (rpm > 900) && (rpm <= 4000):
            alr = 3.0;
            break;
        case (rpm > 4000) && (rpm <= 10000):
            alr = 3.0 * (rpm / 4000) ** 0.5;
            break;
        case rpm > 10000:
            alr = 5.0;
        default:
            break;
    };
    return alr
}; //рассчет пороговых уровней

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 += __peaks[i].level * __res };
    };

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

export function getPeakVue(options) {
    let wav = options.src; //массив данных пиковой формы
    let crr = options.corr; //результат расчета автокорреляции
    let mech = 0; //механические проблемы
    let lubr = 0; //проблемы со смазкой
    let allert = getLevels(options.freq); //определяем уровень предупреждения, g

    let MaxPK = Math.max(...wav); //максимальное значение амплитуды на пиковой форме, g
    let FaultLevel = 2 * allert; //уровень аварии для пиковой формы (Fault = 2 * Allert)
    let EstPE = Math.sqrt(crr.ampl) * 100; //расчетный процент периодической энергии

    switch (true) {
        case EstPE >= 50:
            mech = EstPE * MaxPK / FaultLevel;
            lubr = (100 - EstPE) * MaxPK / FaultLevel;
            break;
        case (EstPE <= 50) && (EstPE > 30):
            EstPE = EstPE / 2;
            mech = EstPE * MaxPK / FaultLevel;
            lubr = (100 - EstPE) * MaxPK / FaultLevel;
            break;
        case EstPE < 30:
            mech = 0
            lubr = MaxPK / FaultLevel;
            break;
        default:
            break;
    }; //определяем действительный расчетный процент периодической энергии

    return {
        mechBS: mech,
        lubrBS: lubr
    };
}; //оценка состояния методом PeakVue

export function getPeakVuePlus(options) {
    let wav = options.src; //массив данных пиковой формы
    let spc = options.spec; //объект спектра пиковой формы 
    let crr = options.corr; //результат расчета автокорреляции
    let mech = 0; //механические проблемы
    let lubr = 0; //проблемы со смазкой
    let allert = getLevels(options.freq); //определяем уровень предупреждения, g

    let MaxPK = Math.max(...wav); //максимальное значение амплитуды на пиковой форме, g
    let FaultLevel = 2 * allert; //уровень аварии для пиковой формы (Fault = 2 * Allert)
    let EstPE = Math.sqrt(crr.ampl) * 100; //расчетный процент периодической энергии

    /*switch (true) {
        case (EstPE <= 50) && (EstPE > 30):
            EstPE = EstPE / 2;
            break;
        case EstPE < 30:
            EstPE = 0;
            break;
        default:
            break;
    }; //определяем действительный расчетный процент периодической энергии*/

    let GS = MaxPK / FaultLevel; //общая серьезность проблемы 
    let SQpeak = specSquare(spc).peak; //площадь обнаруженных гармонических составляющих
    let SQspec = specSquare(spc).harm; //площадь над базовой линией
    let PE = (SQpeak ** 2 / SQspec ** 2); //доля периодической энергии 
    let NPE = (SQspec ** 2 - SQpeak ** 2) / SQspec ** 2; //доля непериодической энергии

    mech = GS * PE * 100;
    lubr = GS * NPE * 100;

    return {
        mechBS: mech,
        lubrBS: lubr,
        mechInd: mech * 0.8, //нормализованное значение (для индикатора 0-100 единиц)
        lubrInd: lubr * 0.8 //нормализованное значение (для индикатора 0-100 единиц)
    };
}; //оценка состояния методом PeakVuePlus