/*protected void BalanceDryingGasStreamHumidity(DryingGasStream inlet, DryingGasStream outlet) {
* //For a drying gas stream going through a heater, absolute humidity does not change from inlet to outlet
* //if (inlet.Humidity.Value != Constants.NO_VALUE && !(outlet.Humidity.IsSpecified && outlet.Humidity.Value != Constants.NO_VALUE)) {
* if (inlet.Humidity.Value != Constants.NO_VALUE && outlet.Humidity.Value == Constants.NO_VALUE) {
* Calculate(outlet.MoistureContentDryBase, inlet.Humidity.Value);
* }
* //else if (outlet.Humidity.Value != Constants.NO_VALUE && !(inlet.Humidity.IsSpecified && inlet.Humidity.Value != Constants.NO_VALUE)) {
* else if (outlet.Humidity.Value != Constants.NO_VALUE && inlet.Humidity.Value == Constants.NO_VALUE) {
* Calculate(inlet.MoistureContentDryBase, outlet.Humidity.Value);
* }
* }*/
protected void BalanceDryingStreamMoistureContent(DryingStream inlet, DryingStream outlet)
{
//For a drying gas stream going through a heater, absolute humidity does not change from inlet to outlet
//if (inlet.Humidity.Value != Constants.NO_VALUE && !(outlet.Humidity.IsSpecified && outlet.Humidity.Value != Constants.NO_VALUE)) {
if (inlet.MoistureContentDryBase.HasValue && !outlet.MoistureContentDryBase.HasValue)
{
Calculate(outlet.MoistureContentDryBase, inlet.MoistureContentDryBase.Value);
}
//else if (outlet.Humidity.Value != Constants.NO_VALUE && !(inlet.Humidity.IsSpecified && inlet.Humidity.Value != Constants.NO_VALUE)) {
else if (outlet.MoistureContentDryBase.HasValue && !inlet.MoistureContentDryBase.HasValue)
{
Calculate(inlet.MoistureContentDryBase, outlet.MoistureContentDryBase.Value);
}
else if (inlet.MoistureContentWetBase.HasValue && !outlet.MoistureContentWetBase.HasValue)
{
Calculate(outlet.MoistureContentWetBase, inlet.MoistureContentWetBase.Value);
}
else if (outlet.MoistureContentWetBase.HasValue && !inlet.MoistureContentWetBase.HasValue)
{
Calculate(inlet.MoistureContentWetBase, outlet.MoistureContentWetBase.Value);
}
/*if (inlet.Concentration.Value != Constants.NO_VALUE && outlet.Concentration.Value == Constants.NO_VALUE) {
* Calculate(outlet.Concentration, inlet.Concentration.Value);
* }
* else if (outlet.MoistureContentWetBase.Value != Constants.NO_VALUE && inlet.Concentration.Value == Constants.NO_VALUE) {
* Calculate(inlet.Concentration, outlet.Concentration.Value);
* }*/
}
protected void BalanceSpecificEnthalpy(ProcessStreamBase inletStream, ProcessStreamBase outletStream)
{
if (inletStream is DryingGasStream)
{
DryingStream inlet = inletStream as DryingStream;
DryingStream outlet = outletStream as DryingStream;
if (inlet.SpecificEnthalpyDryBase.HasValue && !outlet.SpecificEnthalpyDryBase.HasValue)
{
Calculate(outlet.SpecificEnthalpyDryBase, inlet.SpecificEnthalpyDryBase.Value);
}
else if (outlet.SpecificEnthalpyDryBase.HasValue && !inlet.SpecificEnthalpyDryBase.HasValue)
{
Calculate(inlet.SpecificEnthalpyDryBase, outlet.SpecificEnthalpyDryBase.Value);
}
}
else
{
if (inletStream.SpecificEnthalpy.HasValue && !outletStream.SpecificEnthalpy.HasValue)
{
Calculate(outletStream.SpecificEnthalpy, inletStream.SpecificEnthalpy.Value);
}
else if (outletStream.SpecificEnthalpy.HasValue && !inletStream.SpecificEnthalpy.HasValue)
{
Calculate(inletStream.SpecificEnthalpy, outletStream.SpecificEnthalpy.Value);
}
}
}
//protected void BalanceDryingMaterialStreamSpecificHeat(DryingMaterialStream inlet, DryingMaterialStream outlet) {
// if (inlet.SpecificHeatAbsDry.HasValue && !outlet.SpecificHeatAbsDry.HasValue) {
// Calculate(outlet.SpecificHeatAbsDry, inlet.SpecificHeatAbsDry.Value);
// }
// else if (outlet.SpecificHeatAbsDry.HasValue && !inlet.SpecificHeatAbsDry.HasValue) {
// Calculate(inlet.SpecificHeatAbsDry, outlet.SpecificHeatAbsDry.Value);
// }
//}
//protected void BalanceAdiabaticProcess(ProcessStreamBase inlet, ProcessStreamBase outlet) {
// if (inlet.Pressure.HasValue && outlet.Pressure.HasValue) {
// double t1;
// double t2;
// double k;
// double tempValue;
// double pRatio = outlet.Pressure.Value / inlet.Pressure.Value;
// if (inlet.Temperature.HasValue && !outlet.Temperature.HasValue) {
// k = inlet.GetSpecificHeatRatio(inlet.Temperature.Value);
// tempValue = Math.Pow(pRatio, (k - 1.0) / k);
// t2 = inlet.Temperature.Value * tempValue;
// Calculate(outlet.Temperature, t2);
// }
// else if (outlet.Temperature.HasValue && !inlet.Temperature.HasValue) {
// k = inlet.GetSpecificHeatRatio(inlet.Temperature.Value);
// tempValue = Math.Pow(pRatio, (k - 1.0) / k);
// t1 = outlet.Temperature.Value / tempValue;
// Calculate(inlet.Temperature, t1);
// }
// }
//}
protected void AdjustVarsStates(DryingStream dsInlet, DryingStream dsOutlet)
{
if (dsInlet.MassFlowRate.IsSpecifiedAndHasValue)
//if (dsInlet.MassFlowRate.HasValue)
{
dsOutlet.MassFlowRate.State = VarState.Calculated;
dsOutlet.MassFlowRateDryBase.State = VarState.Calculated;
dsOutlet.VolumeFlowRate.State = VarState.Calculated;
dsOutlet.HasVarStateChanged = true;
}
else if (dsInlet.MassFlowRateDryBase.IsSpecifiedAndHasValue)
//else if (dsInlet.MassFlowRateDryBase.HasValue)
{
dsOutlet.MassFlowRate.State = VarState.Calculated;
dsOutlet.VolumeFlowRate.State = VarState.Calculated;
dsOutlet.HasVarStateChanged = true;
}
else if (dsInlet.VolumeFlowRate.IsSpecifiedAndHasValue)
//else if (dsInlet.VolumeFlowRate.HasValue)
{
dsOutlet.MassFlowRate.State = VarState.Calculated;
dsOutlet.MassFlowRateDryBase.State = VarState.Calculated;
dsOutlet.VolumeFlowRate.State = VarState.Calculated;
dsOutlet.HasVarStateChanged = true;
}
else if (dsOutlet.MassFlowRate.IsSpecifiedAndHasValue)
//else if (dsOutlet.MassFlowRate.HasValue)
{
dsInlet.MassFlowRate.State = VarState.Calculated;
dsInlet.MassFlowRateDryBase.State = VarState.Calculated;
dsInlet.VolumeFlowRate.State = VarState.Calculated;
dsInlet.HasVarStateChanged = true;
}
else if (dsOutlet.MassFlowRateDryBase.IsSpecifiedAndHasValue)
//else if (dsOutlet.MassFlowRateDryBase.HasValue)
{
dsInlet.MassFlowRate.State = VarState.Calculated;
dsInlet.VolumeFlowRate.State = VarState.Calculated;
dsInlet.HasVarStateChanged = true;
}
else if (dsOutlet.VolumeFlowRate.IsSpecifiedAndHasValue)
//else if (dsOutlet.VolumeFlowRate.HasValue)
{
dsInlet.MassFlowRate.State = VarState.Calculated;
dsInlet.MassFlowRateDryBase.State = VarState.Calculated;
dsInlet.VolumeFlowRate.State = VarState.Calculated;
dsInlet.HasVarStateChanged = true;
}
}
private void Solve()
{
double totalFlow = 0.0;
double temp;
int numOfUnknownFlow = 0;
int unknownFlowIndex = -1;
DryingStream dryingStream;
DryingStream dsInlet;
DryingStream dsOutlet = null;
if (outlet is DryingStream)
{
dsOutlet = outlet as DryingStream;
}
////flow balance
//for (int i = 0; i < inletStreams.Count; i++) {
// inletStream = inletStreams[i] as ProcessStreamBase;
// if (inletStream.MassFlowRate.HasValue) {
// totalFlow += inletStream.MassFlowRate.Value;
// }
// else {
// unknownFlowIndex = i;
// numOfUnknownFlow++;
// }
//}
//if (numOfUnknownFlow == 1 && outlet.MassFlowRate.HasValue) {
// inletStream = inletStreams[unknownFlowIndex] as ProcessStreamBase;
// //if (outlet.MassFlowRate.Value > totalFlow && inletStream.MassFlowRate.IsSpecifiedAndHasNoValue)
// if (outlet.MassFlowRate.Value > totalFlow && !inletStream.MassFlowRate.HasValue) {
// Calculate(inletStream.MassFlowRate, (outlet.MassFlowRate.Value - totalFlow));
// }
//}
//else if (numOfUnknownFlow == 0) {
// Calculate(outlet.MassFlowRate, totalFlow);
//}
//double inletTotal = 0.0;
//int numOfUnknownInlet = 0;
//int unknownInletIndex = -1;
//moisture content balance
//if (outlet is DryingStream) {
// double mcDryBase;
// double mcWetBase;
// for (int i = 0; i < inletStreams.Count; i++) {
// dsInlet = inletStreams[i] as DryingStream;
// mcWetBase = Constants.NO_VALUE;
// if (dsInlet.MoistureContentWetBase.HasValue) {
// mcWetBase = dsInlet.MoistureContentWetBase.Value;
// }
// else if (dsInlet.MoistureContentDryBase.HasValue) {
// mcDryBase = dsInlet.MoistureContentDryBase.Value;
// mcWetBase = mcDryBase/(1.0 + mcDryBase);
// }
// if (dsInlet.MassFlowRate.HasValue && mcWetBase != Constants.NO_VALUE) {
// //inletTotal += dsInlet.MassFlowRate.Value * mcDryBase/(1.0 + mcDryBase);
// inletTotal += dsInlet.MassFlowRate.Value * mcWetBase;
// }
// else {
// unknownInletIndex = i;
// numOfUnknownInlet++;
// }
// }
// mcDryBase = dsOutlet.MoistureContentDryBase.Value;
// if (numOfUnknownInlet == 1 && dsOutlet.MassFlowRate.HasValue && mcDryBase != Constants.NO_VALUE) {
// dsInlet = inletStreams[unknownInletIndex] as DryingStream;
// double outletMoisture = dsOutlet.MassFlowRate.Value * mcDryBase/(1.0 + mcDryBase);
// if (outletMoisture > inletTotal) {
// //if (dsInlet.MassFlowRate.HasValue && dsInlet.MoistureContentWetBase.IsSpecifiedAndHasNoValue) {
// if (dsInlet.MassFlowRate.HasValue && !dsInlet.MoistureContentWetBase.HasValue) {
// mcWetBase = (outletMoisture - inletTotal)/dsInlet.MassFlowRate.Value;
// Calculate(dsInlet.MoistureContentWetBase, mcWetBase);
// }
// //else if (dsInlet.MassFlowRate.HasValue && dsInlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
// else if (dsInlet.MassFlowRate.HasValue && !dsInlet.MoistureContentDryBase.HasValue) {
// mcWetBase = (outletMoisture - inletTotal)/dsInlet.MassFlowRate.Value;
// Calculate(dsInlet.MoistureContentDryBase, mcWetBase/(1.0 - mcWetBase));
// }
// //else if (dsInlet.MassFlowRateDryBase.HasValue && dsInlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
// else if (dsInlet.MassFlowRateDryBase.HasValue && !dsInlet.MoistureContentDryBase.HasValue) {
// mcDryBase = (outletMoisture - inletTotal)/dsInlet.MassFlowRateDryBase.Value;
// Calculate(dsInlet.MoistureContentDryBase, mcDryBase);
// }
// //else if (dsInlet.MoistureContentDryBase.HasValue && dsInlet.MassFlowRateDryBase.IsSpecifiedAndHasNoValue) {
// else if (dsInlet.MoistureContentDryBase.HasValue && !dsInlet.MassFlowRateDryBase.HasValue) {
// double massFlowDryBase = (outletMoisture - inletTotal)/dsInlet.MoistureContentDryBase.Value;
// Calculate(dsInlet.MassFlowRateDryBase, massFlowDryBase);
// }
// //else if (dsInlet.MoistureContentDryBase.HasValue && dsInlet.MassFlowRate.IsSpecifiedAndHasNoValue) {
// else if (dsInlet.MoistureContentDryBase.HasValue && !dsInlet.MassFlowRate.HasValue) {
// mcDryBase = dsInlet.MoistureContentDryBase.Value;
// double massFlow = (outletMoisture - inletTotal)/mcDryBase * (1.0 + mcDryBase);
// Calculate(dsInlet.MassFlowRate, massFlow);
// }
// }
// }
// else if (numOfUnknownInlet == 0) {
// //if (dsOutlet.MassFlowRate.HasValue && dsOutlet.MoistureContentWetBase.IsSpecifiedAndHasNoValue) {
// if (dsOutlet.MassFlowRate.HasValue && !dsOutlet.MoistureContentWetBase.HasValue) {
// mcWetBase = inletTotal/dsOutlet.MassFlowRate.Value;
// Calculate(dsOutlet.MoistureContentWetBase, mcWetBase);
// }
// //else if (dsOutlet.MassFlowRate.HasValue && dsOutlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
// else if (dsOutlet.MassFlowRate.HasValue && !dsOutlet.MoistureContentDryBase.HasValue) {
// mcWetBase = inletTotal/dsOutlet.MassFlowRate.Value;
// Calculate(dsOutlet.MoistureContentDryBase, mcWetBase/(1.0 - mcWetBase));
// }
// //else if (dsOutlet.MassFlowRateDryBase.HasValue && dsOutlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
// else if (dsOutlet.MassFlowRateDryBase.HasValue && !dsOutlet.MoistureContentDryBase.HasValue) {
// mcDryBase = inletTotal/dsOutlet.MassFlowRateDryBase.Value;
// Calculate(dsOutlet.MoistureContentDryBase, mcDryBase);
// }
// //else if (dsOutlet.MoistureContentDryBase.HasValue && dsOutlet.MassFlowRateDryBase.IsSpecifiedAndHasNoValue) {
// else if (dsOutlet.MoistureContentDryBase.HasValue && !dsOutlet.MassFlowRateDryBase.HasValue) {
// double massFlowDryBase = inletTotal/dsOutlet.MoistureContentDryBase.Value;
// Calculate(dsOutlet.MassFlowRateDryBase, massFlowDryBase);
// }
// //else if (dsOutlet.MoistureContentDryBase.HasValue && dsOutlet.MassFlowRate.IsSpecifiedAndHasNoValue) {
// else if (dsOutlet.MoistureContentDryBase.HasValue && !dsOutlet.MassFlowRate.HasValue) {
// mcDryBase = dsOutlet.MoistureContentDryBase.Value;
// double massFlow = inletTotal/mcDryBase * (1.0 + mcDryBase);
// Calculate(dsOutlet.MassFlowRate, massFlow);
// }
// }
//}
double inletTotal = 0.0;
int numOfUnknownInlet = 0;
int unknownInletIndex = -1;
if (outlet is DryingGasStream)
{
DryingGasStream dgsInlet;
for (int i = 0; i < inletStreams.Count; i++)
{
dgsInlet = inletStreams[i] as DryingGasStream;
if (dgsInlet.MassFlowRateDryBase.HasValue)
{
totalFlow += dgsInlet.MassFlowRateDryBase.Value;
}
else
{
unknownFlowIndex = i;
numOfUnknownFlow++;
}
}
if (numOfUnknownFlow == 1 && dsOutlet.MassFlowRateDryBase.HasValue)
{
dsInlet = inletStreams[unknownFlowIndex] as DryingGasStream;
if (dsOutlet.MassFlowRateDryBase.Value > totalFlow && !dsInlet.MassFlowRateDryBase.HasValue)
{
Calculate(dsInlet.MassFlowRateDryBase, (dsOutlet.MassFlowRateDryBase.Value - totalFlow));
}
}
else if (numOfUnknownFlow == 0)
{
Calculate(dsOutlet.MassFlowRateDryBase, totalFlow);
}
for (int i = 0; i < inletStreams.Count; i++)
{
dgsInlet = inletStreams[i] as DryingGasStream;
if (dgsInlet.MoistureContentDryBase.HasValue && dgsInlet.MassFlowRateDryBase.HasValue)
{
inletTotal += dgsInlet.MassFlowRateDryBase.Value * dgsInlet.MoistureContentDryBase.Value;
}
else
{
unknownInletIndex = i;
numOfUnknownInlet++;
}
}
if (numOfUnknownInlet == 1 && dsOutlet.MassFlowRateDryBase.HasValue && dsOutlet.MoistureContentDryBase.HasValue)
{
dgsInlet = inletStreams[unknownInletIndex] as DryingGasStream;
double outletMoisture = dsOutlet.MassFlowRateDryBase.Value * dsOutlet.MoistureContentDryBase.Value;
if (outletMoisture > inletTotal)
{
if (dgsInlet.MassFlowRateDryBase.HasValue && !dgsInlet.MoistureContentDryBase.HasValue)
{
double mcDryBase = (outletMoisture - inletTotal) / dgsInlet.MassFlowRateDryBase.Value;
Calculate(dgsInlet.MoistureContentDryBase, mcDryBase);
}
else if (dgsInlet.MoistureContentDryBase.HasValue && !dgsInlet.MassFlowRateDryBase.HasValue)
{
double massFlowDryBase = (outletMoisture - inletTotal) / dgsInlet.MoistureContentDryBase.Value;
Calculate(dgsInlet.MassFlowRateDryBase, massFlowDryBase);
}
}
else
{
throw new CalculationFailedException(this.name + "Total mositure content from inlets is greater than that of the outlet");
}
}
else if (numOfUnknownInlet == 0)
{
if (dsOutlet.MassFlowRateDryBase.HasValue && !dsOutlet.MoistureContentDryBase.HasValue)
{
double mcDryBase = inletTotal / dsOutlet.MassFlowRateDryBase.Value;
Calculate(dsOutlet.MoistureContentDryBase, mcDryBase);
}
else if (dsOutlet.MoistureContentDryBase.HasValue && !dsOutlet.MassFlowRateDryBase.HasValue)
{
double massFlowDryBase = inletTotal / dsOutlet.MoistureContentDryBase.Value;
Calculate(dsOutlet.MassFlowRateDryBase, massFlowDryBase);
}
}
}
else if (outlet is DryingMaterialStream)
{
DryingMaterialStream dmsInlet;
for (int i = 0; i < inletStreams.Count; i++)
{
dmsInlet = inletStreams[i] as DryingMaterialStream;
if (dmsInlet.MassFlowRate.HasValue)
{
totalFlow += dmsInlet.MassFlowRate.Value;
}
else
{
unknownFlowIndex = i;
numOfUnknownFlow++;
}
}
if (numOfUnknownFlow == 1 && outlet.MassFlowRate.HasValue)
{
dmsInlet = inletStreams[unknownFlowIndex] as DryingMaterialStream;
if (outlet.MassFlowRate.Value > totalFlow && !dmsInlet.MassFlowRate.HasValue)
{
Calculate(dmsInlet.MassFlowRate, (outlet.MassFlowRate.Value - totalFlow));
}
}
else if (numOfUnknownFlow == 0)
{
Calculate(outlet.MassFlowRate, totalFlow);
}
for (int i = 0; i < inletStreams.Count; i++)
{
dmsInlet = inletStreams[i] as DryingMaterialStream;
if (dmsInlet.MassFlowRate.HasValue && dmsInlet.MoistureContentWetBase.HasValue)
{
inletTotal += dmsInlet.MassFlowRate.Value * dmsInlet.MoistureContentWetBase.Value;
}
else
{
unknownInletIndex = i;
numOfUnknownInlet++;
}
}
if (numOfUnknownInlet == 1 && dsOutlet.MassFlowRate.HasValue && dsOutlet.MoistureContentWetBase.HasValue)
{
dmsInlet = inletStreams[unknownInletIndex] as DryingMaterialStream;
double outletMoisture = dsOutlet.MassFlowRate.Value * dsOutlet.MoistureContentWetBase.Value;
if (outletMoisture > inletTotal)
{
if (dmsInlet.MassFlowRate.HasValue && !dmsInlet.MoistureContentWetBase.HasValue)
{
double mcWetBase = (outletMoisture - inletTotal) / dmsInlet.MassFlowRate.Value;
Calculate(dmsInlet.MoistureContentWetBase, mcWetBase);
}
else if (dmsInlet.MoistureContentWetBase.HasValue && !dmsInlet.MassFlowRate.HasValue)
{
double massFlow = (outletMoisture - inletTotal) / dmsInlet.MoistureContentWetBase.Value;
Calculate(dmsInlet.MassFlowRate, massFlow);
}
}
else
{
throw new CalculationFailedException(this.name + "Total mositure content from inlets is greater than that of the outlet");
}
}
else if (numOfUnknownInlet == 0)
{
if (dsOutlet.MassFlowRate.HasValue && !dsOutlet.MoistureContentWetBase.HasValue)
{
double mcWetBase = inletTotal / dsOutlet.MassFlowRate.Value;
Calculate(dsOutlet.MoistureContentWetBase, mcWetBase);
}
else if (dsOutlet.MoistureContentWetBase.HasValue && !dsOutlet.MassFlowRate.HasValue)
{
double massFlow = inletTotal / dsOutlet.MoistureContentWetBase.Value;
Calculate(dsOutlet.MassFlowRate, massFlow);
}
}
}
//have to recalculate the streams so that the following balance calcualtion
//can have all the latest balance calculated values taken into account
UpdateStreamsIfNecessary();
inletTotal = 0.0;
numOfUnknownInlet = 0;
unknownInletIndex = -1;
double inletTotalDryBase = 0.0;
int numOfUnknownInletDryBase = 0;
int unknownInletIndexDryBase = -1;
ProcessStreamBase inletStream;
for (int i = 0; i < inletStreams.Count; i++)
{
inletStream = inletStreams[i] as ProcessStreamBase;
if (inletStream.MassFlowRate.HasValue && inletStream.SpecificEnthalpy.HasValue)
{
inletTotal += inletStream.MassFlowRate.Value * inletStream.SpecificEnthalpy.Value;
}
else
{
unknownInletIndex = i;
numOfUnknownInlet++;
}
if (outlet is DryingStream)
{
dsInlet = inletStream as DryingStream;
if (dsInlet.MassFlowRateDryBase.HasValue && dsInlet.SpecificEnthalpyDryBase.HasValue)
{
inletTotalDryBase += dsInlet.MassFlowRateDryBase.Value * dsInlet.SpecificEnthalpyDryBase.Value;
}
else
{
unknownInletIndexDryBase = i;
numOfUnknownInletDryBase++;
}
}
}
HumidGasCalculator humidGasCalculator = GetHumidGasCalculator();
if (numOfUnknownInletDryBase == 1 &&
(dsOutlet.MassFlowRate.HasValue && dsOutlet.SpecificEnthalpy.HasValue))
{
dsInlet = inletStreams[unknownInletIndexDryBase] as DryingStream;
double outletEnergy = dsOutlet.MassFlowRate.Value * dsOutlet.SpecificEnthalpy.Value;
if (outletEnergy > inletTotalDryBase)
{
if (dsInlet.MassFlowRate.HasValue && !dsInlet.SpecificEnthalpy.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.MassFlowRate.Value;
Calculate(dsInlet.SpecificEnthalpy, temp);
}
else if (dsInlet.MassFlowRateDryBase.HasValue && !dsInlet.SpecificEnthalpyDryBase.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.MassFlowRateDryBase.Value;
Calculate(dsInlet.SpecificEnthalpyDryBase, temp);
}
else if (dsInlet.SpecificEnthalpy.HasValue && !dsInlet.MassFlowRate.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.SpecificEnthalpy.Value;
Calculate(dsInlet.MassFlowRate, temp);
}
else if (dsInlet.SpecificEnthalpyDryBase.HasValue && !dsInlet.MassFlowRateDryBase.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.SpecificEnthalpyDryBase.Value;
Calculate(dsInlet.MassFlowRateDryBase, temp);
}
}
}
else if (numOfUnknownInletDryBase == 0)
{
if (dsOutlet.MassFlowRate.HasValue && !dsOutlet.SpecificEnthalpy.HasValue)
{
temp = inletTotalDryBase / dsOutlet.MassFlowRate.Value;
Calculate(dsOutlet.SpecificEnthalpy, temp);
}
if (dsOutlet.MassFlowRateDryBase.HasValue && !dsOutlet.SpecificEnthalpyDryBase.HasValue)
{
temp = inletTotalDryBase / dsOutlet.MassFlowRateDryBase.Value;
Calculate(dsOutlet.SpecificEnthalpyDryBase, temp);
}
else if (dsOutlet.SpecificEnthalpy.HasValue && !dsOutlet.MassFlowRate.HasValue)
{
temp = inletTotalDryBase / dsOutlet.SpecificEnthalpy.Value;
Calculate(dsOutlet.MassFlowRate, temp);
}
else if (dsOutlet.SpecificEnthalpyDryBase.HasValue && !dsOutlet.MassFlowRateDryBase.HasValue)
{
temp = inletTotalDryBase / dsOutlet.SpecificEnthalpyDryBase.Value;
Calculate(dsOutlet.MassFlowRateDryBase, temp);
}
}
else if (numOfUnknownInlet == 1 && outlet.MassFlowRate.HasValue && outlet.SpecificEnthalpy.HasValue &&
outlet.SpecificHeat.HasValue)
{
inletStream = inletStreams[unknownInletIndex] as ProcessStreamBase;
double outletEnergy = outlet.MassFlowRate.Value * outlet.Temperature.Value * outlet.SpecificHeat.Value;
if (outletEnergy > inletTotal)
{
if (inletStream.MassFlowRate.HasValue && !inletStream.SpecificEnthalpy.HasValue)
{
temp = (outletEnergy - inletTotal) / inletStream.MassFlowRate.Value;
Calculate(inletStream.SpecificEnthalpy, temp);
}
else if (inletStream.SpecificEnthalpy.HasValue && !inletStream.MassFlowRate.HasValue)
{
temp = (outletEnergy - inletTotal) / inletStream.SpecificEnthalpy.Value;
Calculate(inletStream.MassFlowRate, temp);
}
}
}
else if (numOfUnknownInlet == 0)
{
if (outlet.MassFlowRate.HasValue && !outlet.SpecificEnthalpy.HasValue)
{
temp = inletTotal / outlet.MassFlowRate.Value;
Calculate(outlet.SpecificEnthalpy, temp);
}
else if (outlet.SpecificEnthalpy.HasValue && !outlet.MassFlowRate.HasValue)
{
temp = inletTotal / outlet.SpecificEnthalpy.Value;
Calculate(outlet.MassFlowRate, temp);
}
}
ProcessStreamBase stream;
int numOfKnownMassFlow = 0;
int numOfKnownPressure = 0;
int numOfKnownTemperature = 0;
int numOfKnownMoistureContent = 0;
int numOfStrms = InOutletStreams.Count;
for (int i = 0; i < numOfStrms; i++)
{
stream = InOutletStreams[i] as ProcessStreamBase;
if (stream.MassFlowRate.HasValue)
{
numOfKnownMassFlow++;
}
if (stream.Pressure.HasValue)
{
numOfKnownPressure++;
}
if (stream.SpecificEnthalpy.HasValue)
{
numOfKnownTemperature++;
}
if (outlet is DryingStream)
{
dryingStream = stream as DryingStream;
if (dryingStream.MoistureContentDryBase.HasValue || dryingStream.MoistureContentWetBase.HasValue)
{
numOfKnownMoistureContent++;
}
}
}
if (numOfKnownMassFlow == numOfStrms && numOfKnownTemperature == numOfStrms)
{
if (outlet is ProcessStream && numOfKnownPressure == numOfStrms)
{
solveState = SolveState.Solved;
}
else if (outlet is DryingGasStream && numOfKnownPressure == numOfStrms && numOfKnownMoistureContent == numOfStrms)
{
solveState = SolveState.Solved;
}
else if (outlet is DryingMaterialStream && numOfKnownMoistureContent == numOfStrms)
{
solveState = SolveState.Solved;
}
}
if (solveState == SolveState.Solved && outlet is DryingGasStream)
{
double totalSolidPhaseMass = 0.0;
SolidPhase solidPhase = null;
SolidPhase lastSolidPhase = null;
foreach (DryingGasStream gasStream in inletStreams)
{
solidPhase = gasStream.GasComponents.SolidPhase;
if (solidPhase != null)
{
totalSolidPhaseMass += solidPhase.MassFraction * gasStream.MassFlowRate.Value;
lastSolidPhase = solidPhase;
}
}
if (lastSolidPhase != null)
{
double outletSolidPhaseMassFraction = totalSolidPhaseMass / outlet.MassFlowRate.Value;
DryingGasStream dgsOutlet = outlet as DryingGasStream;
SolidPhase outletSolidPhase = dgsOutlet.GasComponents.SolidPhase;
if (outletSolidPhase != null)
{
outletSolidPhase.MassFraction = outletSolidPhaseMassFraction;
}
else
{
outletSolidPhase = lastSolidPhase.Clone();
outletSolidPhase.MassFraction = outletSolidPhase.MassFraction;
dgsOutlet.GasComponents.SolidPhase = outletSolidPhase;
}
}
}
}
/*public override bool IsSolveReady() {
* bool isReady = false;
* if (inlet is DryingStream) {
* DryingStream dsInlet = inlet as DryingStream;
* if (dsInlet.MassFlowRateDryBase.HasValue && dsInlet.Temperature.HasValue &&
* dsInlet.MoistureContentDryBase.HasValue) {
* isReady = true;
* }
* }
*
* return isReady;
* }*/
public override void Execute(bool propagate)
{
isBeingExecuted = true;
//if (IsSolveReady() && inlet is DryingStream) {
if (inlet is DryingStream)
{
DryingStream dsInlet = inlet as DryingStream;
DryingStream dsOutlet = outlet as DryingStream;
if (dsInlet.Pressure.HasValue && !dsOutlet.Pressure.HasValue)
{
dsOutlet.Pressure.Value = dsInlet.Pressure.Value;
}
//else if (dsOutlet.Pressure.HasValue && !dsInlet.Pressure.HasValue) {
// dsInlet.Pressure.Value = dsOutlet.Pressure.Value;
//}
if (inlet is DryingMaterialStream)
{
BalanceDryingMaterialStreamSpecificHeat(inlet as DryingMaterialStream, outlet as DryingMaterialStream);
}
double oldMassFlowDryBasisValue;
double oldTemperatureValue;
double oldMoistureContentDryBasisValue;
double newMassFlowDryBasisValue = dsInlet.MassFlowRateDryBase.Value;
double newTemperatureValue = dsInlet.Temperature.Value;
double newMoistureContentDryBasisValue = dsInlet.MoistureContentDryBase.Value;
if (!dsInlet.MassFlowRateDryBase.HasValue)
{
newMassFlowDryBasisValue = 0.000;
}
if (!dsInlet.Temperature.HasValue)
{
newTemperatureValue = 274.15;
}
if (!dsInlet.MoistureContentDryBase.HasValue)
{
newMoistureContentDryBasisValue = 0.0000;
}
int counter = 0;
do
{
counter++;
dsOutlet.MassFlowRateDryBase.Value = newMassFlowDryBasisValue;
dsOutlet.Temperature.Value = newTemperatureValue;
dsOutlet.MoistureContentDryBase.Value = newMoistureContentDryBasisValue;
oldMassFlowDryBasisValue = newMassFlowDryBasisValue;
oldTemperatureValue = newTemperatureValue;
oldMoistureContentDryBasisValue = newMoistureContentDryBasisValue;
dsOutlet.HasBeenModified(true);
newMassFlowDryBasisValue = dsInlet.MassFlowRateDryBase.Value;
newTemperatureValue = dsInlet.Temperature.Value;
newMoistureContentDryBasisValue = dsInlet.MoistureContentDryBase.Value;
//newMassFlowDryBasisValue = oldMassFlowDryBasisValue + 0.75 * (dsInlet.MassFlowRateDryBase.Value - oldMassFlowDryBasisValue);
//newTemperatureValue = oldTemperatureValue + 0.75 * (dsInlet.Temperature.Value - oldTemperatureValue);
//newMoistureContentDryBasisValue = oldMoistureContentDryBasisValue + 0.75 * (dsInlet.MoistureContentDryBase.Value - oldMoistureContentDryBasisValue);
} while ((Math.Abs((newMassFlowDryBasisValue - oldMassFlowDryBasisValue) / oldMassFlowDryBasisValue) > 1.0e-8 ||
Math.Abs((newTemperatureValue - oldTemperatureValue) / oldTemperatureValue) > 1.0e-6 ||
Math.Abs((newMoistureContentDryBasisValue - oldMoistureContentDryBasisValue) / oldMoistureContentDryBasisValue) > 1.0e-6) &&
counter < 500);
if (counter == 500)
{
solveState = SolveState.SolveFailed;
}
else
{
if (inlet.HasSolvedAlready && outlet.HasSolvedAlready)
{
solveState = SolveState.Solved;
}
//debug code
Trace.WriteLine(this.name + "Number of Iterations" + counter);
//debug code
}
dsOutlet.Pressure.State = VarState.Calculated;
dsOutlet.Temperature.State = VarState.Calculated;
dsOutlet.MassFlowRateDryBase.State = VarState.Calculated;
dsOutlet.MoistureContentDryBase.State = VarState.Calculated;
dsOutlet.OnSolveComplete(solveState);//has to call this so that the calculated state is updated on the uI
}
isBeingExecuted = false;
OnSolveComplete(solveState);
}
private void Solve()
{
double totalFraction = 0.0;
double totalFlow = 0.0;
double totalFlowDryBase = 0.0;
double fractionValue = 0.0;
int numOfUnknownFraction = 0;
int numOfUnknownFlow = 0;
int numOfUnknownFlowDryBase = 0;
int numOfKnown = 0;
int j = -1;
int k = -1;
int l = -1;
int fractionIndex = -1;
int numOfKnownPressure = 0;
int numOfKnownEnthalpy = 0;
int numOfKnownTemperature = 0;
ProcessStreamBase psb;
int unknownFlowIndex = -1;
int unknownFlowDryBaseIndex = -1;
double temp;
StreamAndFraction saf;
DryingStream dsInlet = null;
DryingStream dsOutlet;
if (inlet is DryingStream)
{
dsInlet = inlet as DryingStream;
}
for (int i = 0; i < outletStreamAndFractions.Count; i++)
{
saf = outletStreamAndFractions[i] as StreamAndFraction;
fractionValue = saf.Fraction.Value;
if (fractionValue != Constants.NO_VALUE)
{
totalFraction += fractionValue;
if (inlet.MassFlowRate.HasValue)
{
Calculate(saf.Stream.MassFlowRate, inlet.MassFlowRate.Value * fractionValue);
}
else if (saf.Stream.MassFlowRate.HasValue && fractionValue > 1.0e-6)
{
Calculate(inlet.MassFlowRate, saf.Stream.MassFlowRate.Value / fractionValue);
}
//inlet mass flow rate dry base is known
else if (inlet is DryingStream)
{
dsOutlet = saf.Stream as DryingStream;
if (dsInlet.MassFlowRateDryBase.HasValue)
{
Calculate(dsOutlet.MassFlowRateDryBase, dsInlet.MassFlowRateDryBase.Value * fractionValue);
}
else if (dsOutlet.MassFlowRateDryBase.HasValue && fractionValue > 1.0e-6)
{
Calculate(dsInlet.MassFlowRateDryBase, dsOutlet.MassFlowRateDryBase.Value / fractionValue);
}
}
}
else
{
bool fractionCalculated = false;
if (inlet.MassFlowRate.HasValue && saf.Stream.MassFlowRate.HasValue)
{
fractionCalculated = true;
fractionValue = saf.Stream.MassFlowRate.Value / inlet.MassFlowRate.Value;
if (fractionValue <= 1.0 && fractionValue >= 0.0)
{
Calculate(saf.Fraction, fractionValue);
totalFraction += fractionValue;
}
}
else if (inlet is DryingStream)
{
dsOutlet = saf.Stream as DryingStream;
if (dsInlet.MassFlowRateDryBase.HasValue && dsOutlet.MassFlowRateDryBase.HasValue)
{
fractionCalculated = true;
fractionValue = dsOutlet.MassFlowRateDryBase.Value / dsInlet.MassFlowRateDryBase.Value;
if (fractionValue <= 1.0 && fractionValue >= 0.0)
{
Calculate(saf.Fraction, fractionValue);
totalFraction += fractionValue;
}
}
}
if (!fractionCalculated)
{
fractionIndex = i;
numOfUnknownFraction++;
}
}
if (saf.Stream.MassFlowRate.HasValue)
{
totalFlow += saf.Stream.MassFlowRate.Value;
}
else
{
unknownFlowIndex = i;
numOfUnknownFlow++;
}
if (inlet is DryingStream)
{
dsOutlet = saf.Stream as DryingStream;
if (dsOutlet.MassFlowRateDryBase.HasValue)
{
totalFlowDryBase += dsOutlet.MassFlowRateDryBase.Value;
}
else
{
unknownFlowDryBaseIndex = i;
numOfUnknownFlowDryBase++;
}
}
}
//all fractions specified except one to be calculated
if (numOfUnknownFraction == 1)
{
saf = outletStreamAndFractions[fractionIndex] as StreamAndFraction;
fractionValue = (1.0 - totalFraction);
Calculate(saf.Fraction, fractionValue);
//if (inlet.MassFlowRate.HasValue && saf.Stream.MassFlowRate.IsSpecifiedAndHasNoValue) {
if (inlet.MassFlowRate.HasValue && !saf.Stream.MassFlowRate.HasValue)
{
Calculate(saf.Stream.MassFlowRate, inlet.MassFlowRate.Value * fractionValue);
}
//else if (saf.Stream.MassFlowRate.HasValue && fractionValue > 1.0e-6 && inlet.MassFlowRate.IsSpecifiedAndHasNoValue) {
else if (saf.Stream.MassFlowRate.HasValue && fractionValue > 1.0e-6 && !inlet.MassFlowRate.HasValue)
{
Calculate(inlet.MassFlowRate, saf.Stream.MassFlowRate.Value / fractionValue);
}
//inlet mass flow rate dry base is known
else if (inlet is DryingStream)
{
dsOutlet = saf.Stream as DryingStream;
//if (dsInlet.MassFlowRateDryBase.HasValue && dsOutlet.MassFlowRateDryBase.IsSpecifiedAndHasNoValue) {
if (dsInlet.MassFlowRateDryBase.HasValue && !dsOutlet.MassFlowRateDryBase.HasValue)
{
Calculate(dsOutlet.MassFlowRateDryBase, dsInlet.MassFlowRateDryBase.Value * fractionValue);
}
//else if (dsOutlet.MassFlowRateDryBase.HasValue && fractionValue > 1.0e-6 && dsInlet.MassFlowRateDryBase.IsSpecifiedAndHasNoValue) {
else if (dsOutlet.MassFlowRateDryBase.HasValue && fractionValue > 1.0e-6 && !dsInlet.MassFlowRateDryBase.HasValue)
{
Calculate(dsInlet.MassFlowRateDryBase, dsOutlet.MassFlowRateDryBase.Value / fractionValue);
}
}
}
if (numOfUnknownFlow == 1)
{
saf = outletStreamAndFractions[unknownFlowIndex] as StreamAndFraction;
if (inlet.MassFlowRate.HasValue && inlet.MassFlowRate.Value > totalFlow)
{
//if (saf.Stream.MassFlowRate.IsSpecifiedAndHasNoValue) {
if (!saf.Stream.MassFlowRate.HasValue)
{
Calculate(saf.Stream.MassFlowRate, (inlet.MassFlowRate.Value - totalFlow));
}
//if (saf.Fraction.IsSpecifiedAndHasNoValue) {
if (!saf.Fraction.HasValue)
{
Calculate(saf.Fraction, saf.Stream.MassFlowRate.Value / inlet.MassFlowRate.Value);
}
}
}
else if (numOfUnknownFlow == 0)
{
Calculate(inlet.MassFlowRate, totalFlow);
foreach (StreamAndFraction sf in outletStreamAndFractions)
{
Calculate(sf.Fraction, sf.Stream.MassFlowRate.Value / inlet.MassFlowRate.Value);
}
}
else if (numOfUnknownFlowDryBase == 1 && dsInlet.MassFlowRateDryBase.HasValue)
{
saf = outletStreamAndFractions[unknownFlowDryBaseIndex] as StreamAndFraction;
dsOutlet = saf.Stream as DryingStream;
if (dsInlet.MassFlowRateDryBase.Value > totalFlowDryBase)
{
//if (dsOutlet.MassFlowRateDryBase.IsSpecifiedAndHasNoValue) {
if (!dsOutlet.MassFlowRateDryBase.HasValue)
{
Calculate(dsOutlet.MassFlowRateDryBase, (dsInlet.MassFlowRateDryBase.Value - totalFlowDryBase));
}
//if (saf.Fraction.IsSpecifiedAndHasNoValue) {
if (!saf.Fraction.HasValue)
{
Calculate(saf.Fraction, dsOutlet.MassFlowRateDryBase.Value / dsInlet.MassFlowRateDryBase.Value);
}
}
}
else if (numOfUnknownFlowDryBase == 0)
{
Calculate(dsInlet.MassFlowRateDryBase, totalFlowDryBase);
foreach (StreamAndFraction sf in outletStreamAndFractions)
{
dsOutlet = sf.Stream as DryingStream;
Calculate(sf.Fraction, dsOutlet.MassFlowRateDryBase.Value / dsInlet.MassFlowRateDryBase.Value);
}
}
for (int i = 0; i < InOutletStreams.Count; i++)
{
psb = InOutletStreams[i] as ProcessStreamBase;
if (psb.Pressure.HasValue)
{
numOfKnownPressure++;
j = i;
}
if (psb.SpecificEnthalpy.HasValue)
{
numOfKnownEnthalpy++;
k = i;
}
if (psb.Temperature.HasValue)
{
numOfKnownTemperature++;
l = i;
}
}
if (numOfKnownPressure == 1)
{
psb = InOutletStreams[j] as ProcessStreamBase;
temp = psb.Pressure.Value;
for (int i = 0; i < InOutletStreams.Count; i++)
{
if (i != j)
{
psb = InOutletStreams[i] as ProcessStreamBase;
Calculate(psb.Pressure, temp);
}
}
}
if (numOfKnownEnthalpy == 1)
{
psb = InOutletStreams[k] as ProcessStreamBase;
temp = psb.SpecificEnthalpy.Value;
for (int i = 0; i < InOutletStreams.Count; i++)
{
if (i != k)
{
psb = InOutletStreams[i] as ProcessStreamBase;
Calculate(psb.SpecificEnthalpy, temp);
}
}
}
else if (numOfKnownTemperature == 1)
{
psb = InOutletStreams[l] as ProcessStreamBase;
temp = psb.Temperature.Value;
for (int i = 0; i < InOutletStreams.Count; i++)
{
if (i != l)
{
psb = InOutletStreams[i] as ProcessStreamBase;
Calculate(psb.Temperature, temp);
}
}
}
//dry gas flow balance
if (inlet is DryingGasStream)
{
DryingStream dsStream;
for (int i = 0; i < InOutletStreams.Count; i++)
{
dsStream = InOutletStreams[i] as DryingStream;
if (dsStream.MoistureContentDryBase.HasValue)
{
numOfKnown++;
j = i;
}
}
if (numOfKnown == 1)
{
dsStream = InOutletStreams[j] as DryingStream;
temp = dsStream.MoistureContentDryBase.Value;
for (int i = 0; i < InOutletStreams.Count; i++)
{
if (i != j)
{
dsStream = InOutletStreams[i] as DryingStream;
Calculate(dsStream.MoistureContentDryBase, temp);
}
}
}
DryingGasComponents inletDgc = (inlet as DryingGasStream).GasComponents;
SolidPhase inletSp = inletDgc.SolidPhase;
DryingGasComponents outletDgc;
foreach (DryingGasStream outlet in outletStreams)
{
outletDgc = outlet.GasComponents;
outletDgc.SolidPhase = inletDgc.SolidPhase;
}
}
//density for drying material stream
if (inlet is DryingMaterialStream)
{
DryingStream dsStream;
for (int i = 0; i < InOutletStreams.Count; i++)
{
dsStream = InOutletStreams[i] as DryingStream;
if (dsStream.MoistureContentWetBase.HasValue)
{
numOfKnown++;
j = i;
}
}
if (numOfKnown == 1)
{
dsStream = InOutletStreams[j] as DryingStream;
temp = dsStream.MoistureContentWetBase.Value;
for (int i = 0; i < InOutletStreams.Count; i++)
{
if (i != j)
{
dsStream = InOutletStreams[i] as DryingStream;
Calculate(dsStream.MoistureContentWetBase, temp);
}
}
}
numOfKnown = 0;
for (int i = 0; i < InOutletStreams.Count; i++)
{
dsStream = InOutletStreams[i] as DryingMaterialStream;
if (dsStream.Density.HasValue)
{
numOfKnown++;
j = i;
}
}
if (numOfKnown == 1)
{
dsStream = InOutletStreams[j] as DryingMaterialStream;
temp = dsStream.Density.Value;
for (int i = 0; i < InOutletStreams.Count; i++)
{
if (i != j)
{
dsStream = InOutletStreams[i] as DryingMaterialStream;
Calculate(dsStream.Density, temp);
}
}
}
}
//balanced gas stream solid phase
//if (inlet is DryingGasStream) {
// DryingGasComponents inletDgc = (inlet as DryingGasStream).GasComponents;
// SolidPhase inletSp = inletDgc.SolidPhase;
// DryingGasComponents outletDgc;
// foreach (DryingGasStream outlet in outletStreams) {
// outletDgc = outlet.GasComponents;
// outletDgc.SolidPhase = inletDgc.SolidPhase;
// }
//}
DryingStream dryingStream;
int numOfKnownMassFlow = 0;
int numOfKnownMoistureContent = 0;
numOfKnownPressure = 0;
numOfKnownEnthalpy = 0;
int numOfStrms = InOutletStreams.Count;
for (int i = 0; i < numOfStrms; i++)
{
psb = InOutletStreams[i] as ProcessStreamBase;
psb.Execute(false);
if (psb.MassFlowRate.HasValue)
{
numOfKnownMassFlow++;
}
if (psb.Pressure.HasValue)
{
numOfKnownPressure++;
}
if (psb.Temperature.HasValue)
{
numOfKnownEnthalpy++;
}
if (inlet is DryingGasStream)
{
dryingStream = psb as DryingStream;
if (dryingStream.MoistureContentDryBase.HasValue)
{
numOfKnownMoistureContent++;
}
}
else if (inlet is DryingMaterialStream)
{
dryingStream = psb as DryingStream;
if (dryingStream.MoistureContentWetBase.HasValue)
{
numOfKnownMoistureContent++;
}
}
}
if (numOfKnownMassFlow == numOfStrms && numOfKnownEnthalpy == numOfStrms)
{
if (inlet is ProcessStream && numOfKnownPressure == numOfStrms)
{
currentSolveState = SolveState.Solved;
}
else if (inlet is DryingGasStream && numOfKnownPressure == numOfStrms && numOfKnownMoistureContent == numOfStrms)
{
currentSolveState = SolveState.Solved;
}
else if (inlet is DryingMaterialStream && numOfKnownMoistureContent == numOfStrms)
{
currentSolveState = SolveState.Solved;
}
}
}
private void Solve()
{
ProcessStreamBase inletStream;
double totalFlow = 0.0;
//double totalFlowDryBase = 0.0;
double temp;
int numOfUnknownFlow = 0;
//int numOfUnknownFlowDryBase = 0;
int unknownFlowIndex = -1;
//int unknownFlowDryBaseIndex = -1;
DryingStream dryingStream;
DryingStream dsInlet;
DryingStream dsOutlet = null;
if (outlet is DryingStream)
{
dsOutlet = outlet as DryingStream;
}
int knownIndex = -1;
int numOfKnown = 0;
ProcessStreamBase stream;
/*for (int i = 0; i < InOutletStreams.Count; i++) {
* stream = InOutletStreams[i] as ProcessStreamBase;
* if (stream.Pressure.HasValue) {
* knownIndex = i;
* numOfKnown++;
* }
* }
*
* if (numOfKnown == 1) {
* stream = InOutletStreams[knownIndex] as ProcessStreamBase;
* temp = stream.Pressure.Value;
* for (int i = 0; i < InOutletStreams.Count; i++) {
* stream = InOutletStreams[i] as ProcessStreamBase;
* if (i != knownIndex) {
* Calculate(stream.Pressure, temp);
* stream.Execute(false);
* }
* }
* }*/
numOfKnown = 0;
DryingMaterialStream matStream;
if (outlet is DryingMaterialStream)
{
for (int i = 0; i < InOutletStreams.Count; i++)
{
matStream = InOutletStreams[i] as DryingMaterialStream;
if (matStream.SpecificHeatAbsDry.HasValue)
{
knownIndex = i;
numOfKnown++;
}
}
if (numOfKnown == 1)
{
matStream = InOutletStreams[knownIndex] as DryingMaterialStream;
temp = matStream.SpecificHeatAbsDry.Value;
for (int i = 0; i < InOutletStreams.Count; i++)
{
matStream = InOutletStreams[i] as DryingMaterialStream;
if (i != knownIndex)
{
Calculate(matStream.SpecificHeatAbsDry, temp);
matStream.Execute(false);
}
}
}
}
//flow balance
for (int i = 0; i < inletStreams.Count; i++)
{
inletStream = inletStreams[i] as ProcessStreamBase;
if (inletStream.MassFlowRate.HasValue)
{
totalFlow += inletStream.MassFlowRate.Value;
}
else
{
unknownFlowIndex = i;
numOfUnknownFlow++;
}
}
if (numOfUnknownFlow == 1 && outlet.MassFlowRate.HasValue)
{
inletStream = inletStreams[unknownFlowIndex] as ProcessStreamBase;
//if (outlet.MassFlowRate.Value > totalFlow && inletStream.MassFlowRate.IsSpecifiedAndHasNoValue)
if (outlet.MassFlowRate.Value > totalFlow && !inletStream.MassFlowRate.HasValue)
{
Calculate(inletStream.MassFlowRate, (outlet.MassFlowRate.Value - totalFlow));
}
}
else if (numOfUnknownFlow == 0)
{
Calculate(outlet.MassFlowRate, totalFlow);
}
double inletTotal = 0.0;
int numOfUnknownInlet = 0;
int unknownInletIndex = -1;
//moisture content balance
if (outlet is DryingStream)
{
double mcDryBase;
double mcWetBase;
for (int i = 0; i < inletStreams.Count; i++)
{
dsInlet = inletStreams[i] as DryingStream;
mcWetBase = Constants.NO_VALUE;
if (dsInlet.MoistureContentWetBase.HasValue)
{
mcWetBase = dsInlet.MoistureContentWetBase.Value;
}
else if (dsInlet.MoistureContentDryBase.HasValue)
{
mcDryBase = dsInlet.MoistureContentDryBase.Value;
mcWetBase = mcDryBase / (1.0 + mcDryBase);
}
if (dsInlet.MassFlowRate.HasValue && mcWetBase != Constants.NO_VALUE)
{
//inletTotal += dsInlet.MassFlowRate.Value * mcDryBase/(1.0 + mcDryBase);
inletTotal += dsInlet.MassFlowRate.Value * mcWetBase;
}
else
{
unknownInletIndex = i;
numOfUnknownInlet++;
}
}
mcDryBase = dsOutlet.MoistureContentDryBase.Value;
if (numOfUnknownInlet == 1 &&
dsOutlet.MassFlowRate.HasValue && mcDryBase != Constants.NO_VALUE)
{
dsInlet = inletStreams[unknownInletIndex] as DryingStream;
double outletMoisture = dsOutlet.MassFlowRate.Value * mcDryBase / (1.0 + mcDryBase);
if (outletMoisture > inletTotal)
{
//if (dsInlet.MassFlowRate.HasValue && dsInlet.MoistureContentWetBase.IsSpecifiedAndHasNoValue) {
if (dsInlet.MassFlowRate.HasValue && !dsInlet.MoistureContentWetBase.HasValue)
{
mcWetBase = (outletMoisture - inletTotal) / dsInlet.MassFlowRate.Value;
Calculate(dsInlet.MoistureContentWetBase, mcWetBase);
}
//else if (dsInlet.MassFlowRate.HasValue && dsInlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
else if (dsInlet.MassFlowRate.HasValue && !dsInlet.MoistureContentDryBase.HasValue)
{
mcWetBase = (outletMoisture - inletTotal) / dsInlet.MassFlowRate.Value;
Calculate(dsInlet.MoistureContentDryBase, mcWetBase / (1.0 - mcWetBase));
}
//else if (dsInlet.MassFlowRateDryBase.HasValue && dsInlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
else if (dsInlet.MassFlowRateDryBase.HasValue && !dsInlet.MoistureContentDryBase.HasValue)
{
mcDryBase = (outletMoisture - inletTotal) / dsInlet.MassFlowRateDryBase.Value;
Calculate(dsInlet.MoistureContentDryBase, mcDryBase);
}
//else if (dsInlet.MoistureContentDryBase.HasValue && dsInlet.MassFlowRateDryBase.IsSpecifiedAndHasNoValue) {
else if (dsInlet.MoistureContentDryBase.HasValue && !dsInlet.MassFlowRateDryBase.HasValue)
{
double massFlowDryBase = (outletMoisture - inletTotal) / dsInlet.MoistureContentDryBase.Value;
Calculate(dsInlet.MassFlowRateDryBase, massFlowDryBase);
}
//else if (dsInlet.MoistureContentDryBase.HasValue && dsInlet.MassFlowRate.IsSpecifiedAndHasNoValue) {
else if (dsInlet.MoistureContentDryBase.HasValue && !dsInlet.MassFlowRate.HasValue)
{
mcDryBase = dsInlet.MoistureContentDryBase.Value;
double massFlow = (outletMoisture - inletTotal) / mcDryBase * (1.0 + mcDryBase);
Calculate(dsInlet.MassFlowRate, massFlow);
}
}
}
else if (numOfUnknownInlet == 0)
{
//if (dsOutlet.MassFlowRate.HasValue && dsOutlet.MoistureContentWetBase.IsSpecifiedAndHasNoValue) {
if (dsOutlet.MassFlowRate.HasValue && !dsOutlet.MoistureContentWetBase.HasValue)
{
mcWetBase = inletTotal / dsOutlet.MassFlowRate.Value;
Calculate(dsOutlet.MoistureContentWetBase, mcWetBase);
}
//else if (dsOutlet.MassFlowRate.HasValue && dsOutlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
else if (dsOutlet.MassFlowRate.HasValue && !dsOutlet.MoistureContentDryBase.HasValue)
{
mcWetBase = inletTotal / dsOutlet.MassFlowRate.Value;
Calculate(dsOutlet.MoistureContentDryBase, mcWetBase / (1.0 - mcWetBase));
}
//else if (dsOutlet.MassFlowRateDryBase.HasValue && dsOutlet.MoistureContentDryBase.IsSpecifiedAndHasNoValue) {
else if (dsOutlet.MassFlowRateDryBase.HasValue && !dsOutlet.MoistureContentDryBase.HasValue)
{
mcDryBase = inletTotal / dsOutlet.MassFlowRateDryBase.Value;
Calculate(dsOutlet.MoistureContentDryBase, mcDryBase);
}
//else if (dsOutlet.MoistureContentDryBase.HasValue && dsOutlet.MassFlowRateDryBase.IsSpecifiedAndHasNoValue) {
else if (dsOutlet.MoistureContentDryBase.HasValue && !dsOutlet.MassFlowRateDryBase.HasValue)
{
double massFlowDryBase = inletTotal / dsOutlet.MoistureContentDryBase.Value;
Calculate(dsOutlet.MassFlowRateDryBase, massFlowDryBase);
}
//else if (dsOutlet.MoistureContentDryBase.HasValue && dsOutlet.MassFlowRate.IsSpecifiedAndHasNoValue) {
else if (dsOutlet.MoistureContentDryBase.HasValue && !dsOutlet.MassFlowRate.HasValue)
{
mcDryBase = dsOutlet.MoistureContentDryBase.Value;
double massFlow = inletTotal / mcDryBase * (1.0 + mcDryBase);
Calculate(dsOutlet.MassFlowRate, massFlow);
}
}
}
inletTotal = 0.0;
numOfUnknownInlet = 0;
unknownInletIndex = -1;
double inletTotalDryBase = 0.0;
int numOfUnknownInletDryBase = 0;
int unknownInletIndexDryBase = -1;
//double cpDryBase;
//double cpWetBase;
for (int i = 0; i < inletStreams.Count; i++)
{
inletStream = inletStreams[i] as ProcessStreamBase;
if (inletStream.MassFlowRate.HasValue && inletStream.SpecificEnthalpy.HasValue)
{
inletTotal += inletStream.MassFlowRate.Value * inletStream.SpecificEnthalpy.Value;
}
else
{
unknownInletIndex = i;
numOfUnknownInlet++;
}
if (outlet is DryingStream)
{
dsInlet = inletStream as DryingStream;
if (dsInlet.MassFlowRateDryBase.HasValue && dsInlet.SpecificEnthalpyDryBase.HasValue)
{
inletTotalDryBase += dsInlet.MassFlowRateDryBase.Value * dsInlet.SpecificEnthalpyDryBase.Value;
}
else
{
unknownInletIndexDryBase = i;
numOfUnknownInletDryBase++;
}
}
}
HumidGasCalculator humidGasCalculator = GetHumidGasCalculator();
if (numOfUnknownInletDryBase == 1 &&
(dsOutlet.MassFlowRate.HasValue && dsOutlet.SpecificEnthalpy.HasValue))
{
dsInlet = inletStreams[unknownInletIndexDryBase] as DryingStream;
//cpDryBase = dsInlet.SpecificHeatDryBase.Value;
//if (cpDryBase == Constants.NO_VALUE && dsInlet is DryingGasStream && dsInlet.MoistureContentDryBase.HasValue) {
// cpDryBase = humidGasCalculator.GetHumidHeat(dsInlet.MoistureContentDryBase.Value);
//}
double outletEnergy = dsOutlet.MassFlowRate.Value * dsOutlet.SpecificEnthalpy.Value;
if (outletEnergy > inletTotalDryBase)
{
if (dsInlet.MassFlowRate.HasValue && !dsInlet.SpecificEnthalpy.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.MassFlowRate.Value;
Calculate(dsInlet.SpecificEnthalpy, temp);
}
else if (dsInlet.MassFlowRateDryBase.HasValue && !dsInlet.SpecificEnthalpyDryBase.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.MassFlowRateDryBase.Value;
Calculate(dsInlet.SpecificEnthalpyDryBase, temp);
}
else if (dsInlet.SpecificEnthalpy.HasValue && !dsInlet.MassFlowRate.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.SpecificEnthalpy.Value;
Calculate(dsInlet.MassFlowRate, temp);
}
else if (dsInlet.SpecificEnthalpyDryBase.HasValue && !dsInlet.MassFlowRateDryBase.HasValue)
{
temp = (outletEnergy - inletTotalDryBase) / dsInlet.SpecificEnthalpyDryBase.Value;
Calculate(dsInlet.MassFlowRateDryBase, temp);
}
}
}
else if (numOfUnknownInletDryBase == 0)
{
dsOutlet.Execute(false);
if (dsOutlet.MassFlowRate.HasValue && !dsOutlet.SpecificEnthalpy.HasValue)
{
temp = inletTotalDryBase / dsOutlet.MassFlowRate.Value;
Calculate(dsOutlet.SpecificEnthalpy, temp);
}
if (dsOutlet.MassFlowRateDryBase.HasValue && !dsOutlet.SpecificEnthalpyDryBase.HasValue)
{
temp = inletTotalDryBase / dsOutlet.MassFlowRateDryBase.Value;
Calculate(dsOutlet.SpecificEnthalpyDryBase, temp);
}
else if (dsOutlet.SpecificEnthalpy.HasValue && !dsOutlet.MassFlowRate.HasValue)
{
temp = inletTotalDryBase / dsOutlet.SpecificEnthalpy.Value;
Calculate(dsOutlet.MassFlowRate, temp);
}
else if (dsOutlet.SpecificEnthalpyDryBase.HasValue && !dsOutlet.MassFlowRateDryBase.HasValue)
{
temp = inletTotalDryBase / dsOutlet.SpecificEnthalpyDryBase.Value;
Calculate(dsOutlet.MassFlowRateDryBase, temp);
}
}
else if (numOfUnknownInlet == 1 && outlet.MassFlowRate.HasValue && outlet.SpecificEnthalpy.HasValue &&
outlet.SpecificHeat.HasValue)
{
inletStream = inletStreams[unknownInletIndex] as ProcessStreamBase;
double outletEnergy = outlet.MassFlowRate.Value * outlet.Temperature.Value * outlet.SpecificHeat.Value;
if (outletEnergy > inletTotal)
{
if (inletStream.MassFlowRate.HasValue && !inletStream.SpecificEnthalpy.HasValue)
{
temp = (outletEnergy - inletTotal) / inletStream.MassFlowRate.Value;
Calculate(inletStream.SpecificEnthalpy, temp);
}
else if (inletStream.SpecificEnthalpy.HasValue && !inletStream.MassFlowRate.HasValue)
{
temp = (outletEnergy - inletTotal) / inletStream.SpecificEnthalpy.Value;
Calculate(inletStream.MassFlowRate, temp);
}
}
}
else if (numOfUnknownInlet == 0)
{
if (outlet.MassFlowRate.HasValue && !outlet.SpecificEnthalpy.HasValue)
{
temp = inletTotal / outlet.MassFlowRate.Value;
Calculate(outlet.SpecificEnthalpy, temp);
}
else if (outlet.SpecificEnthalpy.HasValue && !outlet.MassFlowRate.HasValue)
{
temp = inletTotal / outlet.SpecificEnthalpy.Value;
Calculate(outlet.MassFlowRate, temp);
}
}
int numOfKnownMassFlow = 0;
int numOfKnownPressure = 0;
int numOfKnownTemperature = 0;
int numOfKnownMoistureContent = 0;
int numOfStrms = InOutletStreams.Count;
for (int i = 0; i < numOfStrms; i++)
{
stream = InOutletStreams[i] as ProcessStreamBase;
if (stream.MassFlowRate.HasValue)
{
numOfKnownMassFlow++;
}
if (stream.Pressure.HasValue)
{
numOfKnownPressure++;
}
if (stream.SpecificEnthalpy.HasValue)
{
numOfKnownTemperature++;
}
if (outlet is DryingStream)
{
dryingStream = stream as DryingStream;
if (dryingStream.MoistureContentDryBase.HasValue || dryingStream.MoistureContentWetBase.HasValue)
{
numOfKnownMoistureContent++;
}
}
}
if (numOfKnownMassFlow == numOfStrms && numOfKnownTemperature == numOfStrms)
{
if (outlet is ProcessStream && numOfKnownPressure == numOfStrms)
{
solveState = SolveState.Solved;
}
else if (outlet is DryingGasStream && numOfKnownPressure == numOfStrms && numOfKnownMoistureContent == numOfStrms)
{
solveState = SolveState.Solved;
}
else if (outlet is DryingMaterialStream && numOfKnownMoistureContent == numOfStrms)
{
solveState = SolveState.Solved;
}
}
}
//protected override bool IsSolveReady() {
// bool isReady = false;
// if (inlet is DryingGasStream) {
// DryingGasStream dsInlet = inlet as DryingGasStream;
// DryingGasStream dsOutlet = outlet as DryingGasStream;
// if ((dsInlet.Pressure.HasValue || dsOutlet.Pressure.HasValue) &&
// (dsInlet.Temperature.HasValue || dsOutlet.Temperature.HasValue) &&
// (dsInlet.MassFlowRateDryBase.HasValue || dsOutlet.MassFlowRateDryBase.HasValue || dsInlet.MassFlowRate.HasValue || dsOutlet.MassFlowRate.HasValue) &&
// (dsInlet.MoistureContentDryBase.HasValue || dsOutlet.MoistureContentDryBase.HasValue || dsInlet.MoistureContentWetBase.HasValue || dsOutlet.MoistureContentWetBase.HasValue)) {
// isReady = true;
// }
// }
// else if (inlet is DryingMaterialStream) {
// DryingMaterialStream dsInlet = inlet as DryingMaterialStream;
// DryingMaterialStream dsOutlet = outlet as DryingMaterialStream;
// if (dsInlet.MaterialStateType == MaterialStateType.Liquid) {
// if ((dsInlet.Pressure.HasValue || dsOutlet.Pressure.HasValue) &&
// (dsInlet.Temperature.HasValue || dsOutlet.Temperature.HasValue) &&
// (dsInlet.MassFlowRateDryBase.HasValue || dsOutlet.MassFlowRateDryBase.HasValue || dsInlet.MassFlowRate.HasValue || dsOutlet.MassFlowRate.HasValue) &&
// (dsInlet.MoistureContentDryBase.HasValue || dsOutlet.MoistureContentDryBase.HasValue || dsInlet.MoistureContentWetBase.HasValue || dsOutlet.MoistureContentWetBase.HasValue || dsInlet.MassConcentration.HasValue || dsOutlet.MassConcentration.HasValue)) {
// isReady = true;
// }
// }
// else if (dsInlet.MaterialStateType == MaterialStateType.Solid) {
// if ((dsInlet.Temperature.HasValue || dsOutlet.Temperature.HasValue) &&
// (dsInlet.MassFlowRateDryBase.HasValue || dsOutlet.MassFlowRateDryBase.HasValue || dsInlet.MassFlowRate.HasValue || dsOutlet.MassFlowRate.HasValue) &&
// (dsInlet.MoistureContentDryBase.HasValue || dsOutlet.MoistureContentDryBase.HasValue || dsInlet.MoistureContentWetBase.HasValue || dsOutlet.MoistureContentWetBase.HasValue)) {
// isReady = true;
// }
// }
// }
// return isReady;
//}
public override void Execute(bool propagate)
{
//if (!IsSolveReady()) {
// return;
//}
isBeingExecuted = true;
BalanceStreamComponents(inlet, outlet);
if (inlet is DryingStream)
{
DryingStream dsInlet = inlet as DryingStream;
DryingStream dsOutlet = outlet as DryingStream;
if (dsInlet.Pressure.HasValue && !dsOutlet.Pressure.HasValue)
{
dsOutlet.Pressure.Value = dsInlet.Pressure.Value;
}
IList <ProcessVarDouble> inletVarList = new List <ProcessVarDouble>();
IList <ProcessVarDouble> outletVarList = new List <ProcessVarDouble>();
IList <double> newValueList = new List <double>();
if (dsInlet.MassFlowRateDryBase.HasValue && !dsOutlet.MassFlowRateDryBase.IsSpecifiedAndHasValue)
{
inletVarList.Add(dsInlet.MassFlowRateDryBase);
outletVarList.Add(dsOutlet.MassFlowRateDryBase);
newValueList.Add(dsInlet.MassFlowRateDryBase.Value);
}
else if (dsInlet.MassFlowRate.HasValue && !dsOutlet.MassFlowRate.IsSpecifiedAndHasValue)
{
inletVarList.Add(dsInlet.MassFlowRate);
outletVarList.Add(dsOutlet.MassFlowRate);
newValueList.Add(dsInlet.MassFlowRate.Value);
}
else if (!dsOutlet.MassFlowRateDryBase.IsSpecifiedAndHasValue)
{
inletVarList.Add(dsInlet.MassFlowRateDryBase);
outletVarList.Add(dsOutlet.MassFlowRateDryBase);
double newValue = dsInlet.MassFlowRateDryBase.Value;
if (newValue == Constants.NO_VALUE)
{
newValue = 0.01;
}
newValueList.Add(newValue);
}
if (!dsOutlet.Temperature.IsSpecifiedAndHasValue)
{
inletVarList.Add(dsInlet.Temperature);
outletVarList.Add(dsOutlet.Temperature);
double newValue = dsInlet.Temperature.Value;
if (newValue == Constants.NO_VALUE)
{
newValue = 274.15;
}
newValueList.Add(newValue);
}
if (dsInlet.MoistureContentDryBase.HasValue && !dsOutlet.MoistureContentDryBase.IsSpecifiedAndHasValue)
{
inletVarList.Add(dsInlet.MoistureContentDryBase);
outletVarList.Add(dsOutlet.MoistureContentDryBase);
newValueList.Add(dsInlet.MoistureContentDryBase.Value);
}
else if (dsInlet.MoistureContentWetBase.HasValue && !dsOutlet.MoistureContentWetBase.IsSpecifiedAndHasValue)
{
inletVarList.Add(dsInlet.MoistureContentWetBase);
outletVarList.Add(dsOutlet.MoistureContentWetBase);
newValueList.Add(dsInlet.MoistureContentWetBase.Value);
}
else if (!dsOutlet.MoistureContentDryBase.IsSpecifiedAndHasValue)
{
inletVarList.Add(dsInlet.MoistureContentDryBase);
outletVarList.Add(dsOutlet.MoistureContentDryBase);
double newValue = dsInlet.MoistureContentDryBase.Value;
if (newValue == Constants.NO_VALUE)
{
newValue = 0.001;
}
newValueList.Add(newValue);
}
double[] oldValueList = new double[newValueList.Count];
bool isGreaterThanTolerance;
int counter = 0;
do
{
counter++;
isGreaterThanTolerance = false;
for (int i = 0; i < outletVarList.Count; i++)
{
outletVarList[i].Value = newValueList[i];
oldValueList[i] = newValueList[i];
}
dsOutlet.HasBeenModified(true);
for (int j = 0; j < inletVarList.Count; j++)
{
newValueList[j] = inletVarList[j].Value;
if (Math.Abs((newValueList[j] - oldValueList[j]) / oldValueList[j]) > 1.0e-6)
{
isGreaterThanTolerance = true;
break;
}
}
} while (isGreaterThanTolerance && counter < 500);
if (counter == 500)
{
currentSolveState = SolveState.SolveFailed;
}
else
{
if (inlet.HasSolvedAlready && outlet.HasSolvedAlready)
{
currentSolveState = SolveState.Solved;
}
//debug code
Trace.WriteLine(this.name + "Number of Iterations" + counter);
//debug code
}
if (currentSolveState == SolveState.Solved)
{
dsOutlet.Pressure.State = VarState.Calculated;
foreach (ProcessVarDouble outletVar in outletVarList)
{
outletVar.State = VarState.Calculated;
}
}
else if (currentSolveState == SolveState.NotSolved)
{
if (dsOutlet.Pressure.IsSpecifiedAndHasValue)
{
dsOutlet.Pressure.Value = Constants.NO_VALUE;
}
foreach (ProcessVarDouble outletVar in outletVarList)
{
outletVar.Value = Constants.NO_VALUE;
}
}
dsOutlet.OnSolveComplete(currentSolveState);//has to call this so that the calculated state is updated on the UI
}
isBeingExecuted = false;
OnSolveComplete(currentSolveState);
}
public DryingStreamControl(Flowsheet flowsheet, Point location, DryingStream dryingStream)
: base(flowsheet, location, dryingStream)
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
}
