Defines a rainfall event for use in the hydrology calculations
Exemple #1
0
        /// <summary>
        /// Performs the SBUH calculations for the Twentyfive-year storm event
        /// </summary>
        /// <param name="catchment">A Catchment object</param>
        /// <returns>A Hydrograph object containing the results of the SBUH calculations</returns>
        public static Hydrograph CalculateSbuh25Year(Catchment catchment)
        {
            //Define design storms
            RainfallEvent rainfallEvent = RainfallEvent.GetScsOneAEvent("Twentyfive-Year", 3.9);

            Hydrograph imperviousHydrograph = SantaBarbaraUrbanHydrograph.CalculateHydrograph
                                                  (catchment, rainfallEvent);

            return(imperviousHydrograph);
        }
Exemple #2
0
        /// <summary>
        /// Performs the SBUH calculations for the Pollution Reduction storm event
        /// </summary>
        /// <param name="catchment">A Catchment object</param>
        /// <returns>A Hydrograph object containing the results of the SBUH calculations</returns>
        public static Hydrograph CalculateSbuhPr(Catchment catchment)
        {
            //Define design storms
            RainfallEvent pollutionReduction = RainfallEvent.GetScsOneAEvent("Pollution Reduction", 0.83);

            Hydrograph imperviousHydrographPR = SantaBarbaraUrbanHydrograph.CalculateHydrograph
                                                    (catchment, pollutionReduction);

            return(imperviousHydrographPR);
        }
        /// <summary>
        /// Performs SBUH calculations for a Catchment
        /// </summary>
        /// <param name="catchment"></param>
        /// <param name="rainfallEvent"></param>
        /// <returns></returns>
        public static Hydrograph CalculateHydrograph(Catchment catchment, RainfallEvent rainfallEvent)
        {
            double A  = catchment.ImperviousAreaSquareFeet / 43560;
            double dt = rainfallEvent.TimeIntervalMinutes;
            double Tc = catchment.TimeOfConcentrationMinutes;
            double CN = catchment.CurveNumber;

            double omega = dt / (2 * Tc + dt);
            double S     = (1000 / CN) - 10;


            IList <double> accumulatedRainfall = rainfallEvent.RainfallInches.Accumulate();
            IList <double> accumulatedRunoff   = new List <double>().Initialize(rainfallEvent.Length);


            for (int i = 0; i < rainfallEvent.Length; i++)
            {
                if (accumulatedRainfall[i] < 0.2 * S)
                {
                    accumulatedRunoff[i] = 0;
                }
                else
                {
                    accumulatedRunoff[i] = Math.Pow(accumulatedRainfall[i] - 0.2 * S, 2)
                                           / (accumulatedRainfall[i] + 0.8 * S);
                }
            }

            IList <double> incrementalRunoff = accumulatedRunoff.Deaccumulate();

            IList <double> instantaneousHydrograph = incrementalRunoff.Select(p => p * 60.5 * A / dt).ToList();

            IList <double> designHydrograph = new List <double>().Initialize(rainfallEvent.Length);

            for (int i = 1; i < rainfallEvent.Length - 1; i++)
            {
                designHydrograph[i] = designHydrograph[i - 1] + omega * (instantaneousHydrograph[i] + instantaneousHydrograph[i - 1] - 2 * designHydrograph[i - 1]);
            }

            string name = string.Format("{0} {1}", catchment.Name, rainfallEvent.EventName);

            return(new Hydrograph(name, "cfs", designHydrograph, dt));
        }
        /// <summary>
        /// Performs SBUH calculations for a Catchment
        /// </summary>
        /// <param name="catchment"></param>
        /// <param name="rainfallEvent"></param>
        /// <returns></returns>
        public static Hydrograph CalculateHydrograph(Catchment catchment, RainfallEvent rainfallEvent)
        {
            double A = catchment.ImperviousAreaSquareFeet / 43560;
              double dt = rainfallEvent.TimeIntervalMinutes;
              double Tc = catchment.TimeOfConcentrationMinutes;
              double CN = catchment.CurveNumber;

              double omega = dt / (2 * Tc + dt);
              double S = (1000 / CN) - 10;

              IList<double> accumulatedRainfall = rainfallEvent.RainfallInches.Accumulate();
              IList<double> accumulatedRunoff = new List<double>().Initialize(rainfallEvent.Length);

              for (int i = 0; i < rainfallEvent.Length; i++)
              {
            if (accumulatedRainfall[i] < 0.2 * S)
              accumulatedRunoff[i] = 0;
            else
              accumulatedRunoff[i] = Math.Pow(accumulatedRainfall[i] - 0.2 * S, 2)
            / (accumulatedRainfall[i] + 0.8 * S);
              }

              IList<double> incrementalRunoff = accumulatedRunoff.Deaccumulate();

              IList<double> instantaneousHydrograph = incrementalRunoff.Select(p => p * 60.5 * A / dt).ToList();

              IList<double> designHydrograph = new List<double>().Initialize(rainfallEvent.Length);

              for (int i = 1; i < rainfallEvent.Length - 1; i++)
              {
            designHydrograph[i] = designHydrograph[i-1] + omega*(instantaneousHydrograph[i] + instantaneousHydrograph[i-1]-2*designHydrograph[i-1]);
              }

              string name = string.Format("{0} {1}", catchment.Name, rainfallEvent.EventName);
              return new Hydrograph(name, "cfs", designHydrograph, dt);
        }
