Examples with NumericValue com.serotonin.m2m2.rt.dataImage.types.NumericValue used on opensource projects

Example 1 with NumericValue

use of com.serotonin.m2m2.rt.dataImage.types.NumericValue in project ma-core-public by infiniteautomation.

the class AnalogStatisticsQuantizerTest method testNoStartValueOneValuePerPeriod.

@Test
public void testNoStartValueOneValuePerPeriod() throws IOException {
    // Generate data at 12 noon for every day in the period
    NextTimePeriodAdjuster adjuster = new NextTimePeriodAdjuster(TimePeriods.DAYS, 1);
    time = ZonedDateTime.of(2017, 01, 01, 12, 00, 00, 0, zoneId);
    List<IdPointValueTime> data = new ArrayList<>();
    double value = 1.0;
    while (time.toInstant().isBefore(to.toInstant())) {
        data.add(new IdPointValueTime(1, new NumericValue(value), time.toInstant().toEpochMilli()));
        time = (ZonedDateTime) adjuster.adjustInto(time);
    }
    // Reset time to track periods
    time = ZonedDateTime.of(2017, 01, 01, 00, 00, 00, 0, zoneId);
    MutableInt counter = new MutableInt(0);
    BucketCalculator bc = new TimePeriodBucketCalculator(from, to, TimePeriods.DAYS, 1);
    AnalogStatisticsQuantizer quantizer = new AnalogStatisticsQuantizer(bc, new StatisticsGeneratorQuantizerCallback<AnalogStatistics>() {

        @Override
        public void quantizedStatistics(AnalogStatistics statisticsGenerator) throws IOException {
            counter.increment();
            AnalogStatistics stats = (AnalogStatistics) statisticsGenerator;
            // Test periodStart
            Assert.assertEquals(time.toInstant().toEpochMilli(), stats.getPeriodStartTime());
            // Test periiodEnd
            Assert.assertEquals(time.plusDays(1).toInstant().toEpochMilli(), stats.getPeriodEndTime());
            ZonedDateTime sampleTime = time.plusHours(12);
            // Test Minimum
            Assert.assertEquals(1.0, stats.getMinimumValue(), 0.0001);
            // Test Maximum
            Assert.assertEquals(1.0, stats.getMaximumValue(), 0.0001);
            if (counter.getValue() == 1) {
                Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getMinimumTime());
                Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getMaximumTime());
            } else {
                // Period start if there was a start value
                Assert.assertEquals(time.toInstant().toEpochMilli(), (long) stats.getMinimumTime());
                Assert.assertEquals(time.toInstant().toEpochMilli(), (long) stats.getMaximumTime());
            }
            // Test Average
            Assert.assertEquals(1.0d, stats.getAverage(), 0.0001);
            // Test Integral
            if (counter.getValue() == 1) {
                double integral = 1.0d * 12 * 60 * 60;
                Assert.assertEquals(integral, stats.getIntegral(), 0.0001);
            } else {
                // 24Hrs
                double integral = 1.0d * 24 * 60 * 60;
                Assert.assertEquals(integral, stats.getIntegral(), 0.0001);
            }
            // Test sum
            Assert.assertEquals(1.0d, stats.getSum(), 0.0001);
            // Test first
            Assert.assertEquals(1.0d, stats.getFirstValue(), 0.0001);
            Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getFirstTime());
            // Test last
            Assert.assertEquals(1.0d, stats.getLastValue(), 0.0001);
            Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getLastTime());
            // Test start (the first start value will be null
            if (counter.getValue() == 1)
                Assert.assertEquals(null, stats.getStartValue());
            else
                Assert.assertEquals(1.0, stats.getStartValue(), 0.0001);
            // Test count
            Assert.assertEquals(1, stats.getCount());
            // Test delta
            Assert.assertEquals(0.0, stats.getDelta(), 0.0001);
            // Move to next period time
            time = (ZonedDateTime) adjuster.adjustInto(time);
        }
    });
    quantizer.firstValue(null, 0, true);
    for (int count = 0; count < data.size(); count++) quantizer.row(data.get(count), count + 1);
    quantizer.lastValue(data.get(data.size() - 1), data.size() + 1, true);
    quantizer.done();
    Assert.assertEquals(new Integer(31), counter.getValue());
}

