Esempio n. 1
0
        //Получение данных для записи в архив
        public void Accumulate()
        {
            try
            {
                var forWrite = ArchiveProject.IntervalsForWrite;
                forWrite.Clear();
                var en  = ThreadCalc.PeriodEnd;
                var beg = ThreadCalc.PeriodBegin;
                if (!ThreadCalc.IsPeriodic)
                {
                    SingleInterval = new ArchiveInterval(ThreadCalc.WriteArchiveType, beg, en, ThreadCalc.CalcName);
                    forWrite.Add(SingleInterval);
                }
                else
                {
                    if (IsMoments)
                    {
                        MomentsInterval = new ArchiveInterval(IntervalType.Moments, beg, en, ThreadCalc.CalcName);
                        forWrite.Add(MomentsInterval);
                    }
                    if (IsPeriodic)
                    {
                        BaseInterval = new ArchiveInterval(IntervalType.Base, beg, en, ThreadCalc.CalcName);
                        forWrite.Add(BaseInterval);
                        if (en.Minute == 0)
                        {
                            HourInterval = new ArchiveInterval(IntervalType.Hour, en.AddHours(-1), en, ThreadCalc.CalcName);
                            forWrite.Add(HourInterval);
                        }
                        if (en.Hour == 0 && en.Minute == 0)
                        {
                            DayInterval = new ArchiveInterval(IntervalType.Day, en.AddDays(-1), en, ThreadCalc.CalcName);
                            forWrite.Add(DayInterval);
                        }
                        HasHourValues = false;
                        HasDayValues  = false;
                    }
                    if (IsAbsolute)
                    {
                        AbsoluteInterval = new ArchiveInterval(IntervalType.Absolute, AbsoluteInterval.Begin, en, ThreadCalc.CalcName);
                        forWrite.Add(AbsoluteInterval);
                        if (en.Hour == 0 && en.Minute == 0)
                        {
                            AbsoluteDayInterval = new ArchiveInterval(IntervalType.AbsoluteDay, AbsoluteInterval.Begin, en, ThreadCalc.CalcName);
                            forWrite.Add(AbsoluteDayInterval);
                        }
                        HasAbsoluteValues = false;
                    }
                }
                Procent = 10;

                foreach (var c in ArchiveParams.Values)
                {
                    c.Accumulate();
                }

                if (IsPeriodic)
                {
                    if (!HasHourValues)
                    {
                        forWrite.Remove(HourInterval);
                    }
                    if (!HasDayValues)
                    {
                        forWrite.Remove(DayInterval);
                    }
                }
                if (IsAbsolute && !HasAbsoluteValues)
                {
                    forWrite.Remove(AbsoluteInterval);
                    if (en.Hour == 0 && en.Minute == 0)
                    {
                        forWrite.Remove(AbsoluteDayInterval);
                    }
                }

                if (PrevLastReport != null || PrevManyReport != null)
                {
                    Procent = 70;
                    AddEvent("Обновление списков предыдущих значений");
                    foreach (var p in PrevParams.Values)
                    {
                        p.Accumulate();
                    }
                }
            }
            catch (Exception ex)
            {
                AddEvent("Объем используемой памяти", GC.GetTotalMemory(false).ToString());
                AddError("Ошибка при накоплении", ex);
            }
        }
Esempio n. 2
0
        //Получение уже накопленных данных из архива
        public void ReadArchiveForPeriodic()
        {
            if (!IsPeriodic && !IsAbsolute)
            {
                return;
            }
            AddEvent("Чтение из архива результатов предыдущих расчетов");
            var intervals = ArchiveProject.IntervalsForRead;

            intervals.Clear();
            AbsoluteInterval = null;
            var beg   = ThreadCalc.PeriodBegin;
            var en    = ThreadCalc.PeriodEnd;
            var bhour = beg.AddMinutes(-beg.Minute);
            var bday  = bhour.AddHours(-bhour.Hour);
            var aday  = bday == beg ? bday : bday.AddDays(1);

            //Добавление интервалов для чтения из архива
            if (IsPeriodic)
            {
                if (beg.Minute != 0)
                {
                    intervals.Add(new ArchiveInterval(IntervalType.Base, bhour, beg));
                }
                if (beg.Hour != 0)
                {
                    intervals.Add(new ArchiveInterval(IntervalType.Hour, bday, bhour));
                }
            }
            if (IsAbsolute)
            {
                intervals.Add(new ArchiveInterval(IntervalType.Absolute, Different.MinDate, Different.MaxDate));
                intervals.Add(new ArchiveInterval(IntervalType.AbsoluteDay, bday, aday));
                //Абсолютные отредактированные значения
                if (ThreadCalc.Archive.IsAbsoluteEdited(Code))
                {
                    foreach (var hip in ThreadCalc.Archive.ReadAbsoluteEdit(Code, true).Values)
                    {
                        if (ArchiveParams.ContainsKey(hip.Code))
                        {
                            var ap = ArchiveParams[hip.Code];
                            ap.AbsoluteEditValue = new Moment(ap.ArchiveParam.DataType, hip.Value, hip.Time);
                        }
                    }
                }
            }

            //Чтение из архива
            using (Start(10, 70))
                ThreadCalc.Archive.ReadProject(ArchiveProject);
            foreach (var ap in ArchiveParams.Values)
            {
                ap.FromArchiveParam(beg, en);
            }

            if (IsAbsolute)
            {
                //Определение начала абсолютного интервала
                var abegin = Different.MaxDate;
                foreach (var ap in ArchiveParams.Values)
                {
                    if (ap.AbsoluteValue != null && ap.AbsoluteValue.Time < abegin)
                    {
                        abegin = ap.AbsoluteValue.Time;
                    }
                }
                AbsoluteInterval = new ArchiveInterval(IntervalType.Absolute, abegin != Different.MaxDate ? abegin : beg, beg);
            }
        }