/*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(); }