Example 2 with NumericValue

use of com.serotonin.m2m2.rt.dataImage.types.NumericValue in project ma-core-public by infiniteautomation.

the class AnalogStatisticsQuantizerTest method testStartValueAtPeriodStartNoPeriodValues.

@Test
public void testStartValueAtPeriodStartNoPeriodValues() throws IOException {
    // Generate data at 12 noon for every day in the period
    NextTimePeriodAdjuster adjuster = new NextTimePeriodAdjuster(TimePeriods.DAYS, 1);
    // Reset time to track periods
    time = ZonedDateTime.of(2017, 01, 01, 00, 00, 00, 0, zoneId);
    MutableInt counter = new MutableInt(0);
    BucketCalculator bc = new TimePeriodBucketCalculator(from, to, TimePeriods.DAYS, 1);
    AnalogStatisticsQuantizer quantizer = new AnalogStatisticsQuantizer(bc, new StatisticsGeneratorQuantizerCallback<AnalogStatistics>() {

        @Override
        public void quantizedStatistics(AnalogStatistics statisticsGenerator) throws IOException {
            counter.increment();
            AnalogStatistics stats = (AnalogStatistics) statisticsGenerator;
            // Test periodStart
            Assert.assertEquals(time.toInstant().toEpochMilli(), stats.getPeriodStartTime());
            // Test periodEnd
            Assert.assertEquals(time.plusDays(1).toInstant().toEpochMilli(), stats.getPeriodEndTime());
            ZonedDateTime sampleTime = time;
            if (counter.getValue() == 1) {
                // Test Minimum
                Assert.assertEquals(1.0, stats.getMinimumValue(), 0.0001);
                Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getMinimumTime());
                // Test Maximum
                Assert.assertEquals(1.0, stats.getMaximumValue(), 0.0001);
                Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getMaximumTime());
                // Test Average
                Assert.assertEquals(1.0d, stats.getAverage(), 0.0001);
                // Test Integral
                // 24Hrs
                double integral = 1.0d * 24 * 60 * 60;
                Assert.assertEquals(integral, stats.getIntegral(), 0.0001);
                // Test sum
                Assert.assertEquals(1.0d, stats.getSum(), 0.0001);
                // Test first
                Assert.assertEquals(1.0d, stats.getFirstValue(), 0.0001);
                Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getFirstTime());
                // Test last
                Assert.assertEquals(1.0d, stats.getLastValue(), 0.0001);
                Assert.assertEquals((long) sampleTime.toInstant().toEpochMilli(), (long) stats.getLastTime());
                // Test start
                Assert.assertEquals(1.0, stats.getStartValue(), 0.0001);
                // Test count
                Assert.assertEquals(1, stats.getCount());
                // Test delta
                Assert.assertEquals(0.0, stats.getDelta(), 0.0001);
            } else {
                // No data in other periods
                // Test Minimum
                Assert.assertEquals(1.0, stats.getMinimumValue(), 0.0001);
                Assert.assertEquals(time.toInstant().toEpochMilli(), (long) stats.getMinimumTime());
                // Test Maximum
                Assert.assertEquals(1.0, stats.getMaximumValue(), 0.0001);
                Assert.assertEquals(time.toInstant().toEpochMilli(), (long) stats.getMaximumTime());
                // Test Average
                Assert.assertEquals(1.0, stats.getAverage(), 0.0001);
                // Test Integral
                double integral = 1.0 * 24 * 60 * 60;
                Assert.assertEquals(integral, stats.getIntegral(), 0.0001);
                // Test sum
                Assert.assertEquals(0.0d, stats.getSum(), 0.0001);
                // Test first
                Assert.assertEquals(null, stats.getFirstValue());
                Assert.assertEquals(null, stats.getFirstTime());
                // Test last
                Assert.assertEquals(null, stats.getLastValue());
                Assert.assertEquals(null, stats.getLastTime());
                // Test start
                Assert.assertEquals(1.0, stats.getStartValue(), 0.0001);
                // Test count
                Assert.assertEquals(0, stats.getCount());
                // Test delta
                Assert.assertEquals(0.0d, stats.getDelta(), 0.0001);
            }
            // Move to next period time
            time = (ZonedDateTime) adjuster.adjustInto(time);
        }
    });
    quantizer.firstValue(new IdPointValueTime(1, new NumericValue(1.0), time.toInstant().toEpochMilli()), 0, false);
    quantizer.done();
    Assert.assertEquals(new Integer(31), counter.getValue());
}

