private void AddCalcColumns(TableProcessing.Table table, params string[] columns)
{
foreach (var columnName in columns)
{
table.AddColumnIfNotExist(tables.CalcsHydro.Column(columnName));
}
}
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);
}
private int Find_PY(TableProcessing.Table interpTable, double kY, string CvY_columnName)
{
var PY_cells = interpTable.Column("PY").GetCells();
var CvY_cells = interpTable.Column(CvY_columnName).GetCells();
var rowsCount = PY_cells.Count;
var minDiff = double.MaxValue;
var minDiffIndex = -1;
for (var i = 0; i < rowsCount; ++i)
{
var diff = Math.Abs(CvY_cells[i].DoubleValue - kY);
if (diff < minDiff)
{
minDiff = diff;
minDiffIndex = i;
}
}
var PY = PY_cells[minDiffIndex].IntValue;
return(PY);
}
public CalcMeteoTable(string name,
TableProcessing.Table operInfoMeteoTable) : base(name)
{
AddColumns(
operInfoMeteoTable.Column(Tables.OperInfoMeteo.Index),
operInfoMeteoTable.Column(Tables.OperInfoMeteo.OI_Meteo),
operInfoMeteoTable.Column(Tables.OperInfoMeteo.Meteo));
}
public CalcsHydroTable(string name,
TableProcessing.Table operInfoHydroTable) : base(name)
{
AddColumns(
operInfoHydroTable.Column(Tables.OperInfoHydro.Index),
operInfoHydroTable.Column(Tables.OperInfoHydro.OI_Hydro),
operInfoHydroTable.Column(Tables.OperInfoHydro.Hydro));
}
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));
}
private void ImportColumns(TableProcessing.Table table,
params string[] columns)
{
foreach (var column in columns)
{
var col = tables.CalcsHydro.AddColumn("_" + column);
col.SetDataFrom(table.Column(column));
}
}
public void AddCustomTableIfNotExists(TableProcessing.Table newTable)
{
foreach (var table in customTables)
{
if (table.DataTable.TableName == newTable.DataTable.TableName)
{
return;
}
}
AddCustomTable(newTable);
}
private void AddCalcColumnsOrdinal(TableProcessing.Table table, int firstOrdinal,
params string[] columns)
{
var ordinal = firstOrdinal;
foreach (var columnName in columns)
{
table.AddColumn(tables.CalcsHydro.Column(columnName));
table.DataTable.Columns[columnName].SetOrdinal(ordinal);
ordinal++;
}
}
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));
}
}
private void LoadDbTables()
{
var userArgYear = userInput[CalculationsForm.Arg_Year];
var operTableArgs = OperTableContract.CreateArgs(userArgYear);
OperInfoHydro = dbTableLoader.LoadTable(Tables.Names.OperInfoHydro, operTableArgs);
OperInfoMeteo = dbTableLoader.LoadTable(Tables.Names.OperInfoMeteo, operTableArgs);
BazaInfoHydro = dbTableLoader.LoadTable(Tables.Names.BazaInfoHydro);
BazaInfoMeteo = dbTableLoader.LoadTable(Tables.Names.BazaInfoMeteo);
BazaInfoCoeffs = dbTableLoader.LoadTable(Tables.Names.BazaInfoCoeffs);
OrdinKtgr = dbTableLoader.LoadTable(Tables.Names.OrdinKtgr);
Posts = dbTableLoader.LoadTable(Tables.Names.Posts);
ConsultSp = dbTableLoader.LoadTable(Tables.Names.ConsultSp);
}
public static void BlockE_Calc_kWP(int totalOffset,
TableProcessing.Table calcsTable,
Dictionary <string, string> userInput,
Dictionary <string, object> calcMemory
)
{
var column_kWP = calcsTable.Column("kWP");
if (userInput[CalculationsForm.Arg_Qp] == QpItemsRepr.Wj)
{
column_kWP.SetDataFrom(calcsTable.Column("kWSR"));
calcMemory["DF_Offset"] = totalOffset + 10;
}
else
{
column_kWP.SetDataFrom(calcsTable.Column("kQP"));
calcMemory["DF_Offset"] = totalOffset;
}
}
public void AddCustomTable(TableProcessing.Table newTable)
{
customTables.Add(newTable);
}
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"));
}
public static void RestoreColumn(TableProcessing.Table coeffsTable,
Column xCol, Column yCol,
ICellMapper resultMapper, string equationName,
bool needPlusA = true)
{
var count = xCol.Height;
var xDoubles = new List <double>();
var yDoubles = new List <double>();
for (var i = 0; i < count; i++)
{
if (!xCol[i].IsEmpty && !yCol[i].IsEmpty)
{
xDoubles.Add(xCol[i].DoubleValue);
yDoubles.Add(yCol[i].DoubleValue);
}
}
var restoredColumn = yCol.Table.Column(yCol.Name + "_Restored");
var usedColumn = yCol.Table.Column(yCol.Name + "_Used");
if (xDoubles.Count < 2)
{
return;
}
var p = Fit.Line(xDoubles.ToArray(), yDoubles.ToArray());
// y = a + b*x
var coeffMapper = new RoundDoubleCellMapper(6);
var a = 0.0;
if (needPlusA)
{
a = p.Item1;
}
var b = p.Item2;
var aValue = "";
if (needPlusA)
{
aValue = coeffMapper.Map(new Cell(a)).StringValue;
}
coeffsTable.DataTable.Rows.Add(equationName,
aValue,
coeffMapper.Map(new Cell(b)).StringValue);
for (var i = 0; i < count; i++)
{
if (!xCol[i].IsEmpty)
{
var restoredValue = a + b * xCol[i].DoubleValue;
restoredColumn.Set(i, restoredValue, resultMapper);
usedColumn.Set(i, yCol[i].IsEmpty ? restoredColumn[i] : yCol[i]);
}
}
}
