Esempio n. 1
0
        private DischargeActivity CreateDischargeActivity(FieldVisitInfo visit)
        {
            var dischargeActivityFactory = new DischargeActivityFactory(UnitSystem)
            {
                DefaultParty = DataFile.Properties.Operator
            };

            var dischargeActivity = dischargeActivityFactory.CreateDischargeActivity(
                new DateTimeInterval(visit.StartDate, visit.EndDate), UnitConverter.ConvertDischarge(DataFile.Calculations.Discharge));

            dischargeActivity.Comments = DataFile.Properties.Comment;
            dischargeActivity.ActiveUncertaintyType = UncertaintyType.Quantitative;

            _resultsAppender.GetPluginConfigurations().TryGetValue("IsoUncertaintyScalar", out var scalarText);

            if (!double.TryParse(scalarText, out var scalar))
            {
                scalar = 1.0;
            }

            dischargeActivity.QuantitativeUncertainty = scalar * DataFile.Calculations.UncertaintyIso.Overall * 100;

            // ReSharper disable once CompareOfFloatsByEqualityOperator
            if (scalar != 1.0)
            {
                dischargeActivity.QualityAssuranceComments = $"Scaled ISO uncertainty by {scalar}";
            }

            return(dischargeActivity);
        }
        private DischargeActivity CreateDischargeActivityWithSummary(DateTimeInterval observationInterval, UnitSystem unitSystem)
        {
            var factory = new DischargeActivityFactory(unitSystem);

            var dischargeActivity = factory.CreateDischargeActivity(observationInterval, _parsedData.TotalDischarge);

            dischargeActivity.Party = _parsedData.UserId;

            AddGageHeights(dischargeActivity, observationInterval, unitSystem);

            return(dischargeActivity);
        }
        private DischargeActivity CreateDischargeActivityWithSummary(double discharge)
        {
            var factory = new DischargeActivityFactory(Units.MetricUnitSystem);

            var measurementPeriod = GetMeasurementPeriod();
            var dischargeActivity = factory.CreateDischargeActivity(measurementPeriod, discharge);

            dischargeActivity.Comments = _ehsn.DisMeas.dischargeRemark;
            dischargeActivity.Party    = _ehsn.PartyInfo?.party;

            AddMeanGageHeight(dischargeActivity);

            return(dischargeActivity);
        }
        private DischargeActivity CreateDischargeActivityWithSummary(SxSSummary sxsSummary, UnitSystem unitSystem)
        {
            var factory = new DischargeActivityFactory(unitSystem);

            //Discharge summary:
            var measurementPeriod = GetMeasurementPeriod();
            var dischargeActivity = factory.CreateDischargeActivity(measurementPeriod, sxsSummary.Total_Q.AsDouble());

            dischargeActivity.Comments      = sxsSummary.Comments;
            dischargeActivity.Party         = _fieldVisitInfo.Party;
            dischargeActivity.MeasurementId = !string.IsNullOrWhiteSpace(sxsSummary.Meas_No) ? sxsSummary.Meas_No.Trim() : null;

            //Mean gage height:
            AddMeanGageHeight(dischargeActivity, sxsSummary.Stage, unitSystem);

            return(dischargeActivity);
        }
        public override DischargeActivity Create()
        {
            //NOTE: Timestamps are specified as DateTimeOffset, which requires UTC-offset.
            //If field data file timestamps do not include UTC-offset, plugin can create DateTimeOffset objects using location's UTC-offset.
            var startTime = new DateTimeOffset(FieldVisit.StartDate, _location.UtcOffset);
            var endTime   = new DateTimeOffset(FieldVisit.EndDate, _location.UtcOffset);
            var interval  = new DateTimeInterval(startTime, endTime);

            var dischargeSection = GetManualGaugingDischargeSection(interval);

            var factory           = new DischargeActivityFactory(FieldVisit.UnitSystem);
            var dischargeActivity = factory.CreateDischargeActivity(interval, dischargeSection.Discharge.Value);

            Log.Info(
                $"Creating discharge activity from {interval.Start} to {interval.End} with discharge value = {dischargeSection.Discharge.Value}");

            AddGageHeightMeasurements(interval, dischargeActivity);
            dischargeActivity.ChannelMeasurements.Add(dischargeSection);

            return(dischargeActivity);
        }
