private void WriteImpulse(PressureUnit unit, double[] values)
{
var valueObj = new NdConvertibleValue(StockConverters.PressureConverter, unit, values);
QraStateContainer.SetValue("impulse", valueObj);
//QraStateContainer.Instance.Parameters["impulse"] = ValueObj;
}
/// <summary>
/// Set up data sources and load stored models as selected choices
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void cpConsequenceModels_Load(object sender, EventArgs e)
{
var qraInst = QraStateContainer.Instance;
cbNotionalNozzleModel.DataSource = qraInst.NozzleModels;
cbNotionalNozzleModel.SelectedItem = QraStateContainer.GetValue <NozzleModel>("NozzleModel");
cbDeflagrationModel.DataSource = qraInst.DeflagrationModels;
var model = QraStateContainer.GetValue <DeflagrationModel>("DeflagrationModel");
cbDeflagrationModel.SelectedItem = model;
UpdateCfdInput(model);
cbThermalProbitModel.DataSource = qraInst.ThermalProbitModels;
cbThermalProbitModel.SelectedItem = QraStateContainer.GetValue <ThermalProbitModel>("ThermalProbit");
cbOverpressureProbitModel.DataSource = qraInst.OverpressureProbitModels;
cbOverpressureProbitModel.SelectedItem =
QraStateContainer.GetValue <OverpressureProbitModel>("OverpressureProbit");
var radModel = QraStateContainer.GetValue <RadiativeSourceModels>("RadiativeSourceModel");
cbRadiativeSourceModel.Fill(UiStateRoutines.GetRadiativeSourceModelDict(), radModel);
cbRadiativeSourceModel.SelectedItem = radModel;
}
/// <summary>
/// Parse selected string into Deflagration Model, store it, and update CFD input display.
/// </summary>
private void cbDeflagrationModel_SelectionChangeCommitted(object sender, EventArgs e)
{
var model = (DeflagrationModel)cbDeflagrationModel.SelectedItem;
QraStateContainer.SetValue("DeflagrationModel", model);
UpdateCfdInput(model);
}
private void cbRadiativeSourceModel_OnValueChanged(object sender, EventArgs e)
{
var newValue =
(RadiativeSourceModels)((AnyEnumComboSelector)sender).SelectedItem;
QraStateContainer.SetValue("RadiativeSourceModel", newValue);
}
private void FillIgnitionProbabilitiesTableFromMemory()
{
var immedIgnitionProbs = QraStateContainer.GetValue <double[]>("ImmedIgnitionProbs");
var delayIgnitionProbs = QraStateContainer.GetValue <double[]>("DelayIgnitionProbs");
SetDatagridColumn(dgIgnitionProbabilities, ColImmed, immedIgnitionProbs);
SetDatagridColumn(dgIgnitionProbabilities, ColDelayed, delayIgnitionProbs);
}
private void SetDatabaseExclusionRadius(double value)
{
var er = new double[1];
er[0] = value;
var exclusionRadius = QraStateContainer.GetValue <NdConvertibleValue>("QRAD:EXCLUSIONRADIUS");
exclusionRadius.SetValue(UnitlessUnit.Unitless, er);
}
private void UpdateIgnitionProbablitiesList()
{
var ignitionThresholds = QraStateContainer.GetValue <double[]>("IgnitionThresholds");
for (var i = 0; i < ignitionThresholds.Length; ++i)
{
lbIgnitionProbabilities.Items.Add(ignitionThresholds[i]);
}
}
private void tbDischargeCoefficient_TextChanged(object sender, EventArgs e)
{
var cD = double.NaN;
if (Parsing.TryParseDouble(tbDischargeCoefficient.Text, out cD))
{
//ndConvertibleValue ValueNode = new ndConvertibleValue(StockConverters.UnitlessConverter, UnitlessUnit.Unitless, new double[] { C_D });
QraStateContainer.SetNdValue("DischargeCoefficient", UnitlessUnit.Unitless, cD);
}
}
private void ReadFromGlobalDataCollectionAndSet()
{
if (DesignMode)
{
return;
}
//UIStateRoutines.SetSelectedDropdownValue(cbNotionalNozzleModel, (string)QraStateContainer.Instance.GlobalData["NozzleModel"]);
UiStateRoutines.SetSelectedDropdownValue(cbNotionalNozzleModel,
QraStateContainer.GetObject("NozzleModel").ToString());
}
/// <summary>
/// Compute results of overpressure and generate associated plots.
/// </summary>
/// <param name="ambPressure"></param>
/// <param name="ambTemp"></param>
/// <param name="h2Pressure"></param>
/// <param name="h2Temp"></param>
/// <param name="orificeDiam"></param>
/// <param name="orificeDischargeCoeff"></param>
/// <param name="tankVolume"></param>
/// <param name="releaseDischargeCoeff"></param>
/// <param name="releaseArea"></param>
/// <param name="releaseHeight"></param>
/// <param name="enclosureHeight"></param>
/// <param name="floorCeilingArea"></param>
/// <param name="distReleaseToWall"></param>
/// <param name="ceilVentXArea"></param>
/// <param name="ceilVentHeight"></param>
/// <param name="floorVentXArea"></param>
/// <param name="floorVentHeight"></param>
/// <param name="flowRate"></param>
/// <param name="releaseAngle"></param>
/// <param name="timesToPlot"></param>
/// <param name="dotMarkPressures"></param>
/// <param name="dotMarkTimes"></param>
/// <param name="limitLinePressures"></param>
/// <param name="maxSimTime"></param>
/// <param name="pressuresPerTime"></param>
/// <param name="depths"></param>
/// <param name="concentrations"></param>
/// <param name="overpressure"></param>
/// <param name="timeOfOverpressure"></param>
/// <param name="pressurePlotFilepath"></param>
/// <param name="massPlotFilepath"></param>
/// <param name="layerPlotFilepath"></param>
/// <param name="trajectoryPlotFilepath"></param>
/// <returns></returns>
public int ExecuteOverpressureAnalysis(
double ambPressure, double ambTemp, double h2Pressure, double h2Temp, double orificeDiam, double orificeDischargeCoeff, double tankVolume,
double releaseDischargeCoeff, double releaseArea, double releaseHeight, double enclosureHeight, double floorCeilingArea, double distReleaseToWall,
double ceilVentXArea, double ceilVentHeight, double floorVentXArea, double floorVentHeight, double flowRate, double releaseAngle, double[] timesToPlot,
double[] dotMarkPressures, double[] dotMarkTimes, double[] limitLinePressures, double maxSimTime,
out double[] pressuresPerTime, out double[] depths, out double[] concentrations, out double overpressure, out double timeOfOverpressure,
out string pressurePlotFilepath, out string massPlotFilepath, out string layerPlotFilepath, out string trajectoryPlotFilepath
)
{
bool isDebug = QraStateContainer.GetValue <bool>("debug");
string dataDirLoc = QraStateContainer.UserDataDir;
Trace.TraceInformation("Acquiring python lock and importing module...");
using (Py.GIL())
{
dynamic pyGC = Py.Import("gc");
dynamic pyHyramLib = Py.Import("hyram");
try
{
Trace.TraceInformation("Executing python overpressure call...");
// Execute python function call. Will return PyObject containing results.
dynamic resultPyObj = pyHyramLib.phys.capi.overpressure_indoor_release(
ambPressure, ambTemp, h2Pressure, h2Temp, tankVolume, orificeDiam, orificeDischargeCoeff,
releaseDischargeCoeff, releaseArea, releaseHeight, enclosureHeight, floorCeilingArea, distReleaseToWall,
ceilVentXArea, ceilVentHeight, floorVentXArea, floorVentHeight, flowRate, releaseAngle, timesToPlot,
dotMarkPressures, dotMarkTimes, limitLinePressures, maxSimTime, dataDirLoc, isDebug
);
Trace.TraceInformation("Python call complete. Processing results...");
pressuresPerTime = (double[])resultPyObj["pressures_per_time"];
depths = (double[])resultPyObj["depths"];
concentrations = (double[])resultPyObj["concentrations"];
overpressure = (double)resultPyObj["overpressure"];
timeOfOverpressure = (double)resultPyObj["time_of_overp"];
pressurePlotFilepath = (string)resultPyObj["pres_plot_filepath"];
massPlotFilepath = (string)resultPyObj["mass_plot_filepath"];
layerPlotFilepath = (string)resultPyObj["layer_plot_filepath"];
trajectoryPlotFilepath = (string)resultPyObj["trajectory_plot_filepath"];
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
throw new InvalidOperationException("Error during overpressure calculation. Check log for details.");
}
finally
{
pyGC.InvokeMethod("collect");
pyGC.Dispose();
pyHyramLib.Dispose();
}
}
return(1);
}
private void tbPlotTitle_TextChanged(object sender, EventArgs e)
{
if (tbPlotTitle.Text != null)
{
QraStateContainer.SetValue("PlumeWrapper.PlotTitle", tbPlotTitle.Text);
}
else
{
QraStateContainer.SetValue("PlumeWrapper.PlotTitle", "");
}
}
private void btnIgnitionProbabilitiesDelete_Click(object sender, EventArgs e)
{
var thresholdToRemove = Convert.ToDouble(lbIgnitionProbabilities.SelectedItem);
if (lbIgnitionProbabilities.Items.Count > 1)
{
var ignitionThresholds = QraStateContainer.GetValue <double[]>("IgnitionThresholds");
var immedIgnitionProbs = QraStateContainer.GetValue <double[]>("ImmedIgnitionProbs");
var delayIgnitionProbs = QraStateContainer.GetValue <double[]>("DelayIgnitionProbs");
var newIgnitionThresholds = new double[ignitionThresholds.Length - 1];
var newImmediate = new double[immedIgnitionProbs.Length - 1];
var newDelayed = new double[delayIgnitionProbs.Length - 1];
int offset = 0, index = 0;
for (var i = 0; i < ignitionThresholds.Length; ++i) //Insert new ignition threshold in order
{
if (ignitionThresholds[i] == thresholdToRemove)
{
index = i;
++offset;
}
else
{
newIgnitionThresholds[i - offset] = ignitionThresholds[i];
}
}
offset = 0;
for (var i = 0; i < immedIgnitionProbs.Length; ++i)
{
if (i == index)
{
++offset;
}
else
{
newDelayed[i - offset] = delayIgnitionProbs[i];
newImmediate[i - offset] = immedIgnitionProbs[i];
}
}
QraStateContainer.SetValue("IgnitionThresholds", newIgnitionThresholds);
QraStateContainer.SetValue("ImmedIgnitionProbs", newImmediate);
QraStateContainer.SetValue("DelayIgnitionProbs", newDelayed);
lbIgnitionProbabilities.Items.Clear();
dgIgnitionProbabilities.Rows.Clear();
UpdateIgnitionProbablitiesList();
FillIgnitionProbabilitiesTable();
}
else
{
MessageBox.Show("Error: At least one ignition threshold is required.");
}
}
void IQraBaseNotify.Notify_LoadComplete()
{
//SetNarrative();
ContentPanel.SetNarrative(this, Narratives.DP__Data_Probabilities);
SetDischargeCoefficient();
UpdateIgnitionProbablitiesList();
FillIgnitionProbabilitiesTable();
QraStateContainer.SetValue("ResultsAreStale", true);
_mIgnoringChangeEvents = false;
}
private void HarvestIgnitionProbabilitiesTable()
{
if (!_mIgnoringChangeEvents)
{
var immedIgnitionProbs = HarvestDatagridColumn(dgIgnitionProbabilities, ColImmed);
var delayIgnitionProbs = HarvestDatagridColumn(dgIgnitionProbabilities, ColDelayed);
var ignitionThresholds = new double[lbIgnitionProbabilities.Items.Count];
var lbItems = new object[lbIgnitionProbabilities.Items.Count];
lbIgnitionProbabilities.Items.CopyTo(lbItems, 0);
for (var i = 0; i < ignitionThresholds.Length; ++i)
{
ignitionThresholds[i] = (double)lbItems[i];
}
for (var i = 0; i < delayIgnitionProbs.Length; ++i)
{
if (delayIgnitionProbs[i] < 0)
{
delayIgnitionProbs[i] = 0;
}
if (delayIgnitionProbs[i] > 1)
{
delayIgnitionProbs[i] = 1;
}
}
for (var i = 0; i < immedIgnitionProbs.Length; ++i)
{
if (immedIgnitionProbs[i] < 0)
{
immedIgnitionProbs[i] = 0;
}
if (immedIgnitionProbs[i] > 1)
{
immedIgnitionProbs[i] = 1;
}
}
if (delayIgnitionProbs.Length != 0 && immedIgnitionProbs.Length != 0)
{
QraStateContainer.SetValue("ImmedIgnitionProbs", immedIgnitionProbs);
QraStateContainer.SetValue("DelayIgnitionProbs", delayIgnitionProbs);
QraStateContainer.SetValue("IgnitionThresholds", ignitionThresholds);
//CalculateIgnitionProbabilities.Execute(ImmedIgnitionProbs, DelayIgnitionProbs, IgnitionThresholds);
_mIgnoringChangeEvents = true;
FillIgnitionProbabilitiesTableFromMemory();
_mIgnoringChangeEvents = false;
}
}
}
public void AnalyzeRadiativeHeatFlux(
double ambTemp, double ambPressure, double h2Temp, double h2Pressure, double orificeDiam, double leakHeight, double releaseAngle,
NozzleModel notionalNozzleModel, double[] radHeatFluxX, double[] radHeatFluxY, double[] radHeatFluxZ, double relativeHumidity,
RadiativeSourceModels radiativeSourceModel,
double[] contourLevels, out double[] fluxData, out string fluxPlotFilepath, out string tempPlotFilepath)
{
bool isDebug = QraStateContainer.GetValue <bool>("debug");
string dataDirLoc = QraStateContainer.UserDataDir;
string plotFilepath = "";
Trace.TraceInformation("Acquiring python lock and importing module");
using (Py.GIL())
{
dynamic pyGC = Py.Import("gc");
dynamic pyHyramLib = Py.Import("hyram");
try
{
Trace.TraceInformation("Executing python radiative heat flux analysis...");
dynamic resultPyObj = pyHyramLib.phys.capi.analyze_radiative_heat_flux(
ambTemp, ambPressure, h2Temp, h2Pressure, orificeDiam, leakHeight, releaseAngle,
notionalNozzleModel.GetKey(), radHeatFluxX, radHeatFluxY, radHeatFluxZ, relativeHumidity,
radiativeSourceModel.ToString().ToLower(),
contourLevels, dataDirLoc, isDebug
);
Trace.TraceInformation("Python call complete. Processing results...");
fluxData = (double[])resultPyObj["flux_data"];
fluxPlotFilepath = (string)resultPyObj["flux_plot_filepath"];
tempPlotFilepath = (string)resultPyObj["temp_plot_filepath"];
Debug.WriteLine(" Flux results: " + plotFilepath);
Debug.WriteLine(" Flux plots: " + fluxPlotFilepath + ", " + tempPlotFilepath);
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
throw new InvalidOperationException(
"Error during rad heat flux analysis. Check log for details.");
}
finally
{
pyGC.InvokeMethod("collect");
pyGC.Dispose();
pyHyramLib.Dispose();
}
}
}
private void dgSystemParameters_Vehicles_CellEndEdit(object sender, DataGridViewCellEventArgs e)
{
GridValueChanged(sender, e);
// Update annual demands
var row = e.RowIndex;
Debug.WriteLine("Changed row:" + row + ", col: " + e.ColumnIndex);
if (row != 3)
{
var numVehicles = QraStateContainer.GetNdValue("nVehicles");
var numDays = QraStateContainer.GetNdValue("nVehicleOperatingDays");
var numFuelings = QraStateContainer.GetNdValue("nFuelingsPerVehicleDay");
var demands = numVehicles * numDays * numFuelings;
QraStateContainer.SetNdValue("nDemands", UnitlessUnit.Unitless, demands);
dgSystemParameters_Vehicles.Rows[3].Cells[1].Value = demands; // TODO: binding
}
}
public string CreateFlameTemperaturePlot(
double ambTemp, double ambPressure, double h2Temp, double h2Pressure,
double orificeDiam, double y0, double releaseAngle, string nozzleModelKey)
{
bool isDebug = QraStateContainer.GetValue <bool>("debug");
// Derive path to data dir for temp and data files, e.g. pickling
string dataDirLoc = QraStateContainer.UserDataDir;
string plotFilepath = "";
Trace.TraceInformation("Acquiring python lock and importing module...");
using (Py.GIL())
{
dynamic pyGC = Py.Import("gc");
dynamic pyHyramLib = Py.Import("hyram");
try
{
// Execute python function call. Will return PyObject containing results.
Trace.TraceInformation("Executing python flame temp plot generation...");
dynamic resultPyObj = pyHyramLib.phys.capi.create_flame_temp_plot(
ambPressure, ambTemp, h2Pressure, h2Temp, orificeDiam, y0, releaseAngle, nozzleModelKey,
dataDirLoc, isDebug
);
Trace.TraceInformation("Python call complete. Processing results...");
plotFilepath = (string)resultPyObj;
Debug.WriteLine(" Created plot: " + plotFilepath);
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
throw new InvalidOperationException(
"Error during flame temp plot generation. Check log for details.");
}
finally
{
pyGC.InvokeMethod("collect");
pyGC.Dispose();
pyHyramLib.Dispose();
}
}
return(plotFilepath);
}
/// <summary>
/// Create plume plot via python
/// </summary>
/// <param name="ambientPressure"></param>
/// <param name="ambientTemp"></param>
/// <param name="h2Pressure"></param>
/// <param name="h2Temp"></param>
/// <param name="orificeDiam"></param>
/// <param name="dischargeCoeff"></param>
/// <param name="xMin"></param>
/// <param name="xMax"></param>
/// <param name="yMin"></param>
/// <param name="yMax"></param>
/// <param name="contours"></param>
/// <param name="jetAngle"></param>
/// <param name="plotTitle"></param>
/// <returns></returns>
public string CreatePlumePlot(
double ambientPressure, double ambientTemp, double h2Pressure, double h2Temp, double orificeDiam,
double dischargeCoeff, double xMin, double xMax, double yMin, double yMax, double contours, double jetAngle, string plotTitle)
{
bool isDebug = QraStateContainer.GetValue <bool>("debug");
string dataDirLoc = QraStateContainer.UserDataDir;
string plotFilepath;
Trace.TraceInformation("Acquiring python lock and importing module...");
using (Py.GIL())
{
dynamic pyGC = Py.Import("gc");
dynamic pyHyramLib = Py.Import("hyram");
try
{
// Execute python function call. Will return PyObject containing results.
Trace.TraceInformation("Executing python plume call...");
dynamic resultPyObj = pyHyramLib.phys.capi.create_plume_plot(
ambientPressure, ambientTemp, h2Pressure, h2Temp, orificeDiam, dischargeCoeff, xMin, xMax, yMin, yMax, contours,
jetAngle, plotTitle, dataDirLoc, isDebug
);
plotFilepath = (string)resultPyObj;
resultPyObj.Dispose();
Trace.TraceInformation("Python call complete. Created plot: " + plotFilepath);
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
throw new InvalidOperationException("Error during plume plot generation. Check log for details.");
}
finally
{
pyGC.InvokeMethod("collect");
pyGC.Dispose();
pyHyramLib.Dispose();
}
}
return(plotFilepath);
}
private void frmQFEMain_Load(object sender, EventArgs e)
{
// Delete old temp files from prev runs
QuickFunctions.ClearOldTemporaryFiles();
ActiveScreen = this;
tcNav.TabPages.Remove(tpNfpa2Mode);
tcNav.TabPages.Remove(tpTests);
tcNav.SelectedIndex = 0;
tcNav.SelectedTab = null;
tcNav.SelectedTab = tpQraMode;
// Populate fuel selection dropdowns.
// One dropdown on phys UI, one on QRA. Both sync to same backend param.
fuelTypePhys.DataSource = QraStateContainer.Instance.FuelTypes;
fuelTypePhys.SelectedItem = QraStateContainer.GetValue <FuelType>("FuelType");
fuelTypeQra.DataSource = QraStateContainer.Instance.FuelTypes;
fuelTypeQra.SelectedItem = QraStateContainer.GetValue <FuelType>("FuelType");
}
private void FillIgnitionProbabilitiesTable()
{
_mIgnoringChangeEvents = true;
var ignitionThresholds = QraStateContainer.GetValue <double[]>("IgnitionThresholds");
if (ignitionThresholds.Length > 0)
{
dgIgnitionProbabilities.Rows.Add("<" + ignitionThresholds[0], "", "");
for (var i = 1; i < ignitionThresholds.Length; ++i)
{
dgIgnitionProbabilities.Rows.Add(ignitionThresholds[i - 1] + "-" + ignitionThresholds[i], "", "");
}
dgIgnitionProbabilities.Rows.Add("\u2265" + ignitionThresholds[ignitionThresholds.Length - 1], "", "");
FillIgnitionProbabilitiesTableFromMemory();
}
_mIgnoringChangeEvents = false;
}
private void Execute()
{
// Blanket try block to help catch deployed issue Brian encountered
Trace.TraceInformation("Gathering parameters for radiative flux analysis...");
try
{
var ambTemp = QraStateContainer.GetNdValue("SysParam.ExternalTempC", TempUnit.Kelvin);
var ambPressure = QraStateContainer.GetNdValue("SysParam.ExternalPresMPA", PressureUnit.Pa);
var h2Temp = QraStateContainer.GetNdValue("FlameWrapper.T_H2", TempUnit.Kelvin);
var h2Pressure = QraStateContainer.GetNdValue("FlameWrapper.P_H2", PressureUnit.Pa);
var orificeDiam = QraStateContainer.GetNdValue("FlameWrapper.d_orifice", DistanceUnit.Meter);
var leakHeight = QraStateContainer.GetNdValue("FlameWrapper.ReleaseHeight", DistanceUnit.Meter);
_radHeatFluxX =
QraStateContainer.GetNdValueList("FlameWrapper.radiative_heat_flux_point:x", DistanceUnit.Meter);
_radHeatFluxY =
QraStateContainer.GetNdValueList("FlameWrapper.radiative_heat_flux_point:y", DistanceUnit.Meter);
_radHeatFluxZ =
QraStateContainer.GetNdValueList("FlameWrapper.radiative_heat_flux_point:z", DistanceUnit.Meter);
var contourLevels =
QraStateContainer.GetNdValueList("FlameWrapper.contour_levels", UnitlessUnit.Unitless);
var relativeHumidity = QraStateContainer.GetNdValue("FlameWrapper.RH", UnitlessUnit.Unitless);
var notionalNozzleModel = QraStateContainer.GetValue <NozzleModel>("NozzleModel");
var releaseAngle = QraStateContainer.GetNdValue("OpWrapper.ReleaseAngle", AngleUnit.Radians);
var radiativeSourceModel =
QraStateContainer.GetValue <RadiativeSourceModels>("RadiativeSourceModel");
Trace.TraceInformation("Creating PhysInterface for python call");
var physInt = new PhysInterface();
physInt.AnalyzeRadiativeHeatFlux(ambTemp, ambPressure, h2Temp, h2Pressure, orificeDiam, leakHeight,
releaseAngle,
notionalNozzleModel, _radHeatFluxX, _radHeatFluxY, _radHeatFluxZ, relativeHumidity,
radiativeSourceModel,
contourLevels, out _fluxData, out _fluxPlotFilepath, out _tempPlotFilepath);
Trace.TraceInformation("PhysInterface call complete");
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
MessageBox.Show(@"Heat flux analysis failed, please try again. Check log for details.");
}
}
private void ExtractAndSaveXyzValues()
{
if (!_mIgnoreXyzChangeEvent)
{
var xValues =
ArrayFunctions.ExtractFloatArrayFromDelimitedString(tbRadiativeHeatFluxPointsX.Text, ',');
var yValues =
ArrayFunctions.ExtractFloatArrayFromDelimitedString(tbRadiativeHeatFluxPointsY.Text, ',');
var zValues =
ArrayFunctions.ExtractFloatArrayFromDelimitedString(tbRadiativeHeatFluxPointsZ.Text, ',');
if (xValues.Length == yValues.Length && yValues.Length == zValues.Length && zValues.Length > 0)
{
QraStateContainer.SetValue("FlameWrapper.radiative_heat_flux_point:x",
new NdConvertibleValue(StockConverters.DistanceConverter, DistanceUnit.Meter, xValues));
QraStateContainer.SetValue("FlameWrapper.radiative_heat_flux_point:y",
new NdConvertibleValue(StockConverters.DistanceConverter, DistanceUnit.Meter, yValues));
QraStateContainer.SetValue("FlameWrapper.radiative_heat_flux_point:z",
new NdConvertibleValue(StockConverters.DistanceConverter, DistanceUnit.Meter, zValues));
}
}
}
private void GenerateResults()
{
ContentPanel.SetNarrative(this, Narratives.SS__ScenarioStats);
var result = QraStateContainer.GetValue <QraResult>("Result");
// Set risk metrics
dgRiskMetrics.Rows[0].Cells[1].Value = result.TotalPll;
dgRiskMetrics.Rows[1].Cells[1].Value = result.Far;
dgRiskMetrics.Rows[2].Cells[1].Value = result.Air;
var curRow = 1;
for (var i = 0; i < result.LeakResults.Count; i++)
{
var leakRes = result.LeakResults[i];
dgRanking.Rows.Add(curRow++, leakRes.GetLeakSizeString(), "Shutdown", leakRes.ShutdownAvgEvents,
leakRes.ProbShutdown, 0);
dgRanking.Rows.Add(curRow++, leakRes.GetLeakSizeString(), "Jet fire", leakRes.JetfireAvgEvents,
leakRes.ProbJetfire, leakRes.JetfirePllContrib);
dgRanking.Rows.Add(curRow++, leakRes.GetLeakSizeString(), "Explosion", leakRes.ExplosAvgEvents,
leakRes.ProbExplosion, leakRes.ExplosionPllContrib);
dgRanking.Rows.Add(curRow++, leakRes.GetLeakSizeString(), "No ignition", leakRes.NoIgnAvgEvents,
leakRes.ProbNoIgnition, 0);
}
// Load position plots
pbPositionPlot000d01.SizeMode = PictureBoxSizeMode.Zoom;
pbPositionPlot000d01.Load(result.PositionPlotFilenames[0]);
pbPositionPlot000d10.Load(result.PositionPlotFilenames[1]);
pbPositionPlot001d00.Load(result.PositionPlotFilenames[2]);
pbPositionPlot010d00.Load(result.PositionPlotFilenames[3]);
pbPositionPlot100d00.Load(result.PositionPlotFilenames[4]);
// Add cut set data
PopulateCutSetTable(CutSetDGV000d01, result.LeakResults[0], false);
PopulateCutSetTable(CutSetDGV000d10, result.LeakResults[1], false);
PopulateCutSetTable(CutSetDGV001d00, result.LeakResults[2], false);
PopulateCutSetTable(CutSetDGV010d00, result.LeakResults[3], false);
PopulateCutSetTable(CutSetDGV100d00, result.LeakResults[4], true);
}
private void Execute()
{
var ambPressure = QraStateContainer.GetNdValue("SysParam.ExternalPresMPA", PressureUnit.Pa);
var ambTemp = QraStateContainer.GetNdValue("SysParam.ExternalTempC", TempUnit.Kelvin);
var h2Pressure = QraStateContainer.GetNdValue("FlameWrapper.P_H2", PressureUnit.Pa);
var h2Temp = QraStateContainer.GetNdValue("FlameWrapper.T_H2", TempUnit.Kelvin);
var orificeDiam = QraStateContainer.GetNdValue("FlameWrapper.d_orifice", DistanceUnit.Meter);
var dischargeCoeff = QraStateContainer.GetNdValue("OpWrapper.Cd0", UnitlessUnit.Unitless);
var xMin = QraStateContainer.GetNdValue("PlumeWrapper.XMin", DistanceUnit.Meter);
var xMax = QraStateContainer.GetNdValue("PlumeWrapper.XMax", DistanceUnit.Meter);
var yMin = QraStateContainer.GetNdValue("PlumeWrapper.YMin", DistanceUnit.Meter);
var yMax = QraStateContainer.GetNdValue("PlumeWrapper.YMax", DistanceUnit.Meter);
var contours = QraStateContainer.GetNdValue("PlumeWrapper.Contours", UnitlessUnit.Unitless);
var jetAngle = QraStateContainer.GetNdValue("PlumeWrapper.jet_angle", AngleUnit.Radians);
var plotTitle = QraStateContainer.GetValue <string>("PlumeWrapper.PlotTitle");
var physInt = new PhysInterface();
_plotFilename = physInt.CreatePlumePlot(
ambPressure, ambTemp, h2Pressure, h2Temp, orificeDiam, dischargeCoeff, xMin, xMax, yMin, yMax, contours,
jetAngle, plotTitle);
}
private void cbNotionalNozzleModel_SelectedIndexChanged(object sender, EventArgs e)
{
if (DesignMode)
{
return;
}
var newModel = NozzleModel.ParseNozzleModelName(cbNotionalNozzleModel.SelectedItem.ToString());
QraStateContainer.SetValue("NozzleModel", newModel);
//QraStateContainer.Instance.SetNozzleModel((string)cbNotionalNozzleModel.SelectedItem);
var oldValue = _mNozzleModelSelected;
//string NozzleName = QraStateContainer.Instance.GetObject("NotionalNozzleModel").ToString();
//mNozzleModelSelected = QraStateContainer.Instance.GetNozzleModel();
var oldModel = QraStateContainer.GetValue <NozzleModel>("NozzleModel");
if (_mNozzleModelSelected != oldValue)
{
SpawnNotionalNozzleModelChangedEvent();
}
}
private void Execute()
{
var ambTemp = QraStateContainer.Instance.GetStateDefinedValueObject("SysParam.ExternalTempC")
.GetValue(TempUnit.Kelvin)[0];
var ambPres = QraStateContainer.Instance.GetStateDefinedValueObject("SysParam.ExternalPresMPA")
.GetValue(PressureUnit.Pa)[0];
var h2Temp = QraStateContainer.Instance.GetStateDefinedValueObject("FlameWrapper.T_H2")
.GetValue(TempUnit.Kelvin)[0];
var h2Pres = QraStateContainer.Instance.GetStateDefinedValueObject("FlameWrapper.P_H2")
.GetValue(PressureUnit.Pa)[0];
var orificeDiam = QraStateContainer.Instance.GetStateDefinedValueObject("FlameWrapper.d_orifice")
.GetValue(DistanceUnit.Meter)[0];
var y0 = QraStateContainer.Instance.GetStateDefinedValueObject("FlameWrapper.ReleaseHeight")
.GetValue(DistanceUnit.Meter)[0];
var releaseAngle = QraStateContainer.Instance.GetStateDefinedValueObject("OpWrapper.ReleaseAngle")
.GetValue(AngleUnit.Radians)[0];
var nozzleModel = QraStateContainer.GetValue <NozzleModel>("NozzleModel");
var physInt = new PhysInterface();
_resultImageFilepath = physInt.CreateFlameTemperaturePlot(ambTemp, ambPres, h2Temp, h2Pres, orificeDiam, y0,
releaseAngle, nozzleModel.GetKey());
}
private void fuelTypeQra_SelectionChangeCommitted(object sender, EventArgs e)
{
QraStateContainer.SetValue("FuelType", fuelTypePhys.SelectedItem);
}
void IQraBaseNotify.Notify_LoadComplete()
{
SetNarrative();
QraStateContainer.SetValue("ResultsAreStale", true);
}
/// <summary>
/// Parse selected string into Notional Nozzle Model and store it.
/// </summary>
private void cbNotionalNozzleModel_SelectionChangeCommitted(object sender, EventArgs e)
{
var model = (NozzleModel)cbNotionalNozzleModel.SelectedItem;
QraStateContainer.SetValue("NozzleModel", model);
}
private void WritePs(PressureUnit unit, double[] values)
{
var valueObj = new NdConvertibleValue(StockConverters.PressureConverter, unit, values);
QraStateContainer.SetValue("P_s", valueObj);
}