Example 3 with NumericValue

use of com.serotonin.m2m2.rt.dataImage.types.NumericValue in project ma-core-public by infiniteautomation.

the class AnalogStatisticsQuantizerTest method testStartValueAtStartManyValuesPerPeriod.

@Test
public void testStartValueAtStartManyValuesPerPeriod() throws IOException {
    // Generate data at 12 noon for every day in the period
    NextTimePeriodAdjuster adjuster = new NextTimePeriodAdjuster(TimePeriods.DAYS, 1);
    NextTimePeriodAdjuster hourlyAdjuster = new NextTimePeriodAdjuster(TimePeriods.HOURS, 1);
    time = ZonedDateTime.of(2017, 01, 01, 12, 00, 00, 0, zoneId);
    List<IdPointValueTime> data = new ArrayList<>();
    while (time.toInstant().isBefore(to.toInstant())) {
        // Insert 10 values per day
        double value = 1.0;
        ZonedDateTime daily = ZonedDateTime.ofInstant(time.toInstant(), zoneId);
        for (int i = 0; i < 10; i++) {
            data.add(new IdPointValueTime(1, new NumericValue(value), daily.toInstant().toEpochMilli()));
            daily = (ZonedDateTime) hourlyAdjuster.adjustInto(daily);
            value = value + 1.0d;
        }
        time = (ZonedDateTime) adjuster.adjustInto(time);
    }
    // Reset time to track periods
    time = ZonedDateTime.of(2017, 01, 01, 00, 00, 00, 0, zoneId);
    MutableInt counter = new MutableInt(0);
    BucketCalculator bc = new TimePeriodBucketCalculator(from, to, TimePeriods.DAYS, 1);
    AnalogStatisticsQuantizer quantizer = new AnalogStatisticsQuantizer(bc, new StatisticsGeneratorQuantizerCallback<AnalogStatistics>() {

        @Override
        public void quantizedStatistics(AnalogStatistics statisticsGenerator) throws IOException {
            counter.increment();
            AnalogStatistics stats = (AnalogStatistics) statisticsGenerator;
            // Test periodStart
            Assert.assertEquals(time.toInstant().toEpochMilli(), stats.getPeriodStartTime());
            // Test periiodEnd
            Assert.assertEquals(time.plusDays(1).toInstant().toEpochMilli(), stats.getPeriodEndTime());
            // Test Minimum
            if (counter.getValue() == 1) {
                Assert.assertEquals(1.0, stats.getMinimumValue(), 0.0001);
                Assert.assertEquals(time.toInstant().toEpochMilli(), (long) stats.getMinimumTime());
                // Test Maximum
                Assert.assertEquals(10.0, stats.getMaximumValue(), 0.0001);
                Assert.assertEquals(time.plusHours(12).plusHours(9).toInstant().toEpochMilli(), (long) stats.getMaximumTime());
            } else {
                Assert.assertEquals(1.0, stats.getMinimumValue(), 0.0001);
                Assert.assertEquals(time.plusHours(12).toInstant().toEpochMilli(), (long) stats.getMinimumTime());
                // Test Maximum
                Assert.assertEquals(10.0, stats.getMaximumValue(), 0.0001);
                Assert.assertEquals(time.toInstant().toEpochMilli(), (long) stats.getMaximumTime());
            }
            // 1-9 for 1hr each, 10 for 12hrs at the start and 2hrs at the end
            if (counter.getValue() == 1) {
                double integral = 1d * 13 * 60d * 60d + 2d * 60 * 60 + 3d * 60 * 60 + 4d * 60 * 60 + 5d * 60 * 60 + 6d * 60 * 60 + 7d * 60 * 60 + 8d * 60 * 60 + 9d * 60 * 60;
                integral = integral + 10d * 3d * 60 * 60;
                double average = integral / (24d * 60d * 60d);
                Assert.assertEquals(average, stats.getAverage(), 0.0001);
                // Test Integral
                Assert.assertEquals(integral, stats.getIntegral(), 0.0001);
            } else {
                double integral = 1d * 60d * 60d + 2d * 60 * 60 + 3d * 60 * 60 + 4d * 60 * 60 + 5d * 60 * 60 + 6d * 60 * 60 + 7d * 60 * 60 + 8d * 60 * 60 + 9d * 60 * 60;
                integral = integral + 10d * 15d * 60 * 60;
                double average = integral / (24d * 60d * 60d);
                Assert.assertEquals(average, stats.getAverage(), 0.0001);
                // Test Integral
                Assert.assertEquals(integral, stats.getIntegral(), 0.0001);
            }
            // Test sum
            if (counter.getValue() == 1) {
                Assert.assertEquals(56d, stats.getSum(), 0.0001);
                // Test first
                Assert.assertEquals(1.0d, stats.getFirstValue(), 0.0001);
                Assert.assertEquals((long) time.toInstant().toEpochMilli(), (long) stats.getFirstTime());
            } else {
                Assert.assertEquals(55d, stats.getSum(), 0.0001);
                // Test first
                Assert.assertEquals(1.0d, stats.getFirstValue(), 0.0001);
                Assert.assertEquals((long) time.plusHours(12).toInstant().toEpochMilli(), (long) stats.getFirstTime());
            }
            // Test last
            Assert.assertEquals(10.0d, stats.getLastValue(), 0.0001);
            Assert.assertEquals((long) time.plusHours(12).plusHours(9).toInstant().toEpochMilli(), (long) stats.getLastTime());
            if (counter.getValue() == 1) {
                // Test start (the first start value will be null
                Assert.assertEquals(1.0, stats.getStartValue(), 0.0001);
                // Test count
                Assert.assertEquals(11, stats.getCount());
            } else {
                // Test start (the first start value will be null
                Assert.assertEquals(10.0, stats.getStartValue(), 0.0001);
                // Test count
                Assert.assertEquals(10, stats.getCount());
            }
            // Test delta
            if (counter.getValue() == 1) {
                // 1 to 10
                Assert.assertEquals(9.0, stats.getDelta(), 0.0001);
            } else {
                Assert.assertEquals(0.0, stats.getDelta(), 0.0001);
            }
            // Move to next period time
            time = (ZonedDateTime) adjuster.adjustInto(time);
        }
    });
    quantizer.firstValue(new IdPointValueTime(1, new NumericValue(1.0), time.toInstant().toEpochMilli()), 0, false);
    for (int count = 0; count < data.size(); count++) quantizer.row(data.get(count), count + 1);
    quantizer.lastValue(data.get(data.size() - 1), data.size() + 1, true);
    quantizer.done();
    Assert.assertEquals(new Integer(31), counter.getValue());
}

