diff --git a/maskVM.js b/maskVM.js index 343746c..3be6d5b 100644 --- a/maskVM.js +++ b/maskVM.js @@ -1,4 +1,45 @@ -export function specModel(options) { +export function getMask(options) { + let __result = {}; //результат + let __spec = options.spec; //источник данных для построения модели + let __set = options.set; //источник данных для построения портретов дефектов + let __rows = Object.keys(__set); //массив ключей объекта (наименование портретов) + + let __model = specModel( + { + src: __spec, //спектр для построения модели (объект) + tol: options.tol, //коридор обнаружения гармоники, % + color: options.color, //цвет модели в формате HEX + canvas: options.canvas //координатная плоскость для отрисовки + } + ); //рисуем упрощенную модель спектра огибающей + + for (let i = 0; i < __rows.length; i++) { + let __mask_name = __rows[i]; //имена портретов + let __arr = __set[__mask_name]; //массив значений + let __mask = createMask( + { + name: __mask_name, //имя маски дефекта + src1: __model, //модель спектра для анализа (объект) + src2: __spec, //базовый спектр для построения портрета (объект) + filter: options.filter, //полосовой фильтр (для определения разницы амплитуд гармонической и случайной составляющей) + color: __arr[0], //цвет портрета в формате HEX + freq: __arr[1], //функциональная частота, Гц + harms: __arr[2], //кол-во гармоник в портрете, шт + lvl: __arr[3], //глубина модуляции сильного дефекта для портрета, % + tol: options.tol, //коридор обнаружения гармоники на портрете, % + type: __arr[4], //тип портрета (0 - обычный ряд, 1 - четные составляющие) + coef: __arr[5], //коэффициент затухания гармоник портрета: дефект (0.05 - 0.10), износ (0.30 - 0.50) + canvas: options.canvas //координатная плоскость для отрисовки маски + } + ); + if (__mask.corr >= 0.5) { __result[__mask.name] = __mask.corr }; //добавляем данные в результат + gtl.log.info("Вероятность: " + __mask.name, __mask.corr); //выводим корреляцию гармоник в лог + }; + + return __result; +}; //оценка состояния методом maskVM + +function specModel(options) { let __result = {}; //результат let __model = options.src.base; //массив точек базовой линии для построения упрощенной модели спектра let imin = 0; //левая граница коридора @@ -32,7 +73,7 @@ export function specModel(options) { return __result; }; //построение упрощенной модели спектра -export function createMask(options) { +function createMask(options) { let result = {}; //результат let data = options.src1.data; //массив точек спектра для сравнения с портретом let mask = options.src2.base; //массив точек базовой линии для построения портрета дефекта @@ -132,45 +173,4 @@ export function createMask(options) { }; return result; -}; //построение портрета дефекта - -export function getMask(options) { - let __result = {}; //результат - let __spec = options.spec; //источник данных для построения модели - let __set = options.set; //источник данных для построения портретов дефектов - let __rows = Object.keys(__set); //массив ключей объекта (наименование портретов) - - let __model = specModel( - { - src: __spec, //спектр для построения модели (объект) - tol: options.tol, //коридор обнаружения гармоники, % - color: options.color, //цвет модели в формате HEX - canvas: options.canvas //координатная плоскость для отрисовки - } - ); //рисуем упрощенную модель спектра огибающей - - for (let i = 0; i < __rows.length; i++) { - let __mask_name = __rows[i]; //имена портретов - let __arr = __set[__mask_name]; //массив значений - let __mask = createMask( - { - name: __mask_name, //имя маски дефекта - src1: __model, //модель спектра для анализа (объект) - src2: __spec, //базовый спектр для построения портрета (объект) - filter: options.filter, //полосовой фильтр (для определения разницы амплитуд гармонической и случайной составляющей) - color: __arr[0], //цвет портрета в формате HEX - freq: __arr[1], //функциональная частота, Гц - harms: __arr[2], //кол-во гармоник в портрете, шт - lvl: __arr[3], //глубина модуляции сильного дефекта для портрета, % - tol: options.tol, //коридор обнаружения гармоники на портрете, % - type: __arr[4], //тип портрета (0 - обычный ряд, 1 - четные составляющие) - coef: __arr[5], //коэффициент затухания гармоник портрета: дефект (0.05 - 0.10), износ (0.30 - 0.50) - canvas: options.canvas //координатная плоскость для отрисовки маски - } - ); - if (__mask.corr >= 0.5) { __result[__mask.name] = __mask.corr }; //добавляем данные в результат - gtl.log.info("Вероятность: " + __mask.name, __mask.corr); //выводим корреляцию гармоник в лог - }; - - return __result; -}; //оценка состояния методом maskVM \ No newline at end of file +}; //построение портрета дефекта \ No newline at end of file diff --git a/peakClass.js b/peakClass.js new file mode 100644 index 0000000..1e49df1 --- /dev/null +++ b/peakClass.js @@ -0,0 +1,220 @@ +export class peakClass { + constructor(args) { + this.wave = args.src; + this.freq = args.freq; + this.visible = args.visible; + if (args.spec != undefined) { this.spec = args.spec }; + } + + getLevels(rpm = this.freq * 60) { + let __allert = 0; //уровень предупреждения, g + switch (true) { + case rpm <= 900: + __allert = 3.0 * (rpm / 900) ** 0.75; //1.5 => 3.0 для формы Peak-To-Peak + break; + case (rpm > 900) && (rpm <= 4000): + __allert = 3.0; //1.5 => 3.0 для формы Peak-To-Peak + break; + case (rpm > 4000) && (rpm <= 10000): + __allert = 3.0 * (rpm / 4000) ** 0.5; //1.5 => 3.0 для формы Peak-To-Peak + break; + case rpm > 10000: + __allert = 5.0; //3.0 => 5.0 для формы Peak-To-Peak + default: + break; + }; + return __allert + }; //рассчет пороговых уровней + + getParams(rpm = this.freq * 60) { + let __wdt = 0; //граничная частота ФВЧ + let __frq = 40 * this.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 + } + }; + }; //рассчет параметров спектра + + getWave() { + let __allert = this.getLevels(); + let __fault = 2 * __allert; + + if (this.visible == true) { + let __canvas = gtl.plots.add("Waveform"); + let __alr = this.wave.values.map((item) => (item = __allert)); + let __flt = this.wave.values.map((item) => (item = __fault)); + + __canvas.add({ + color: this.wave.color, + name: this.wave.name, + x: this.wave.time, + y: this.wave.values + }); //рисуем форму сигнала + + __canvas.add({ + color: 0xFFFF00, + name: "allert", + x: this.wave.time, + y: __alr + }); //рисуем порог предупреждения + + __canvas.add({ + color: 0xFF0000, + name: "fault", + x: this.wave.time, + y: __flt + }); //рисуем порог опасности + + } + return __allert + } + + getCorr() { + let __plot = []; //массив значений корреляции для графика + let arr = this.wave.values; + let arr2 = arr.concat(arr); //расширяем массив данных + let lag = 0.5; + let X = 0; //аргумент 1 + let Y = 0; //аргумент 2 + + 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 __max = Math.max(...__plot0); //определяем максимальное значение коэффициента + + if (this.visible == true) { + let __canvas = gtl.plots.add("Correlation"); + + __canvas.add({ + color: 0x00A550, + name: "Корреляционная функция", + x: this.wave.time, + y: __plot + }); + }; //отрисовка графика на plot + + return __max; + }; //рассчет автокорреляции + + getSpecSquare() { + if (this.spec != undefined) { + let __base = this.spec.base; //массив значений средней линии + let __data = this.spec.data; //массив значений амплитуд + let __lines = this.spec.data.length; //количества линий спектра + let __res = this.spec.resolution; //частотное разрешения спектра (высота прямоугольной трапеции) + let __start = 0; //стартовый индекс в массиве + let __end = __lines; //конечный индекс в массиве + let s0 = 0; //площадь под базовой линией + let s1 = 0; //площадь всего спектра + let s2 = 0; //площадь над базовой линией + let s3 = 0; //площадь обнаруженных гармоник + + for (let i = __start; i <= __end - 1; i++) { + s0 += __base[i] * __res; + s1 += __data[i] * __res; + let __delta = __data[i] - __base[i]; + if (__delta >= 0) { s2 += __delta * __res }; + if (__delta >= this.spec.peak_level) { s3 += __delta * __res }; + }; + + return { + base: s0, + spec: s1, + harm: s2, + peak: s3 + }; + }; //определение площадей спектра + } + + getResult() { + let __result = {}; //результат + let __mech = 0; //механические проблемы + let __lubr = 0; //проблемы со смазкой + + let __allert = this.getWave(); //рисуем пиковую форму сигнала и получаем порог предупреждения, g + let __corr = this.getCorr(); //вычисляем автокорреляционную функцию (получаем максимум) + + let MaxPK = Math.max(...this.wave.values); //максимальное значение амплитуды на пиковой форме, g + let FaultLevel = 2 * __allert; //уровень аварии для пиковой формы (Fault = 2 * Allert) + let EstPE = Math.sqrt(__corr) * 100; //расчетный процент периодической энергии + + if (this.spec != undefined) { + let GS = MaxPK / FaultLevel; //общая серьезность проблемы + let SQpeak = this.getSpecSquare().peak; //площадь обнаруженных гармонических составляющих + let SQspec = this.getSpecSquare().harm; //площадь над базовой линией + let PE = (SQpeak ** 2 / SQspec ** 2); //доля периодической энергии + let NPE = (SQspec ** 2 - SQpeak ** 2) / SQspec ** 2; //доля непериодической энергии + + __mech = GS * PE * 100; + __lubr = GS * NPE * 100; + + __result = { + mechBS: __mech * 0.8, //нормализованное значение (для индикатора 0-100 единиц) + lubrBS: __lubr * 0.8, //нормализованное значение (для индикатора 0-100 единиц) + }; + } else { + 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; + }; //определяем действительный расчетный процент периодической энергии + + __result = { + mechBS: __mech, + lubrBS: __lubr + }; + }; + + return __result; + }; //оценка состояния методом PeakVM +} \ No newline at end of file diff --git a/peakVM.js b/peakVM.js index 51a63b7..6d2d262 100644 --- a/peakVM.js +++ b/peakVM.js @@ -1,207 +1,3 @@ -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.values; - 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; - - - if (options.canvas != undefined) { - options.canvas.add( - { - color: options.color, - name: options.name, - x: options.src.time, - y: plot - } - ); - }; //отрисовка графика на plot - - return result; -}; //рассчет автокорреляции - -export function getWave(options) { - let __src = options.src; //источник данных - let __allert = 0; - let __fault = 0; - if (options.lvl != undefined) { - __allert = options.lvl; - __fault = 2 * __allert; - }; - - if (options.canvas != undefined) { - options.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)); - - options.canvas.add( - { - color: 0xFFFF00, - name: "allert", - x: __src.time, - y: __alr - } - ); //рисуем линию предупреждения - - options.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 = 1.5 * (rpm / 900) ** 0.75; //1.5 => 3.0 для формы Peak-To-Peak - break; - case (rpm > 900) && (rpm <= 4000): - alr = 1.5; //1.5 => 3.0 для формы Peak-To-Peak - break; - case (rpm > 4000) && (rpm <= 10000): - alr = 1.5 * (rpm / 4000) ** 0.5; //1.5 => 3.0 для формы Peak-To-Peak - break; - case rpm > 10000: - alr = 3.0; //3.0 => 5.0 для формы Peak-To-Peak - 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 __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 += __base[i] * __res; - s1 += __data[i] * __res; - let __delta = __data[i] - __base[i]; - if (__delta >= 0) { s2 += __delta * __res }; - if (__delta >= spec.peak_level) { s3 += __delta * __res }; - }; - - return { - base: s0, - spec: s1, - harm: s2, - peak: s3 - }; -}; //определение площадей спектра - export function getPeak(options) { let __result = {}; //результат let __wav = options.src; //массив данных пиковой формы @@ -276,3 +72,190 @@ export function getPeak(options) { return __result; }; //оценка состояния методом PeakVM + +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; //1.5 => 3.0 для формы Peak-To-Peak + break; + case (rpm > 900) && (rpm <= 4000): + alr = 3.0; //1.5 => 3.0 для формы Peak-To-Peak + break; + case (rpm > 4000) && (rpm <= 10000): + alr = 3.0 * (rpm / 4000) ** 0.5; //1.5 => 3.0 для формы Peak-To-Peak + break; + case rpm > 10000: + alr = 5.0; //3.0 => 5.0 для формы Peak-To-Peak + default: + break; + }; + return alr +}; //рассчет пороговых уровней + +function getWave(options) { + let __src = options.src; //источник данных + let __allert = 0; + let __fault = 0; + if (options.lvl != undefined) { + __allert = options.lvl; + __fault = 2 * __allert; + }; + + if (options.canvas != undefined) { + options.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)); + + options.canvas.add( + { + color: 0xFFFF00, + name: "allert", + x: __src.time, + y: __alr + } + ); //рисуем линию предупреждения + + options.canvas.add( + { + color: 0xFF0000, + name: "fault", + x: __src.time, + y: __flt + } + ); //рисуем линию опасности + }; + }; + + return { + color: __src.color, + name: __src.name, + time: __src.time, + values: __src.values + } +}; //пиковая форма сигнала + +function getAutoCorr(options) { + let result = {}; //результат + let plot = []; //массив значений корреляции для графика + let arr = options.src.values; + 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; + + if (options.canvas != undefined) { + options.canvas.add( + { + color: options.color, + name: options.name, + x: options.src.time, + y: plot + } + ); + }; //отрисовка графика на plot + + return result; +}; //рассчет автокорреляции + +function specSquare(spec, L, R) { + let __base = spec.base; //массив значений средней линии + let __data = spec.data; //массив значений амплитуд + let __lines = spec.data.length; //количества линий спектра + let __res = spec.resolution; //частотное разрешения спектра (высота прямоугольной трапеции) + 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 += __base[i] * __res; + s1 += __data[i] * __res; + let __delta = __data[i] - __base[i]; + if (__delta >= 0) { s2 += __delta * __res }; + if (__delta >= spec.peak_level) { s3 += __delta * __res }; + }; + + return { + base: s0, + spec: s1, + harm: s2, + peak: s3 + }; +}; //определение площадей спектра \ No newline at end of file diff --git a/spmClass.js b/spmClass.js new file mode 100644 index 0000000..b52b94c --- /dev/null +++ b/spmClass.js @@ -0,0 +1,157 @@ +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 + } //оценка общего состояния +} \ No newline at end of file diff --git a/spmVM.js b/spmVM.js index 15bfe81..27014ee 100644 --- a/spmVM.js +++ b/spmVM.js @@ -1,45 +1,3 @@ -export function getdBi(d, rpm) { - 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 - -export function 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; - }; - }; - - let __result = arr.map((item) => (item = 20 * Math.log10(item / __limit))); - return __result; -}; //перевод значений массива в дБ - export function getSpm(args) { let __src1 = args.src1.values; //массив данных амплитуд импульсов для расчета коврового уровня let __src2 = args.src2.values; //массив данных амплитуд импульсов для определения максимума @@ -131,3 +89,45 @@ export function getSpm(args) { return __result; }; //оценка состояния методом spmVM + +function 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; + }; + }; + + let __result = arr.map((item) => (item = 20 * Math.log10(item / __limit))); + return __result; +}; //перевод значений массива в дБ + +function getdBi(d, rpm) { + 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 \ No newline at end of file diff --git a/userFunctions.js b/userFunctions.js index 870448e..6b02915 100644 --- a/userFunctions.js +++ b/userFunctions.js @@ -449,14 +449,9 @@ export function getStdMeasures(options) { }; //получение амплитуды function getPtP(src) { - let __ptp = gtl.create_moving_peak_to_peak( - { - src: src, - name: "peak_to_peak", - time: __time - } - ); - __ptp.history = __time * __avg; + let __ptp = gtl.add_value_peak_to_peak(src); + __ptp.time = __time; + __ptp.avg_cnt = __avg; return __ptp; }; //получение размаха