Esempio n. 1
0
        private async Task FetchMeasurementsAsync(DateTime Hour)
        {
            // Discard all old data.
            hourData = new Dictionary <DateTime, List <Measurement> >();

            // Determine where to stop.
            var endHour = Hour.AddHours(PrefetchSize);

            if (endHour > CacheEnd)
            {
                endHour = CacheEnd;
            }

            // Initialize the hour data cache.
            for (DateTime i = Hour; i < endHour; i = i.AddHours(1))
            {
                hourData[i] = new List <Measurement>();
            }

            // Fetch raw data.
            var measurements = await Database.GetRawMeasurementsAsync(SensorId, Hour, endHour);

            // Insert data into cache.
            foreach (var item in measurements)
            {
                var hour = MeasurementAggregation.Quantize(item.Time, TimeSpan.FromHours(1));
                hourData[hour].Add(item);
            }
        }
Esempio n. 2
0
        private async Task <IEnumerable <Measurement> > GetMeasurementsAsync(FrozenPeriod Period)
        {
            const int MinutesPerHour = 60;

            switch (Period.Compaction)
            {
            case CompactionLevel.DayAverages:
            case CompactionLevel.HourAverages:
            case CompactionLevel.Measurements:
                // We'll re-create measurement data by replicating
                // hour-average data.
                var results = await GetHourAveragesAsync(
                    MeasurementAggregation.Quantize(Period.StartTime, TimeSpan.FromHours(1)),
                    (int)Math.Ceiling(Period.Duration.TotalHours));

                return(ReplicateEach(results, Period.StartTime, Period.EndTime, TimeSpan.FromMinutes(1), MinutesPerHour).ToArray());

            case CompactionLevel.None:
            default:
                // We can just fetch real measurements from the database.
                return(await Database.GetRawMeasurementsAsync(SensorId, Period.StartTime, Period.EndTime));
            }
        }
Esempio n. 3
0
        private async Task <IEnumerable <Measurement> > GetHourAveragesAsync(FrozenPeriod Period)
        {
            const int HoursPerDay = 24;

            switch (Period.Compaction)
            {
            case CompactionLevel.DayAverages:
            case CompactionLevel.HourAverages:
                // We'll re-create hour-average data by replicating
                // day-average data.
                var results = await GetDayAveragesAsync(
                    MeasurementAggregation.Quantize(Period.StartTime, TimeSpan.FromDays(1)),
                    (int)Math.Ceiling(Period.Duration.TotalDays));

                return(ReplicateEach(results, Period.StartTime, Period.EndTime, TimeSpan.FromHours(1), HoursPerDay).ToArray());

            case CompactionLevel.Measurements:
            case CompactionLevel.None:
            default:
                // We can just fetch or create "real" hour-average data.
                return(await GetRealHourAveragesAsync(Period.StartTime, (int)Period.Duration.TotalHours));
            }
        }