tbf/TBF/UI/Procedures/Formulas.cs

using Common;

namespace TBF.UI.Procedures
{
    public static class Formulas
    {
        public static double GetTargetQ(Config.Entities.PTest ptest, double qN, double qpQiRatio, string metroClass, Medium medium)
        {
            if (ptest.Name.ToLower().Contains("q4") || ptest.Name.ToLower().Contains("qmax"))
            {
                return Formulas.GetQ4Qmax(qN, metroClass, medium, ptest.CoefQto);
            }
            else if (ptest.Name.ToLower().Contains("q3") || ptest.Name.ToLower().Contains("qn") || ptest.Name.ToLower().Equals("qp"))
            {
                return qN;
            }
            else if (ptest.Name.ToLower().Contains("q2") || ptest.Name.ToLower().Contains("qt"))
            {
                return Formulas.GetQ2Qt(qN, metroClass, medium, ptest.CoefQto);
            }
            else if (ptest.Name.ToLower().Contains("q1") || ptest.Name.ToLower().Contains("qmin"))
            {
                return Formulas.GetQ1Qmin(qN, metroClass, medium, ptest.CoefQto);
            }
            else if (ptest.Name.ToLower().Contains("0,1qp") || ptest.Name.ToLower().Contains("0.1qp"))
            {
                return 0.1 * qN;
            }
            else if (ptest.Name.ToLower().Contains("qi"))
            {
                return qN / qpQiRatio;
            }
            else
            {
                return qN;       /// Manual flow selection: CoefQfrom and CoefQto are used to calculate Qfrom and Qto from Qn
            }
        }

        /// <summary>
        /// Get either Q1 or Qmin flow for a given Qn and metrological class
        /// </summary>
        /// <param name="Qn">Nominal flow in m3/h</param>
        /// <param name="metroClass">Metrological class ("A" ,"B", "C" or "R#")</param>
        /// <param name="medium">NotSpecified, ColdWater or HotWater</param>
        /// <param name="Qdflt">Default flow when metrologic does not match pattern</param>
        /// <returns>Q1 or Qmin flow in m3/h</returns>
        public static double GetQ1Qmin(double Qn, string metroClass, Medium medium = Medium.ColdWater, double Qdflt = 0)
        {
            if (string.IsNullOrEmpty(metroClass)) return Qdflt;

            int metroClassRatio;
            if ((metroClass[0] == 'R') && int.TryParse(metroClass.Substring(1), out metroClassRatio) && (metroClassRatio > 0))
            {
                return Qn / (double)metroClassRatio;
            }
            else
            {
                if (medium == Medium.HotWater)
                {
                    switch (metroClass)
                    {
                        case "A": return (Qn < 15) ? (0.04 * Qn) : (0.08 * Qn);
                        case "B": return (Qn < 15) ? (0.02 * Qn) : (0.04 * Qn);
                        case "C": return (Qn < 15) ? (0.01 * Qn) : (0.02 * Qn);
                        case "D": return (Qn < 15) ? (0.01 * Qn) : Qdflt;
                        default: break;
                    }
                }
                else
                {
                    switch (metroClass)
                    {
                        case "A": return (Qn < 15) ? (0.04 * Qn) : (0.08 * Qn);
                        case "B": return (Qn < 15) ? (0.02 * Qn) : (0.03 * Qn);
                        case "C": return (Qn < 15) ? (0.01 * Qn) : (0.006 * Qn);
                        default: break;
                    }
                }
            }

            return Qdflt;
        }

        /// <summary>
        /// Get either Q2 or Qt flow for a given Qn and metrological class
        /// </summary>
        /// <param name="Qn">Nominal flow in m3/h</param>
        /// <param name="metroClass">Metrological class ("A" ,"B", "C" or "R#")</param>
        /// <param name="medium">NotSpecified, ColdWater or HotWater</param>
        /// <param name="Qdflt">Default flow when metrologic does not match pattern</param>
        /// <returns>Q2 or Qt flow in m3/h</returns>
        public static double GetQ2Qt(double Qn, string metroClass, Medium medium = Medium.ColdWater, double Qdflt = 0)
        {
            if (string.IsNullOrEmpty(metroClass)) return Qdflt;

            int metroClassRatio;
            if ((metroClass[0] == 'R') && int.TryParse(metroClass.Substring(1), out metroClassRatio) && (metroClassRatio > 0))
            {
                return 1.6 * Qn / (double)metroClassRatio;
            }

            if (medium == Medium.HotWater)
            {
                switch (metroClass)
                {
                    case "A": return (Qn < 15) ? (0.1 * Qn) : (0.2 * Qn);
                    case "B": return (Qn < 15) ? (0.08 * Qn) : (0.15 * Qn);
                    case "C": return (Qn < 15) ? (0.06 * Qn) : (0.1 * Qn);
                    case "D": return (Qn < 15) ? (0.015 * Qn) : Qdflt;
                    default: break;
                }
            }
            else
            {
                switch (metroClass)
                {
                    case "A": return (Qn < 15) ? (0.1 * Qn) : (0.3 * Qn);
                    case "B": return (Qn < 15) ? (0.08 * Qn) : (0.2 * Qn);
                    case "C": return (Qn < 15) ? (0.015 * Qn) : (0.015 * Qn);
                    default: break;
                }
            }

            return Qdflt;
        }

        /// <summary>
        /// Get either Q4 or Qmax flow for a given Qn and metrological class
        /// </summary>
        /// <param name="Qn">Nominal flow in m3/h</param>
        /// <param name="metroClass">Metrological class ("A" ,"B", "C" or "R#")</param>
        /// <param name="medium">NotSpecified, ColdWater or HotWater</param>
        /// <param name="Qdflt">Default flow when metrologic does not match pattern</param>
        /// <returns>Q4 or Qmax flow in m3/h</returns>
        public static double GetQ4Qmax(double Qn, string metroClass, Medium medium = Medium.ColdWater, double Qdflt = 0)
        {
            if (string.IsNullOrEmpty(metroClass)) return Qdflt;

            switch (metroClass[0])
            {
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                    return 2 * Qn;
                case 'R':
                    return 1.25 * Qn;
                default:
                    return Qdflt;
            }
        }
    }
}