Example #1
0
        private TimeSeries CreateDischargeTotalTimeSeries(
            Defaults defaults,
            ProcessorConfig processorConfig,
            string identifier)
        {
            var timeSeriesIdentifier = TimeSeriesIdentifierParser.ParseIdentifier(identifier);

            Log.Info($"Creating '{identifier}' ...");

            var parameter = FindExistingParameterByIdentifier(timeSeriesIdentifier.Parameter);
            var unit      = ResolveParameterUnit(defaults.DischargeTotalUnit, processorConfig.DischargeTotalUnit, parameter);
            var location  = FindExistingLocation(timeSeriesIdentifier.Location);

            var response = Client.Provisioning.Post(
                new Aquarius.TimeSeries.Client.ServiceModels.Provisioning.PostReflectedTimeSeries
            {
                LocationUniqueId  = location.UniqueId,
                Parameter         = parameter.ParameterId,
                Unit              = unit,
                Label             = timeSeriesIdentifier.Label,
                InterpolationType = InterpolationType.SucceedingConstant,
                GapTolerance      = DurationExtensions.MaxGapDuration,
                UtcOffset         = location.UtcOffset,
                Method            = DefaultMethodCode,
                Comment           = $"Created automatically by {ExeHelper.ExeNameAndVersion}"
            });

            Log.Info($"Created '{response.Identifier}' ({response.Unit})");

            AddNewTimeSeries(response);

            return(response);
        }
Example #2
0
        private Processor Resolve(Defaults defaults, ProcessorConfig processorConfig)
        {
            var eventIdentifier = !string.IsNullOrEmpty(processorConfig.EventTimeSeries)
                ? processorConfig.EventTimeSeries
                : defaults.EventParameterAndLabel;

            var eventTimeSeries = FindTimeSeries(
                nameof(processorConfig.EventTimeSeries),
                eventIdentifier,
                processorConfig.Location,
                defaults.EventLabel);

            var dischargeIdentifier =
                ResolveDefaultIdentifier(processorConfig.DischargeTimeSeries, DischargeParameterId, defaults.DischargeLabel);

            var dischargeTimeSeries = FindTimeSeries(
                nameof(processorConfig.DischargeTimeSeries),
                dischargeIdentifier,
                processorConfig.Location,
                defaults.DischargeLabel);

            var dischargeTotalIdentifier =
                ResolveDefaultIdentifier(processorConfig.DischargeTotalTimeSeries, DischargeTotalParameterId, defaults.EventLabel);

            var dischargeTotalTimeSeries = FindOrCreateTimeSeries(
                nameof(processorConfig.DischargeTotalTimeSeries),
                dischargeTotalIdentifier,
                processorConfig.Location,
                defaults.EventLabel,
                identifier => CreateDischargeTotalTimeSeries(defaults, processorConfig, identifier));

            var processor = new Processor
            {
                EventTimeSeries          = eventTimeSeries,
                DischargeTimeSeries      = dischargeTimeSeries,
                DischargeTotalTimeSeries = dischargeTotalTimeSeries,
                MinimumEventDuration     = processorConfig.MinimumEventDuration ?? defaults.MinimumEventDuration,
            };

            ThrowIfWrongParameter(DischargeParameterId, nameof(processor.DischargeTimeSeries), processor.DischargeTimeSeries);
            ThrowIfWrongParameter(DischargeTotalParameterId, nameof(processor.DischargeTotalTimeSeries), processor.DischargeTotalTimeSeries);
            ThrowIfWrongTimeSeriesType(TimeSeriesType.Reflected, nameof(processor.DischargeTotalTimeSeries), processor.DischargeTotalTimeSeries);

            DecomposeTimePeriodUnits(VolumeUnitGroup, processor.DischargeTimeSeries);

            // TODO: If no calculations, try to infer them from all the "LabData" timeseries in the location with a mass/volume unit group and a Total equivalent?

            processor.Calculations.AddRange(processorConfig
                                            .Calculations
                                            .Select(calculationConfig => Resolve(defaults, processorConfig.Location, processor, calculationConfig)));

            return(processor);
        }