Esempio n. 6
0
        public DischargeActivity Create()
        {
            //NOTE: Timestamps are specified as DateTimeOffset, which requires UTC-offset.
            //If field data file timestamps do not include UTC-offset, plugin can create DateTimeOffset objects using location's UTC-offset.
            var startTime = new DateTimeOffset(_fieldVisit.StartDate, _location.UtcOffset);
            var endTime   = new DateTimeOffset(_fieldVisit.EndDate, _location.UtcOffset);
            var interval  = new DateTimeInterval(startTime, endTime);

            var factory           = new DischargeActivityFactory(_fieldVisit.UnitSystem);
            var dischargeActivity = factory.CreateDischargeActivity(interval, _fieldVisit.DischargeActivity.Discharge);

            _log.Info(
                $"Creating discharge activity from {interval.Start} to {interval.End} with discharge value = {_fieldVisit.DischargeActivity.Discharge}");

            AddGageHeightMeasurements(interval, dischargeActivity);
            dischargeActivity.Comments      = _fieldVisit.DischargeActivity.Comments;
            dischargeActivity.Party         = _fieldVisit.DischargeActivity.Party;
            dischargeActivity.MeasurementId = _fieldVisit.DischargeActivity.MeasurementId;

            return(dischargeActivity);
        }
Esempio n. 7
0
        private DischargeActivity CreateDischargeActivityWithSummary(Channel channel, UnitSystem unitSystem)
        {
            var factory = new DischargeActivityFactory(unitSystem);

            var totalDischarge = channel.ChannelSummary?.Discharge?.Total?.Value ??
                                 throw new ArgumentException("No total discharge amount provided");

            //Discharge summary:
            var measurementPeriod = GetMeasurementPeriod();
            var dischargeActivity = factory.CreateDischargeActivity(
                measurementPeriod,
                UnitConverter.ConvertDischarge(totalDischarge.AsDouble()));

            dischargeActivity.Comments = string.Join("\n", new[]
            {
                channel.ChannelSummary?.Other?.UserComment?.Value,
                channel.QA?.QRev_Message?.Value,
            }
                                                     .Where(s => !string.IsNullOrWhiteSpace(s))
                                                     .Select(s => s.Trim()));

            return(dischargeActivity);
        }
Esempio n. 8
0
        private DischargeActivity CreateDischargeActivityWithSummary(DischargeMeasurementSummary summary,
                                                                     UnitSystem unitSystem)
        {
            var factory = new DischargeActivityFactory(unitSystem);

            var totalDischarge = summary.Discharge ??
                                 throw new ArgumentException("No total discharge amount provided");

            //Discharge summary:
            var measurementPeriod = GetMeasurementPeriod();
            var dischargeActivity = factory.CreateDischargeActivity(measurementPeriod, totalDischarge);

            dischargeActivity.Comments = string.Join("\n", summary.Notes);
            dischargeActivity.Party    = summary.Operator;

            if (!Config.IgnoreMeasurementId)
            {
                dischargeActivity.MeasurementId = summary.MeasurementNumber;
            }

            dischargeActivity.QuantitativeUncertainty = summary.UncertaintyPercentage;
            dischargeActivity.ActiveUncertaintyType   = dischargeActivity.QuantitativeUncertainty.HasValue
                ? UncertaintyType.Quantitative
                : UncertaintyType.None;

            var notes = new List <string>(summary.DepthSensorNotes);

            if (summary.QualityThresholdNotes.Any())
            {
                if (notes.Any())
                {
                    notes.Add("");
                }

                notes.AddRange(summary.QualityThresholdNotes);
            }

            if (summary.FieldQualityNotes.Any())
            {
                if (notes.Any())
                {
                    notes.Add("");
                }

                notes.AddRange(summary.FieldQualityNotes);
            }

            dischargeActivity.QualityAssuranceComments = string.Join("\n", notes);

            if (!string.IsNullOrEmpty(summary.Quality) && Config.Grades.Any())
            {
                if (!Config.Grades.TryGetValue(summary.Quality, out var gradeText))
                {
                    gradeText = summary.Quality;
                }

                dischargeActivity.MeasurementGrade = int.TryParse(gradeText, out var gradeCode)
                    ? Grade.FromCode(gradeCode)
                    : Grade.FromDisplayName(gradeText);
            }

            AddMeanGageHeight(dischargeActivity, summary.GageStart, FieldVisitInfo.StartDate, unitSystem);
            AddMeanGageHeight(dischargeActivity, summary.GageEnd, FieldVisitInfo.EndDate, unitSystem);

            return(dischargeActivity);
        }