Example 4 with NumericValue

use of com.serotonin.m2m2.rt.dataImage.types.NumericValue in project ma-core-public by infiniteautomation.

the class BaseDwr method setPointImpl.

protected void setPointImpl(DataPointVO point, String valueStr, SetPointSource source) {
    if (point == null)
        return;
    if (valueStr == null)
        Common.runtimeManager.relinquish(point.getId());
    else {
        // Convert the string value into an object.
        DataValue value = DataValue.stringToValue(valueStr, point.getPointLocator().getDataTypeId());
        // do reverse conversion of renderer
        TextRenderer tr = point.getTextRenderer();
        if (point.getPointLocator().getDataTypeId() == DataTypes.NUMERIC && tr instanceof ConvertingRenderer) {
            ConvertingRenderer cr = (ConvertingRenderer) tr;
            UnitConverter converter = cr.getRenderedUnit().getConverterTo(cr.getUnit());
            double convertedValue = converter.convert(value.getDoubleValue());
            value = new NumericValue(convertedValue);
        }
        Common.runtimeManager.setDataPointValue(point.getId(), value, source);
    }
}

Example 5 with NumericValue

use of com.serotonin.m2m2.rt.dataImage.types.NumericValue in project ma-core-public by infiniteautomation.

the class DataPointRT method savePointValue.

