Ejemplo n.º 1
0
        public static void CopyCoeffs(string coeffTypeColumnName,
                                      TableProcessing.Table bazaHydroTable,
                                      TableProcessing.Table coeffsTable,
                                      TableProcessing.Table hydroTable,
                                      params string[] coeffsArray)
        {
            hydroTable.AddColumnIfNotExist(bazaHydroTable.Column(coeffTypeColumnName));

            var coeffsTableRows = coeffsTable.GetRows();

            hydroTable.IterateRows(calcsRow =>
            {
                var query = from coeffsRow in coeffsTableRows
                            where coeffsRow["OI_RnDF"].StringValue
                            == calcsRow[coeffTypeColumnName].StringValue
                            select coeffsRow;

                var neededRow = query.First();

                foreach (var coeffColumnName in coeffsArray)
                {
                    calcsRow.Set(coeffColumnName, neededRow[coeffColumnName]);
                }
            }, null, coeffsArray);
        }
Ejemplo n.º 2
0
        private void InterpolateCvY(double value)
        {
            var interpColumnName = CvYColumnConverter.NameFromValue(value);

            var interpTable = new TableProcessing.Table("Interpolate " + interpColumnName);

            interpTable.AddColumn(tables.OrdinKtgr.Column("PY"));

            var floorValue = double.NegativeInfinity;
            var ceilValue  = double.PositiveInfinity;

            for (var i = 0; i < tables.OrdinKtgr.DataTable.Columns.Count; i++)
            {
                var column = tables.OrdinKtgr.DataTable.Columns[i];

                if (column.ColumnName.IndexOf("CvY_", StringComparison.Ordinal) != 0)
                {
                    continue;
                }

                var CV_value = CvYColumnConverter.ValueFromName(column.ColumnName);

                if (CV_value < value)
                {
                    floorValue = CV_value;
                }
                else if (CV_value > value)
                {
                    ceilValue = CV_value;
                    break;
                }
            }

            var floorStr = CvYColumnConverter.NameFromValue(floorValue);

            var ceilStr = CvYColumnConverter.NameFromValue(ceilValue);

            interpTable.AddColumn(tables.OrdinKtgr.Column(floorStr));
            var column_res = interpTable.Column(interpColumnName);

            interpTable.AddColumn(tables.OrdinKtgr.Column(ceilStr));

            interpTable.IterateRows(row =>
            {
                double[] x = { floorValue, ceilValue };
                double[] y =
                {
                    row[floorStr].DoubleValue,
                    row[ceilStr].DoubleValue
                };

                var res = LinearSpline.Interpolate(x, y).Interpolate(value);
                row.Set(column_res.Name, res);
            }, column_res.Name);

            tables.OrdinKtgr.AddColumn(interpTable.Column(interpColumnName));
        }
Ejemplo n.º 3
0
        public static void CalcMeteoAvg(List <Row> meteoRows, string meteoColumnName,
                                        TableProcessing.Table calcsHydroTable, string hydroColumnName,
                                        ICellMapper cellMapper, params TableProcessing.Table[] resultTables)
        {
            var valuesColumnName = meteoColumnName + "_Values";


            calcsHydroTable.IterateRows(hydroRow =>
            {
                var intList = hydroRow["OI_METEO"].ToIntList();

                double number = 0;

                var realMeteoColumnName = meteoColumnName;

                if (meteoColumnName.StartsWith("&"))
                {
                    var hydroPtr        = meteoColumnName.Substring(1);
                    realMeteoColumnName = hydroRow[hydroPtr].StringValue;
                }

                Etc.NoThrow(() =>
                {
                    var doubleQuery = from meteoRow in meteoRows
                                      where intList.Contains(meteoRow["OI_Meteo"].IntValue) &&
                                      double.TryParse(
                        meteoRow[realMeteoColumnName].StringValue, out number)
                                      select number;

                    var enumerable = doubleQuery.ToList();

                    var strQuery = from dbl in enumerable
                                   select cellMapper.Map(new Cell(dbl)).StringValue;

                    var res = string.Join(";", strQuery.ToArray());

                    hydroRow.Set(valuesColumnName, res);

                    hydroRow.Set(hydroColumnName,
                                 enumerable.Average(), cellMapper);
                });
            }, valuesColumnName, hydroColumnName);

            foreach (var table in resultTables)
            {
                table.AddColumn(calcsHydroTable.Column(hydroColumnName));
            }
        }
Ejemplo n.º 4
0
        private void Calc_PY()
        {
            var interpTable = new TableProcessing.Table("Інтерполяція PY");

            tables.AddCustomTable(interpTable);

            interpTable.AddColumn("PY");
            interpTable.AddRow("0,001");
            interpTable.AddRow("0,01");
            interpTable.AddRow("0,03");
            interpTable.AddRow("0,05");
            interpTable.AddRow("0,1");
            interpTable.AddRow("0,3");
            interpTable.AddRow("0,5");

            for (var i = 1; i <= 99; i++)
            {
                interpTable.AddRow(i);
            }

            tables.CalcsHydro.IterateRows(row =>
            {
                var kY             = row["kY"].DoubleValue;
                var CvY_columnName = row["CvY_Column"].StringValue;

                if (CvY_columnName.IndexOf("CvY_", StringComparison.Ordinal) != 0)
                {
                    return;
                }

                if (!tables.OrdinKtgr.DataTable.Columns.Contains(CvY_columnName))
                {
                    var value_CvY = CvYColumnConverter.ValueFromName(CvY_columnName);
                    InterpolateCvY(value_CvY);
                }

                var PY_cells  = tables.OrdinKtgr.Column("PY").GetCells();
                var CvY_cells = tables.OrdinKtgr.Column(CvY_columnName).GetCells();

                var x = new List <double>();
                var y = new List <double>();

                for (var i = 0; i < PY_cells.Count; i++)
                {
                    Etc.NoThrow(() =>
                    {
                        var xValue = PY_cells[i].DoubleValue;
                        var yValue = CvY_cells[i].DoubleValue;

                        x.Add(xValue);
                        y.Add(yValue);
                    });
                }

                Etc.NoThrow(() =>
                {
                    var spline = LinearSpline.Interpolate(x, y);

                    interpTable.IterateRows(row2 =>
                    {
                        row2.Set(CvY_columnName,
                                 spline.Interpolate(row2["PY"].DoubleValue));
                    }, CvY_columnName);
                });

                var PY = Find_PY(interpTable, kY, CvY_columnName);
                row.Set("PY", PY);
            }, "PY");

            tables.Result.AddColumn(tables.CalcsHydro.Column("PY"));
        }