Exemple #5
0
        /// <summary>
        /// Executes the calculator and returns a PacResults.
        /// </summary>
        /// <param name="catchment">A catchment object defining the hydrologic parameters of the post-developed catchment area to be evaluated.</param>
        /// <param name="preCatchment">A catchment object defining the hydrologic parameters of the pre-developed catchment area to be evaluated.</param>
        /// <param name="facility">A Facility object defining the stormwater management facility to be evaluated.</param>
        /// <param name="category">Identifies the HierarchyCategory the proposed facility will be evaluated against.</param>
        /// <param name="dischargePoint">Identifies the DischargePoint of the proposed facility.</param>
        /// <returns>A PacResults object containing the results of the calculation.</returns>
        internal static PacResults PerformCalculations(Catchment catchment, Catchment preCatchment, Facility facility, HierarchyCategory category, DischargePoint dischargePoint)
        {
            //Define design storms
            RainfallEvent pollutionReduction = RainfallEvent.GetScsOneAEvent("Pollution Reduction", 0.83);
            RainfallEvent twoYear            = RainfallEvent.GetScsOneAEvent("Two-Year", 2.4);
            RainfallEvent fiveYear           = RainfallEvent.GetScsOneAEvent("Five-Year", 2.9);
            RainfallEvent tenYear            = RainfallEvent.GetScsOneAEvent("Ten-Year", 3.4);
            RainfallEvent twentyFiveYear     = RainfallEvent.GetScsOneAEvent("Twentyfive-Year", 3.9);

            PacResults results = new PacResults();

            //Calculate hydrographs for the most important design storms
            Hydrograph imperviousHydrographPR = SantaBarbaraUrbanHydrograph.CalculateHydrograph
                                                    (catchment, pollutionReduction);
            Hydrograph imperviousHydrographTwoYear = SantaBarbaraUrbanHydrograph.CalculateHydrograph
                                                         (catchment, twoYear);
            Hydrograph imperviousHydrographFiveYear = SantaBarbaraUrbanHydrograph.CalculateHydrograph
                                                          (catchment, fiveYear);
            Hydrograph imperviousHydrographTenYear = SantaBarbaraUrbanHydrograph.CalculateHydrograph
                                                         (catchment, tenYear);
            Hydrograph imperviousHydrographTwentyfiveYear = SantaBarbaraUrbanHydrograph.CalculateHydrograph
                                                                (catchment, twentyFiveYear);

            results.PollutionReductionResults =
                ReservoirRouter.PerformCalculations(facility, category, catchment, imperviousHydrographPR);
            results.PollutionReductionPeakOverflow        = results.PollutionReductionResults.PeakOverflow;
            results.PollutionReductionTotalOverflowVolume = results.PollutionReductionResults.OverflowVolume;
            results.PollutionReductionSurfaceCapacity     = results.PollutionReductionResults.PercentSurfaceCapacityUsed;
            results.PollutionReductionPercentRockCapacity = results.PollutionReductionResults.PercentRockCapacityUsed;

            results.PollutionReductionInflowVolume = results.PollutionReductionResults.InflowVolume;
            results.PollutionReductionPeakInflow   = results.PollutionReductionResults.PeakInflowRate;

            results.TwoYearResults =
                ReservoirRouter.PerformCalculations(facility, category, catchment, imperviousHydrographTwoYear);
            results.TwoYearPeakOverflow        = results.TwoYearResults.PeakOverflow;
            results.TwoYearTotalOverflowVolume = results.TwoYearResults.OverflowVolume;

            results.TwoYearInflowVolume = results.TwoYearResults.InflowVolume;
            results.TwoYearPeakInflow   = results.TwoYearResults.PeakInflowRate;

            results.FiveYearResults =
                ReservoirRouter.PerformCalculations(facility, category, catchment, imperviousHydrographFiveYear);
            results.FiveYearPeakOverflow        = results.FiveYearResults.PeakOverflow;
            results.FiveYearTotalOverflowVolume = results.FiveYearResults.OverflowVolume;

            results.FiveYearInflowVolume = results.FiveYearResults.InflowVolume;
            results.FiveYearPeakInflow   = results.FiveYearResults.PeakInflowRate;

            results.TenYearResults =
                ReservoirRouter.PerformCalculations(facility, category, catchment, imperviousHydrographTenYear);
            results.TenYearPeakOverflow        = results.TenYearResults.PeakOverflow;
            results.TenYearTotalOverflowVolume = results.TenYearResults.OverflowVolume;
            results.TenYearSurfaceCapacity     = results.TenYearResults.PercentSurfaceCapacityUsed;
            results.TenYearPercentRockCapacity = results.TenYearResults.PercentRockCapacityUsed;

            results.TenYearInflowVolume = results.TenYearResults.InflowVolume;
            results.TenYearPeakInflow   = results.TenYearResults.PeakInflowRate;

            results.TwentyfiveYearResults =
                ReservoirRouter.PerformCalculations(facility, category, catchment, imperviousHydrographTwentyfiveYear);
            results.TwentyfiveYearPeakOverflow        = results.TwentyfiveYearResults.PeakOverflow;
            results.TwentyfiveYearTotalOverflowVolume = results.TwentyfiveYearResults.OverflowVolume;

            results.TwentyfiveYearInflowVolume = results.TwentyfiveYearResults.InflowVolume;
            results.TwentyfiveYearPeakInflow   = results.TwentyfiveYearResults.PeakInflowRate;

            results.TenYearScore                   = PacScore.NotUsed; // Defaults
            results.FlowControlScore               = PacScore.NotUsed;
            results.TwoYearFlowControlScore        = PacScore.NotUsed;
            results.FiveYearFlowControlScore       = PacScore.NotUsed;
            results.TenYearFlowControlScore        = PacScore.NotUsed;
            results.TwentyfiveYearFlowControlScore = PacScore.NotUsed;

            switch (category)
            {
            case HierarchyCategory.Category1:
            case HierarchyCategory.Category2:
                results.TenYearScore = results.TenYearPeakOverflow > 0 ? PacScore.Fail : PacScore.Pass;
                break;

            case HierarchyCategory.Category3:
                //Define preliminary catchment runoff results
                results.PreDevelopedTwoYearPeakInflow        = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, twoYear)).PeakInflowRate;
                results.PreDevelopedFiveYearPeakInflow       = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, fiveYear)).PeakInflowRate;
                results.PreDevelopedTenYearPeakInflow        = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, tenYear)).PeakInflowRate;
                results.PreDevelopedTwentyfiveYearPeakInflow = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, twentyFiveYear)).PeakInflowRate;

                switch (dischargePoint)
                {
                case DischargePoint.A:
                    results.FlowControlScore = PacScore.NotUsed;
                    break;

                case DischargePoint.B:
                    if (results.TwoYearPeakOverflow <= results.PreDevelopedTwoYearPeakInflow / 2)
                    {
                        results.TwoYearFlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.TwoYearFlowControlScore = PacScore.Fail;
                    }
                    if (results.FiveYearPeakOverflow <= results.PreDevelopedFiveYearPeakInflow)
                    {
                        results.FiveYearFlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.FiveYearFlowControlScore = PacScore.Fail;
                    }
                    if (results.TenYearPeakOverflow <= results.PreDevelopedTenYearPeakInflow)
                    {
                        results.TenYearFlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.TenYearFlowControlScore = PacScore.Fail;
                    }
                    if (results.TwentyfiveYearPeakOverflow <= results.PreDevelopedTwentyfiveYearPeakInflow)
                    {
                        results.TwentyfiveYearFlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.TwentyfiveYearFlowControlScore = PacScore.Fail;
                    }
                    if (results.TwoYearPeakOverflow <= results.PreDevelopedTwoYearPeakInflow / 2 &&
                        results.FiveYearPeakOverflow <= results.PreDevelopedFiveYearPeakInflow &&
                        results.TenYearPeakOverflow <= results.PreDevelopedTenYearPeakInflow &&
                        results.TwentyfiveYearPeakOverflow <= results.PreDevelopedTwentyfiveYearPeakInflow)
                    {
                        results.FlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.FlowControlScore = PacScore.Fail;
                    }
                    break;

                case DischargePoint.C:
                    if (results.TwoYearPeakOverflow <= results.PreDevelopedTwoYearPeakInflow)
                    {
                        results.TwoYearFlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.TwoYearFlowControlScore = PacScore.Fail;
                    }
                    if (results.FiveYearPeakOverflow <= results.PreDevelopedFiveYearPeakInflow)
                    {
                        results.FiveYearFlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.FiveYearFlowControlScore = PacScore.Fail;
                    }
                    if (results.TenYearPeakOverflow <= results.PreDevelopedTenYearPeakInflow)
                    {
                        results.TenYearFlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.TenYearFlowControlScore = PacScore.Fail;
                    }

                    if (results.TwoYearPeakOverflow <= results.PreDevelopedTwoYearPeakInflow &&
                        results.FiveYearPeakOverflow <= results.PreDevelopedFiveYearPeakInflow &&
                        results.TenYearPeakOverflow <= results.PreDevelopedTenYearPeakInflow)
                    {
                        results.FlowControlScore = PacScore.Pass;
                    }
                    else
                    {
                        results.FlowControlScore = PacScore.Fail;
                    }
                    break;

                default:
                    break;
                }
                break;

            case HierarchyCategory.Category4:
                //Define preliminary catchment runoff results
                results.PreDevelopedTwoYearPeakInflow        = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, twoYear)).PeakInflowRate;
                results.PreDevelopedFiveYearPeakInflow       = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, fiveYear)).PeakInflowRate;
                results.PreDevelopedTenYearPeakInflow        = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, tenYear)).PeakInflowRate;
                results.PreDevelopedTwentyfiveYearPeakInflow = ReservoirRouter.PerformCalculations(facility, category, preCatchment, SantaBarbaraUrbanHydrograph.CalculateHydrograph(preCatchment, twentyFiveYear)).PeakInflowRate;
                if (results.TwentyfiveYearPeakOverflow <= results.PreDevelopedTenYearPeakInflow)
                {
                    results.FlowControlScore = PacScore.Pass;
                    results.TwentyfiveYearFlowControlScore = PacScore.Pass;
                }
                else
                {
                    results.FlowControlScore = PacScore.Fail;
                    results.TwentyfiveYearFlowControlScore = PacScore.Fail;
                }
                break;

            default:
                break;
            }

            results.PollutionReductionScore = results.PollutionReductionResults.PeakSurfaceOverflow > 0 ?
                                              PacScore.Fail : PacScore.Pass;

            return(results);
        }