private void savePointValue(PointValueTime newValue, SetPointSource source, boolean async, boolean saveToDatabase) {
    // Null values are not very nice, and since they don't have a specific meaning they are hereby ignored.
    if (newValue == null)
        return;
    // Check the data type of the value against that of the locator, just for fun.
    int valueDataType = DataTypes.getDataType(newValue.getValue());
    if (valueDataType != DataTypes.UNKNOWN && valueDataType != vo.getPointLocator().getDataTypeId())
        // to know how it happened, and the stack trace here provides the best information.
        throw new ShouldNeverHappenException("Data type mismatch between new value and point locator: newValue=" + DataTypes.getDataType(newValue.getValue()) + ", locator=" + vo.getPointLocator().getDataTypeId());
    // Check if this value qualifies for discardation.
    if (vo.isDiscardExtremeValues() && DataTypes.getDataType(newValue.getValue()) == DataTypes.NUMERIC) {
        double newd = newValue.getDoubleValue();
        // Discard if NaN
        if (Double.isNaN(newd))
            return;
        if (newd < vo.getDiscardLowLimit() || newd > vo.getDiscardHighLimit())
            // Discard the value
            return;
    }
    if (newValue.getTime() > Common.timer.currentTimeMillis() + SystemSettingsDao.getFutureDateLimit()) {
        // Too far future dated. Toss it. But log a message first.
        LOG.warn("Future dated value detected: pointId=" + vo.getId() + ", value=" + newValue.getValue().toString() + ", type=" + vo.getPointLocator().getDataTypeId() + ", ts=" + newValue.getTime(), new Exception());
        return;
    }
    boolean backdated = pointValue != null && newValue.getTime() < pointValue.getTime();
    // Determine whether the new value qualifies for logging.
    boolean logValue;
    // ... or even saving in the cache.
    boolean saveValue = true;
    switch(vo.getLoggingType()) {
        case DataPointVO.LoggingTypes.ON_CHANGE_INTERVAL:
        case DataPointVO.LoggingTypes.ON_CHANGE:
            if (pointValue == null)
                logValue = true;
            else if (backdated)
                // Backdated. Ignore it
                logValue = false;
            else {
                if (newValue.getValue() instanceof NumericValue) {
                    // Get the new double
                    double newd = newValue.getDoubleValue();
                    // See if the new value is outside of the tolerance.
                    double diff = toleranceOrigin - newd;
                    if (diff < 0)
                        diff = -diff;
                    if (diff > vo.getTolerance()) {
                        toleranceOrigin = newd;
                        logValue = true;
                    } else
                        logValue = false;
                } else if (newValue.getValue() instanceof ImageValue) {
                    logValue = !((ImageValue) newValue.getValue()).equalDigests(((ImageValue) pointValue.getValue()).getDigest());
                } else
                    logValue = !Objects.equals(newValue.getValue(), pointValue.getValue());
            }
            saveValue = logValue;
            break;
        case DataPointVO.LoggingTypes.ALL:
            logValue = true;
            break;
        case DataPointVO.LoggingTypes.ON_TS_CHANGE:
            if (pointValue == null)
                logValue = true;
            else if (backdated)
                // Backdated. Ignore it
                logValue = false;
            else
                logValue = newValue.getTime() != pointValue.getTime();
            saveValue = logValue;
            break;
        case DataPointVO.LoggingTypes.INTERVAL:
            if (!backdated)
                intervalSave(newValue);
        default:
            logValue = false;
    }
    if (!saveToDatabase)
        logValue = false;
    if (saveValue) {
        valueCache.savePointValue(newValue, source, logValue, async);
        if (vo.getLoggingType() == DataPointVO.LoggingTypes.ON_CHANGE_INTERVAL)
            rescheduleChangeInterval(Common.getMillis(vo.getIntervalLoggingPeriodType(), vo.getIntervalLoggingPeriod()));
    }
    // fetch the annotation
    if (source != null) {
        newValue = new AnnotatedPointValueTime(newValue.getValue(), newValue.getTime(), source.getSetPointSourceMessage());
    }
    // Ignore historical values.
    if (pointValue == null || newValue.getTime() >= pointValue.getTime()) {
        PointValueTime oldValue = pointValue;
        pointValue = newValue;
        fireEvents(oldValue, newValue, null, source != null, false, logValue, true, false);
    } else
        fireEvents(null, newValue, null, false, true, logValue, false, false);
}