tbf/TBF/UI/Procedures/Formulas.cs

///
/// Copyright (c) 2023 Sensus Slovensko a.s.
///
using Common;
using Config.Entities;

namespace TBF.UI.Procedures
{
    public static class Formulas
    {
        public static double GetTargetQ(PTest ptest, Medium medium,
                                        double qN, double qpQiRatio, string metroClass,
                                        double qNaux, double qpQiRatioAux, string metroClassAux)
        {
            switch (ptest.FlowId)
            {
                case FlowId.Qdetected:
                case FlowId.Qrise:
                case FlowId.Qfall:

                    return -1.0;    /// Reserved value indicating flow detection

                case FlowId.Q4:
                case FlowId.Qmax:
                case FlowId.Q4Main:
                case FlowId.QmaxMain:

                    return GetQ4Qmax(qN, metroClass, medium, ptest.CoefQto);

                case FlowId.Q4Aux:
                case FlowId.QmaxAux:

                    return GetQ4Qmax(qNaux, metroClassAux, medium, ptest.CoefQto);

                case FlowId.Q3:
                case FlowId.Qn:
                case FlowId.Q3Main:
                case FlowId.QnMain:

                    return qN;

                case FlowId.Q3Aux:
                case FlowId.QnAux:

                    return qNaux;

                case FlowId.Q2:
                case FlowId.Qt:
                case FlowId.Q2Main:
                case FlowId.QtMain:

                    return GetQ2Qt(qN, metroClass, medium, ptest.CoefQto);

                case FlowId.Q2Aux:
                case FlowId.QtAux:

                    return GetQ2Qt(qNaux, metroClassAux, medium, ptest.CoefQto);

                case FlowId.Q1:
                case FlowId.Qmin:
                case FlowId.Q1Main:
                case FlowId.QminMain:

                    return GetQ1Qmin(qN, metroClass, medium, ptest.CoefQto);

                case FlowId.Q1Aux:
                case FlowId.QminAux:

                    return GetQ1Qmin(qNaux, metroClassAux, medium, ptest.CoefQto);

                case FlowId.Qp10:
                case FlowId.Qp10Main:

                    return 0.1 * qN;

                case FlowId.Qp10Aux:

                    return 0.1 * qNaux;

                case FlowId.Qi:
                case FlowId.QiMain:

                    return qN / qpQiRatio;

                case FlowId.QiAux:

                    return qNaux / qpQiRatioAux;

                default:

                    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;
            }
        }
    }
}