public bool CalculateDemandCurve(bool isElevation, bool showUserApproach, out string errorMessage)
        {
            try
            {
                DemandCurveData = new DemandCurveData(IsInternationalSystemOfUnits_IS);

                if (!FillDemandCurveData(isElevation, showUserApproach, out errorMessage))
                {
                    return(false);
                }

                if (!DemandCurveCalculationLibrary.DemandCurveCalculation(isElevation, showUserApproach, DemandCurveData, out errorMessage))
                {
                    return(false);
                }

                // output data in DemandCurveOutputData
                DemandCurveOutputData.NameValueUnitsDataTable.DataTable.Clear();

                //data.BarometricPressure = truncit(data.BarometricPressure, 5);
                DemandCurveOutputData.NameValueUnitsDataTable.AddRow("KaV/L", DemandCurveData.KaV_L.ToString("F5"), string.Empty);

                return(true);
            }
            catch (Exception exception)
            {
                errorMessage = string.Format("Error in Demand Curve calculation. Please check your input values. Exception Message: {0}", exception.Message);
                return(false);
            }
        }
Example #2
0
        public bool FillDemandCurveData(DemandCurveData data, bool isElevation, bool showUserApproach, out string errorMessage)
        {
            errorMessage = string.Empty;

            if (MinimumDataValue.Current >= MaximumDataValue.Current)
            {
                errorMessage = "Minimum value must be less than the Maximum value";
                return(false);
            }

            data.CurveC1            = C1DataValue.Current;
            data.CurveC2            = SlopeDataValue.Current;
            data.LiquidToGasRatio   = LiquidToGasRatioDataValue.Current;
            data.Elevation          = ElevationDataValue.Current;
            data.LiquidToGasRatio   = LiquidToGasRatioDataValue.Current;
            data.BarometricPressure = BarometricPressureDataValue.Current;
            data.KaV_L              = BarometricPressureDataValue.Current;
            data.CurveMinimum       = MinimumDataValue.Current;
            data.CurveMaximum       = MaximumDataValue.Current;
            data.WetBulbTemperature = WetBulbTemperatureDataValue.Current;
            data.Range              = RangeDataValue.Current;
            data.Approach           = ApproachDataValue.Current;

            return(true);
        }
        void CalculateApproach(DemandCurveData data)
        {
            MerkelData merkelData = new MerkelData()
            {
                WetBulbTemperature = data.WetBulbTemperature,
                Range            = data.Range,
                Elevation        = data.Elevation,
                LiquidToGasRatio = data.LiquidToGasRatio
            };

            if ((data.LiquidToGasRatio >= 0.1) && (data.LiquidToGasRatio <= 5.0))
            {
                if (data.CurveC1 != 0.0 && data.CurveC2 != 0.0)
                {
                    data.KaV_L    = Math.Round((data.CurveC1 * Math.Pow(data.LiquidToGasRatio, data.CurveC2)), 5, MidpointRounding.ToEven);
                    data.Approach = GetExactApproach(merkelData);

                    if ((data.KaV_L < .01) || (data.KaV_L > 5.0))
                    {
                        data.KaV_L    = 0.0;
                        data.Approach = 0;
                    }

                    if (data.TargetApproach >= 100)
                    {
                        data.Approach = 0;
                    }

                    if (!data.IsInternationalSystemOfUnits_IS_)
                    {
                        data.Approach *= 5.0 / 9.0;
                    }
                }
            }
        }
 public DemandCurveViewModel(bool isDemo, bool isInternationalSystemOfUnits_IS_)
 {
     DemandCurveInputData            = new DemandCurveInputData(isDemo, isInternationalSystemOfUnits_IS_);
     DemandCurveOutputData           = new DemandCurveOutputData(isInternationalSystemOfUnits_IS_);
     DemandCurveData                 = new DemandCurveData(isInternationalSystemOfUnits_IS_);
     DemandCurveCalculationLibrary   = new DemandCurveCalculationLibrary();
     IsInternationalSystemOfUnits_IS = isInternationalSystemOfUnits_IS_;
     IsDemo = isDemo;
 }
        public bool DemandCurveCalculation(bool isElevation, bool showUserApproach, DemandCurveData data, out string errorMessage)
        {
            errorMessage = string.Empty;

            data.TargetApproach = 0;
            data.UserApproach   = 0;

            //ApproachXValues = new List<double>();
            ApproachInRange    = new List <bool>();
            ApproachOutOfRange = new List <bool>();

            data.DataTable.Clear();

            InitializeApproachList(data);

            for (int i = 0; i < InitialApproachXValues.Length; i++)
            {
                if (ApproachInRange[i])
                {
                    DataColumn dataColumn = new DataColumn();
                    dataColumn.ColumnName = string.Format("L/G-{0}", InitialApproachXValues[i]);
                    dataColumn.DataType   = Type.GetType("System.Double");
                    data.DataTable.Columns.Add(dataColumn);
                    dataColumn            = new DataColumn();
                    dataColumn.ColumnName = string.Format("kaVL-{0}", InitialApproachXValues[i]);
                    dataColumn.DataType   = Type.GetType("System.Double");
                    data.DataTable.Columns.Add(dataColumn);
                }
            }

            if ((data.CurveC1 != 0) && (data.CurveC2 != 0))
            {
                DataColumn dataColumn = new DataColumn();
                dataColumn.ColumnName = string.Format("L/G-COEF");
                dataColumn.DataType   = Type.GetType("System.Double");
                data.DataTable.Columns.Add(dataColumn);
                dataColumn            = new DataColumn();
                dataColumn.ColumnName = "kaVL-COEF";
                dataColumn.DataType   = Type.GetType("System.Double");
                data.DataTable.Columns.Add(dataColumn);
            }

            CalculateApproach(data);
            CalculateApproaches(data);

            return(true);
        }
        void InitializeApproachList(DemandCurveData data)
        {
            MerkelData merkelData = new MerkelData()
            {
                WetBulbTemperature = data.WetBulbTemperature,
                Range            = data.Range,
                Elevation        = data.Elevation,
                LiquidToGasRatio = 0.1
            };

            foreach (double approachValue in InitialApproachXValues)
            {
                merkelData.Approach = approachValue;

                double KaVL            = CalculationLibrary.CalculateMerkel(merkelData);
                bool   approachInRange = (KaVL > 0.1) && (KaVL < 5.0);
                ApproachInRange.Add(approachInRange);
                ApproachOutOfRange.Add(!approachInRange);
            }
        }
        void CalculateApproaches(DemandCurveData data)
        {
            //StreamWriter fs = new StreamWriter("new.txt");

            MerkelData merkelData = new MerkelData()
            {
                WetBulbTemperature = 80, // data.WetBulbTemperature,
                Range            = data.Range,
                Elevation        = data.Elevation,
                LiquidToGasRatio = data.LiquidToGasRatio
            };

            double       kaVL = 0;
            double       calculatedWaterAirRatio = 0.0;
            const double waterAirRatio_MIN = 0.01, waterAirRatio_MAX = 5.0;
            double       calculatedWaterAirRatio_MIN = 999.0;

            //ApproachXValues[INDEX_TARGETAPPROACH] = TargetApproach;
            //ApproachXValues[INDEX_USERAPPROACH] = UserApproach;

            for (double waterAirRatio = waterAirRatio_MIN; waterAirRatio < waterAirRatio_MAX; waterAirRatio += .05)
            {
                //fs.WriteLine("\ndLG {0} \n", waterAirRatio.ToString("F6"));
                DataRow dataRow = data.DataTable.NewRow();

                for (int i = 0; i < InitialApproachXValues.Length; i++)
                {
                    //fs.WriteLine("\niIndex {0}  getapp(iIndex) {1} App[iIndex] {2} ", i, 1, (int)ApproachXValues[i]);
                    string approachXValue = ((int)InitialApproachXValues[i]).ToString();

                    if (ApproachInRange[i] && !ApproachOutOfRange[i])
                    {
                        merkelData.LiquidToGasRatio = waterAirRatio;
                        merkelData.Approach         = InitialApproachXValues[i];
                        if (data.IsInternationalSystemOfUnits_IS_)
                        {
                            merkelData.Approach *= 1.8;
                        }

                        if (waterAirRatio > 1.3 && waterAirRatio < 1.4)
                        {
                            //fs.WriteLine();
                        }

                        //fs.WriteLine(" m_dblCurveWBT {0}, m_dblCurveRange {1}, App[iIndex] {2}, dLG {3}, m_dblAltitude {4} ", merkelData.WetBulbTemperature.ToString("F6"), merkelData.Range.ToString("F6"), merkelData.Approach.ToString("F6"), merkelData.WaterAirRatio.ToString("F6"), merkelData.Elevation.ToString("F6"));

                        kaVL = CalculationLibrary.CalculateMerkel(merkelData);

                        //fs.WriteLine(" m_dblCurveWBT {0}, m_dblCurveRange {1}, App[iIndex] {2}, dLG {3}, m_dblAltitude {4} ", merkelData.WetBulbTemperature.ToString("F6"), merkelData.Range.ToString("F6"), merkelData.Approach.ToString("F6"), merkelData.WaterAirRatio.ToString("F6"), merkelData.Elevation.ToString("F6"));
                        //fs.WriteLine("kavl {0} minVal {1} maxVal {2} dLG {3} App[iIndex] {4} ", kaVL.ToString("F6"), waterAirRatio_MIN.ToString("F6"), waterAirRatio_MAX.ToString("F6"), waterAirRatio.ToString("F6"), ApproachXValues[i].ToString("F6"));

                        // ddp
                        if ((kaVL < waterAirRatio_MIN) || (kaVL >= waterAirRatio_MAX))
                        {
                            double dInterp;
                            for (dInterp = waterAirRatio; ((kaVL < waterAirRatio_MIN) || (kaVL >= waterAirRatio_MAX)) && (dInterp > .1); dInterp -= 0.0002)
                            {
                                merkelData.Approach = InitialApproachXValues[i];
                                if (data.IsInternationalSystemOfUnits_IS_)
                                {
                                    merkelData.Approach *= 1.8;
                                }
                                merkelData.LiquidToGasRatio = dInterp;
                                kaVL = CalculationLibrary.CalculateMerkel(merkelData);
                            }
                            calculatedWaterAirRatio = dInterp;
                            ApproachOutOfRange[i]   = true; //DDP This is the last point
                        }
                        else
                        {
                            calculatedWaterAirRatio = waterAirRatio;
                        }

                        //fs.WriteLine("kavl {0} dLG {1} App[iIndex] {2} ", kaVL.ToString("F6"), waterAirRatio.ToString("F6"), ApproachXValues[i].ToString("F6"));

                        if ((calculatedWaterAirRatio_MIN > kaVL) && (kaVL > .1))
                        {
                            calculatedWaterAirRatio_MIN = kaVL;
                        }
                        //fs.Write("sDLG {0} ", calculatedWaterAirRatio.ToString("F6"));
                        //fs.Write("min4Lg {0} \n", min4Lg.ToString("F6"));

                        if ((kaVL <= 10.0) && (kaVL >= .1))
                        {
                            //fs.WriteLine("index {2} m_wndGraph {0} {1}", calculatedWaterAirRatio.ToString("F6"), kaVL.ToString("F6"), i);
                            dataRow[string.Format("L/G-{0}", approachXValue)]  = calculatedWaterAirRatio;
                            dataRow[string.Format("kaVL-{0}", approachXValue)] = kaVL;
                        }
                    }
                }
                data.DataTable.Rows.Add(dataRow);
            }

            ////---------------------------------------------------------------------
            //// Draw Fill Line
            ////---------------------------------------------------------------------
            //if ((data.CurveC1 != 0) && (data.CurveC2 != 0))//&& coef)
            //{
            //    for (double waterAirRatio = data.CurveMinimum; waterAirRatio <= data.CurveMaximum; waterAirRatio += .05)
            //    {
            //        DataRow dataRow = data.DataTable.NewRow();
            //        if ((waterAirRatio >= data.CurveMinimum) && (waterAirRatio <= data.CurveMaximum))
            //        {
            //            double dblK = data.CurveC1 * Math.Pow(waterAirRatio, data.CurveC2);

            //            if ((dblK >= calculatedWaterAirRatio_MIN) && (dblK <= waterAirRatio_MAX))
            //            {
            //                dataRow["kaVL-COEF"] = kaVL;
            //                dataRow["L/G-COEF"] = calculatedWaterAirRatio;
            //                //m_wndGraph.GetSeries(INDEX_COEF).AddXY(waterAirRatio, dblK, NULL, 00099FF);
            //            }
            //        }
            //        data.DataTable.Rows.Add(dataRow);
            //    }
            //}

            //////---------------------------------------------------------------------
            ////// Draw L/G line
            //////---------------------------------------------------------------------
            //if (data.WaterAirRatio > waterAirRatio_MIN && data.WaterAirRatio <= waterAirRatio_MAX)// && Lg)
            //{
            //    DataColumn dataColumn = new DataColumn();
            //    dataColumn.ColumnName = "L/G-X";
            //    dataColumn.DataType = Type.GetType("System.Double");
            //    data.DataTable.Columns.Add(dataColumn);
            //    dataColumn = new DataColumn();
            //    dataColumn.ColumnName = "L/G-Y";
            //    dataColumn.DataType = Type.GetType("System.Double");
            //    data.DataTable.Columns.Add(dataColumn);

            //    DataRow dataRow = data.DataTable.NewRow();
            //    dataRow["L/G-Y"] = data.WaterAirRatio;
            //    dataRow["L/G-X"] = calculatedWaterAirRatio_MIN;
            //    data.DataTable.Rows.Add(dataRow);

            //    dataRow = data.DataTable.NewRow();
            //    dataRow["L/G-Y"] = data.WaterAirRatio;
            //    dataRow["L/G-X"] = waterAirRatio_MAX;
            //    data.DataTable.Rows.Add(dataRow);
            //}

            //////---------------------------------------------------------------------
            ////// Draw KaV/L line
            //////---------------------------------------------------------------------
            //if ((data.KaV_L > 0.1) && (data.KaV_L <= waterAirRatio_MAX)) // && m_bShowKaVLLine)
            //{
            //    DataRow dataRow = data.DataTable.NewRow();
            //    dataRow[string.Format("kaVL-{0}", INDEX_KAVL)] = waterAirRatio_MIN;
            //    dataRow[string.Format("L/G-{0}", INDEX_KAVL)] = data.KaV_L;
            //    data.DataTable.Rows.Add(dataRow);
            //    dataRow = data.DataTable.NewRow();
            //    dataRow[string.Format("kaVL-{0}", INDEX_KAVL)] = waterAirRatio_MAX;
            //    dataRow[string.Format("L/G-{0}", INDEX_KAVL)] = data.KaV_L;
            //    data.DataTable.Rows.Add(dataRow);
            data.DataTable.Rows[0][string.Format("kaVL-{0}", INDEX_KAVL)] = waterAirRatio_MAX;
            //    data.DataTable.Rows[0][columnName] = waterAirRatio_MAX;
            //    data.DataTable.Rows[1][columnName] = waterAirRatio_MAX;
            //}

            //fs.Flush();
            //fs.Close();
        }
 public void FillTable(DemandCurveData data)
 {
 }