/// <summary>
/// заполнение выбранного элемента перед сохранением в БД или расчетом
/// </summary>
private bool prepareEquipment()
{
try
{
if (radioButtonCharacteristicCalculate.Checked)
{
selectedEquipment.PerformanceCharacteristic = PowerCalculator.CalculatePerformanceCharacteristic(selectedEquipment);
}
else if (radioButtonCharacteristicManual.Checked)
{
FormPerformanceCharacteristicDialog fpcd = new FormPerformanceCharacteristicDialog(30);
if (fpcd.ShowDialog(this) == DialogResult.OK)
{
selectedEquipment.PerformanceCharacteristic = fpcd.Result;
}
else
{
return(false);
}
}
return(true);
}
catch (Exception ex)
{
_ = MessageBox.Show(this, $"Произошла ошибка при расчете мощностной характеристики:\r\n{ex.Message}", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
}
public void PowerTest(double firstValue, double secondValue, double expected)
{
var calculator = new PowerCalculator();
var actualResult = calculator.Calculate(firstValue, secondValue);
Assert.AreEqual(expected, actualResult, 0.001);
}
public void PowerCalculatorTest()
{
var calculator = new PowerCalculator();
double actual = calculator.Calculate(2);
Assert.AreEqual(4, actual);
}
public void CalculateTest(double valueOne, double valueTwo, double result)
{
var calculator = new PowerCalculator();
var testResult = calculator.Calculate(valueOne, valueTwo);
Assert.AreEqual(result, testResult);
}
/// <summary>
/// Constructor
/// </summary>
public CalculationEngineForecast()
{
wfProxy = new WeatherForecastProxy();
chfProxy = new CalculateHourlyForecast();
model = CalculationEngineModel.Instance;
powCalc = new PowerCalculator();
Thread newThread = new Thread(CalculatePerHour);
newThread.Start();
}
public CalculationTests()
{
_grid = new Grid {
SerialNumber = 8
};
_calculator = new PowerCalculator( );
_cell = new FuelCell {
X = 3, Y = 5
};
}
/// <summary>
/// отрисовка графиков
/// </summary>
private void reloadGraphs()
{
//отрисовка графика характеристики
zedGraphControl.GraphPane.CurveList.Clear();
GraphPane spane = zedGraphControl.GraphPane;
spane.Title.Text = "P(V), кВт";
spane.XAxis.Title.Text = "V, м/с";
spane.YAxis.Title.Text = "P(V), кВт";
if ((selectedEquipment.HasCharacteristic || selectedEquipment.EnoughDataToCalculateCharacteristic) &&
(radioButtonCharacteristicFromDatabase.Checked || radioButtonCharacteristicCalculate.Checked))
{
//получение графика с учетом настроек
Dictionary <double, double> func;
string titleSuffix;
if (selectedEquipment.HasCharacteristic && radioButtonCharacteristicFromDatabase.Checked)
{
if (checkBoxRecalcPerformanceWithAirDensity.Checked)
{
func = PowerCalculator.RecalcPerfomanceCharacteristicWithAirDensity(range.AirDensity, selectedEquipment.PerformanceCharacteristic, selectedEquipment);
titleSuffix = " (Из БД \"Оборудование\" с учетом плотности воздуха)";
}
else
{
func = selectedEquipment.PerformanceCharacteristic;
titleSuffix = " (Из БД \"Оборудование\")";
}
}
else if (selectedEquipment.EnoughDataToCalculateCharacteristic && radioButtonCharacteristicCalculate.Checked)
{
func = PowerCalculator.CalculatePerformanceCharacteristic(selectedEquipment);
titleSuffix = " (Расчитана на основе Vmin, Vmax, Nном, Vном)";
}
else
{
throw new Exception("Что-то совсем не так");
}
//вывод графика
List <double> keys = func.Keys.ToList();
keys.Sort();
spane.Title.Text = "P(V), кВт" + titleSuffix;
spane.GraphObjList.Clear();
spane.CurveList.Clear();
PointPairList slist = new PointPairList();
foreach (double key in keys)
{
slist.Add(key, func[key]);
}
_ = spane.AddCurve("P(V)", slist, Color.Red);
}
zedGraphControl.AxisChange();
zedGraphControl.Invalidate();
}
static void Main(string[] args)
{
const int serialNumber = 9435;
const int size = 300;
var calculator = new PowerCalculator();
var grid = new Grid();
grid.SerialNumber = serialNumber;
grid.Initialize(size, calculator);
var highestResultAny = grid.HighestPowerCubeAnySize();
System.Console.WriteLine($"Result: X:{highestResultAny.result.Cell.X} Y:{highestResultAny.result.Cell.Y} power: {highestResultAny.result.TotalPower} size: {highestResultAny.cubeSize}");
}
public void PowerSpotChecks(int serialNumber, int expectedX, int expectedY, int expectedPower)
{
const int size = 300;
var calculator = new PowerCalculator();
var grid = new Grid();
grid.SerialNumber = serialNumber;
grid.Initialize(size, calculator);
var highestResult = grid.HighestPowerCube(3);
Assert.Equal(expectedPower, highestResult.TotalPower);
Assert.Equal(expectedX, highestResult.Cell.X);
Assert.Equal(expectedY, highestResult.Cell.Y);
}
private async void comboBoxTowerHeights_SelectedValueChanged(object sender, EventArgs e)
{
try
{
double newH = Convert.ToDouble(comboBoxTowerHeights.SelectedItem);
result = await PowerCalculator.Calculate(range, equipment, newH, startHeight, ams, needRecalcWithAirDensity).ConfigureAwait(true);
refreshInterface();
}
catch (Exception ex)
{
_ = MessageBox.Show(this, $"Произошла ошибка при расчете выработки ВЭУ:\r\n{ex.Message}", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
public void CellSpotChecks(int x, int y, int serialNumber, int expectedPower)
{
const int size = 300;
var calculator = new PowerCalculator();
var grid = new Grid();
grid.SerialNumber = serialNumber;
grid.Initialize(size, calculator);
var xIndex = x - 1;
var yIndex = y - 1;
var testCell = grid.Cells[yIndex, xIndex];
Assert.Equal(expectedPower, testCell.PowerLevel);
}
private async void buttonSaveToFile_Click(object sender, EventArgs e)
{
try
{
SaveFileDialog ofd = new SaveFileDialog();
ofd.InitialDirectory = Vars.Options.LastDirectory;
ofd.FileName = "Расчет выработки для " + equipment.Model.ToFileName();
ofd.Filter = "Файл MS Excel *.xlsx | *.xlsx";
ofd.Filter += "|Файл *.csv | *.csv";
ofd.AddExtension = true;
ofd.OverwritePrompt = false;
if (ofd.ShowDialog() == DialogResult.OK)
{
Vars.Options.LastDirectory = Path.GetDirectoryName(ofd.FileName);
List <PowerCalculatorResult> results = new List <PowerCalculatorResult>();
foreach (double h in equipment.TowerHeight)
{
results.Add(await PowerCalculator.Calculate(range, equipment, h, startHeight, ams, needRecalcWithAirDensity).ConfigureAwait(true));
}
FileProvider fp;
switch (Path.GetExtension(ofd.FileName))
{
case ".xlsx":
fp = new ExcelFile();
break;
case ".csv":
fp = new CSVFile();
break;
default:
_ = MessageBox.Show(this, "Нельзя сохранить файл в этом формате", "Сохранение результатов расчета", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
fp.SavePowerCalculatorResults(results, ofd.FileName);
_ = Process.Start(ofd.FileName);
}
}
catch (Exception ex)
{
_ = MessageBox.Show(this, $"Произошла ошибка при расчете выработки ВЭУ:\r\n{ex.Message}", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
public void Initialize(int size, PowerCalculator calculator)
{
_size = size;
Cells = new FuelCell[size, size];
for (int rowIndex = 0; rowIndex < size; rowIndex++)
{
var currentY = rowIndex + 1;
for (int columnIndex = 0; columnIndex < size; columnIndex++)
{
var currentX = columnIndex + 1;
var cell = new FuelCell {
X = currentX, Y = currentY
};
var power = calculator.PowerLevel(SerialNumber, cell);
cell.PowerLevel = power;
Cells[rowIndex, columnIndex] = cell;
}
}
}
private ICalculator <float> CreateCalculator(CalculateType calculateType, params float[] values)
{
ICalculator <float> ret = null;
switch (calculateType)
{
case CalculateType.Addition:
ret = new AdditionCalculator <float>(values[0], values[1]);
break;
case CalculateType.Subtraction:
ret = new SubtractionCalculator <float>(values[0], values[1]);
break;
case CalculateType.Multiplication:
ret = new MultiplicationCalculator <float>(values[0], values[1]);
break;
case CalculateType.Division:
ret = new DivisionCalculator <float>(values[0], values[1]);
break;
case CalculateType.Power:
ret = new PowerCalculator <float>(values[0], values[1]);
break;
case CalculateType.Sine:
ret = new SineCalculator <float>(values[0]);
break;
case CalculateType.Cosine:
ret = new CosineCalculator <float>(values[0]);
break;
}
return(ret);
}
public static void SetPowerRegenCalculator(PowerType type, PowerCalculator calc)
{
PowerRegenCalculators[(int)type] = calc;
}
public void TestV2(int baseNumber, int exponent, int expectedResult)
{
PowerCalculator math = new PowerCalculator();
math.Calculate(baseNumber, exponent).Should().Be(expectedResult);
}
public static void SetBasePowerCalculator(PowerType type, PowerCalculator calc)
{
BasePowerForLevelCalculators[(int)type] = calc;
}
public void CircuitPower_IntVoltageAndCurrent_ReturnIntPower(int voltage, int current, int expected)
{
var actual = PowerCalculator.CircuitPower(voltage, current);
Assert.Equal(expected, actual);
}
public PowerCalculationTests()
{
_calculator = new PowerCalculator();
}
