public Valve(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "Valve";
Icon.IconType = IconTypes.Valve;
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("Out", PortDirection.Out, 1));
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p1 = system.VariableFactory.CreateVariable("P1", "Pressure in valve inlet", PhysicalDimension.Pressure);
p2 = system.VariableFactory.CreateVariable("P2", "Pressure in valve outlet", PhysicalDimension.Pressure);
KVS = new Variable("KVS", 10, 0, 1e6, SI.cum / SI.h / METRIC.bar, "Nominal valve coefficient");
KV = new Variable("KV", 10, 0, 1e6, SI.cum / SI.h / METRIC.bar, "Effective valve coefficient");
Opening = new Variable("Open", 50, 0, 100, SI.nil, "Valve opening in %");
Position = new Variable("Pos", 50, 0, 100, SI.nil, "Valve position in %");
dp.LowerBound = 0;
dp.ValueInSI = 0;
AddVariable(dp);
AddVariable(KVS);
AddVariable(KV);
AddVariable(Opening);
AddVariable(Position);
AddVariable(p1);
AddVariable(p2);
}
public Heater(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "Heater";
Icon.IconType = IconTypes.Heater;
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("Out", PortDirection.Out, 1));
HeatPorts.Add(new Port <HeatStream>("Duty", PortDirection.In, 1));
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p = system.VariableFactory.CreateVariable("P", "Pressure in heater outlet", PhysicalDimension.Pressure);
T = system.VariableFactory.CreateVariable("T", "Temperature in heater outlet", PhysicalDimension.Temperature);
VF = system.VariableFactory.CreateVariable("VF", "Vapor fraction in heater outlet", PhysicalDimension.MolarFraction);
Q = system.VariableFactory.CreateVariable("Q", "Heat Duty", PhysicalDimension.HeatFlow);
dp.LowerBound = 0;
dp.ValueInSI = 0;
AddVariable(dp);
AddVariable(p);
AddVariable(T);
AddVariable(VF);
AddVariable(Q);
}
public FeedStage(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "Flash";
Icon.IconType = IconTypes.FeedStage;
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("VIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("LIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("VOut", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("LOut", PortDirection.Out, 1));
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p = system.VariableFactory.CreateVariable("P", "Pressure in flash", PhysicalDimension.Pressure);
T = system.VariableFactory.CreateVariable("T", "Temperature in flash", PhysicalDimension.Temperature);
Q = system.VariableFactory.CreateVariable("Q", "Heat Duty", PhysicalDimension.HeatFlow);
K = new Variable[system.Components.Count];
for (int i = 0; i < system.Components.Count; i++)
{
K[i] = system.VariableFactory.CreateVariable("K", "Equilibrium partition coefficient", PhysicalDimension.Dimensionless);
K[i].Subscript = system.Components[i].ID;
K[i].ValueInSI = 1.2;
}
dp.LowerBound = -1e10;
dp.ValueInSI = 0;
AddVariable(p);
AddVariable(T);
AddVariable(Q);
AddVariable(dp);
AddVariables(K);
}
public BlackBoxReactor(string name, ThermodynamicSystem system, int numberOfReactions) : base(name, system)
{
Class = "Reactor";
_numberOfReactions = numberOfReactions;
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("Out", PortDirection.Out, 1));
R = new Variable[_numberOfReactions];
DHR = new Variable[_numberOfReactions];
_stochiometry = new double[_numberOfReactions, System.Components.Count];
for (int i = 0; i < _numberOfReactions; i++)
{
R[i] = system.VariableFactory.CreateVariable("R", (i + 1).ToString(), "Converted Molar Flow for reaction " + (i + 1).ToString(), PhysicalDimension.MolarFlow);
DHR[i] = system.VariableFactory.CreateVariable("DHR", (i + 1).ToString(), "Reaction enthalpy", PhysicalDimension.SpecificMolarEnthalpy);
DHR[i].ValueInSI = 0;
DHR[i].IsFixed = true;
}
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p = system.VariableFactory.CreateVariable("P", "Pressure in heater outlet", PhysicalDimension.Pressure);
T = system.VariableFactory.CreateVariable("T", "Temperature in heater outlet", PhysicalDimension.Temperature);
Q = system.VariableFactory.CreateVariable("Q", "Heat Duty", PhysicalDimension.HeatFlow);
dp.LowerBound = -1e9;
dp.ValueInSI = 0;
AddVariable(dp);
AddVariable(p);
AddVariable(T);
AddVariables(R);
AddVariable(Q);
AddVariables(DHR);
}
public void Show(ThermodynamicSystem system)
{
var vm = _thermoEditorFactory.Create(system);
_aggregator.PublishOnUIThread(new AddNewDocumentMessage {
TimeStamp = DateTime.Now, Sender = this, Title = system.Name, Parameter = vm
});
}
public MixtureHenryCoefficient(ThermodynamicSystem system, Variable T, List<Variable> x, int idx)
{
index = idx;
_system = system;
var parameterSet = _system.BinaryParameters.FirstOrDefault(ps => ps.Name == "HENRY");
if (parameterSet == null)
throw new ArgumentNullException("No HENRY parameters defined");
double[,] a = parameterSet.Matrices["A"];
double[,] b = parameterSet.Matrices["B"];
double[,] c = parameterSet.Matrices["C"];
double[,] d = parameterSet.Matrices["D"];
Symbol = "HENRY";
this.T = T;
this.x = x;
Parameters.Add(T);
foreach (var comp in x)
Parameters.Add(comp);
NC = system.Components.Count;
Expression sumxj = 0;
Expression _lnHenry = 0;
for (int j = 0; j < system.Components.Count; j++)
{
if (!system.Components[j].IsInert)
{
Expression lnHij = a[idx, j];
if (b[idx, j] != 0.0)
lnHij += b[idx, j] / T;
if (c[idx, j] != 0.0)
lnHij += c[idx, j] * Sym.Ln(T);
if (d[idx, j] != 0.0)
lnHij += d[idx, j] * T;
sumxj += x[j];
_lnHenry += x[j] * Sym.Par(lnHij);
}
}
_lnHenry = _lnHenry / Sym.Par(sumxj);
_henry = Sym.Exp(_lnHenry);
_dhenryDx = new Expression[NC];
DiffFunctional = (cache, v) => _henry.Diff(cache, v);
EvalFunctional = (cache) => _henry.Eval(cache);
}
public EquilibriumTray(int number, ThermodynamicSystem system)
{
_system = system;
Number = number;
var numString = number.ToString();
T = system.VariableFactory.CreateVariable("T", numString, "Stage Temperature", PhysicalDimension.Temperature);
TV = system.VariableFactory.CreateVariable("TV", numString, "Stage Vapor Temperature", PhysicalDimension.Temperature);
DP = system.VariableFactory.CreateVariable("DP", numString, "Pressure Drop", PhysicalDimension.Pressure);
DP.LowerBound = 0;
DP.ValueInSI = 0;
p = system.VariableFactory.CreateVariable("P", numString, "Stage Pressure", PhysicalDimension.Pressure);
Q = system.VariableFactory.CreateVariable("Q", numString, "Heat Duty", PhysicalDimension.HeatFlow);
L = system.VariableFactory.CreateVariable("L", numString, "Liquid molar flow", PhysicalDimension.MolarFlow);
V = system.VariableFactory.CreateVariable("V", numString, "Vapor molar flow", PhysicalDimension.MolarFlow);
U = system.VariableFactory.CreateVariable("U", numString, "Liquid molar flow", PhysicalDimension.MolarFlow);
W = system.VariableFactory.CreateVariable("W", numString, "Vapor molar flow", PhysicalDimension.MolarFlow);
F = system.VariableFactory.CreateVariable("F", numString, "Feed molar flow", PhysicalDimension.MolarFlow);
RL = system.VariableFactory.CreateVariable("RL", numString, "Liquid sidestream fraction", PhysicalDimension.Dimensionless);
RV = system.VariableFactory.CreateVariable("RV", numString, "Vapor sidestream fraction", PhysicalDimension.Dimensionless);
RV.LowerBound = 0;
RL.LowerBound = 0;
HF = system.VariableFactory.CreateVariable("HF", numString, "Feed specific molar enthalpy", PhysicalDimension.SpecificMolarEnthalpy);
HL = system.VariableFactory.CreateVariable("HL", numString, "Liquid specific molar enthalpy", PhysicalDimension.SpecificMolarEnthalpy);
HV = system.VariableFactory.CreateVariable("HV", numString, "Vapor specific molar enthalpy", PhysicalDimension.SpecificMolarEnthalpy);
eps = system.VariableFactory.CreateVariable("eps", numString, "Tray efficiency", PhysicalDimension.Dimensionless);
eps.ValueInSI = 1;
eps.LowerBound = 0;
eps.UpperBound = 1;
K = new Variable[system.Components.Count];
x = new Variable[system.Components.Count];
y = new Variable[system.Components.Count];
yeq = new Variable[system.Components.Count];
z = new Variable[system.Components.Count];
for (int i = 0; i < system.Components.Count; i++)
{
K[i] = system.VariableFactory.CreateVariable("K", numString + ", " + system.Components[i].ID, "Equilibrium partition coefficient", PhysicalDimension.Dimensionless);
K[i].ValueInSI = 1.2;
K[i].LowerBound = 1e-8;
K[i].UpperBound = 1e6;
x[i] = system.VariableFactory.CreateVariable("x", numString + ", " + system.Components[i].ID, "Liquid molar fraction", PhysicalDimension.MolarFraction);
y[i] = system.VariableFactory.CreateVariable("y", numString + ", " + system.Components[i].ID, "Vapor molar fraction", PhysicalDimension.MolarFraction);
yeq[i] = system.VariableFactory.CreateVariable("yeq", numString + ", " + system.Components[i].ID, "Equilibrium Vapor molar fraction", PhysicalDimension.MolarFraction);
z[i] = system.VariableFactory.CreateVariable("z", numString + ", " + system.Components[i].ID, "Feed molar fraction", PhysicalDimension.MolarFraction);
}
}
public Mixer(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "Mixer";
Icon.IconType = IconTypes.Mixer;
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, -1));
MaterialPorts.Add(new Port <MaterialStream>("Out", PortDirection.Out, 1));
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p = system.VariableFactory.CreateVariable("P", "Pressure in mixer", PhysicalDimension.Pressure);
dp.LowerBound = -1e8;
dp.ValueInSI = 0;
AddVariable(dp);
AddVariable(p);
}
public Splitter(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "Splitter";
Icon.IconType = IconTypes.Splitter;
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("Out1", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("Out2", PortDirection.Out, 1));
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p = system.VariableFactory.CreateVariable("P", "Pressure in splitter", PhysicalDimension.Pressure);
SplitFactor = system.VariableFactory.CreateVariable("K", "Split factor (molar)", PhysicalDimension.MolarFraction);
dp.LowerBound = 0;
AddVariable(dp);
AddVariable(SplitFactor);
AddVariable(p);
}
public ShellAndTubeHeatExchanger(string name, ThermodynamicSystem system, int passes, int discretization) : base(name, system)
{
Class = "Shell&Tube";
Icon.IconType = IconTypes.HeatExchanger;
_numberOfPasses = passes;
_discretization = discretization;
MaterialPorts.Add(new Port <MaterialStream>("ShellIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("ShellOut", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("TubeIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("TubeOut", PortDirection.Out, 1));
_area = system.VariableFactory.CreateVariable("A", "Area", PhysicalDimension.Area);
_koverall = system.VariableFactory.CreateVariable("k", "Effective Heat Transfer Coefficient", PhysicalDimension.HeatTransferCoefficient);
AddVariables(_area, _koverall);
}
public ActivityCoefficientWilson(ThermodynamicSystem system, Variable T, List <Variable> x, int idx)
{
Symbol = "WILSON_GAMMA";
_system = system;
index = idx;
Parameters.Add(T);
foreach (var comp in x)
{
Parameters.Add(comp);
}
NC = system.Components.Count;
this.T = T;
this.x = x;
var parameterSet = _system.BinaryParameters.FirstOrDefault(ps => ps.Name == "WILSON");
if (parameterSet == null)
{
throw new ArgumentNullException("No WILSON parameters defined");
}
double[,] a = parameterSet.Matrices["A"];
double[,] b = parameterSet.Matrices["B"];
double[,] c = parameterSet.Matrices["C"];
double[,] d = parameterSet.Matrices["D"];
var lambda = new Expression[NC, NC];
for (int i = 0; i < NC; i++)
{
for (int j = 0; j < NC; j++)
{
lambda[i, j] = Sym.Exp(a[i, j] + b[i, j] / T + c[i, j] * Sym.Ln(T) + d[i, j] * T);
}
}
Expression H1 = Sym.Sum(0, NC, (k) => x[k] * lambda[index, k]);
Expression H2 = Sym.Sum(0, NC, (k) => x[k] * lambda[k, index] / Sym.Sum(0, NC, (j) => x[j] * lambda[k, j]));
_gammaExp = Sym.Exp(1 - Sym.Ln(H1) - H2);
_dgammaDx = new Expression[NC];
DiffFunctional = (cache, v) => _gammaExp.Diff(cache, v);
EvalFunctional = (cache) => _gammaExp.Eval(cache);
}
void FillNRTL(ThermodynamicSystem system)
{
if (!File.Exists(".\\Data\\nrtl.ipd"))
{
throw new FileNotFoundException("NRTL parameter database not found. Please install ChemSep Lite and copy the nrtl.ipd file to the Data directory of this program.");
}
if (nrtlDB == null)
{
LoadNRTLDB();
}
var nrtlParamSet = new NRTL(system);
if (system.BinaryParameters.Count(ps => ps.Name == "NRTL") == 0)
{
system.BinaryParameters.Add(nrtlParamSet);
}
//var Rcal = 1.9872;
for (int i = 0; i < system.Components.Count; i++)
{
var c1 = system.Components[i];
for (int j = i; j < system.Components.Count; j++)
{
var c2 = system.Components[j];
var entry = (from e in nrtlDB
where (e.Cas1 == c1.CasNumber && e.Cas2 == c2.CasNumber) || (e.Cas1 == c2.CasNumber && e.Cas2 == c1.CasNumber)
select e).FirstOrDefault();
if (entry != null)
{
nrtlParamSet.SetParam("B", c1, c2, entry.Aij / 1.9872);
nrtlParamSet.SetParam("B", c2, c1, entry.Aji / 1.9872);
nrtlParamSet.SetParam("C", c1, c2, entry.Alpha);
nrtlParamSet.SetParam("C", c2, c1, entry.Alpha);
Write("Found NRTL parameter set for " + c1.ID + " / " + c2.ID + Environment.NewLine);
}
}
}
}
public Phase(string symbol, ThermodynamicSystem system)
{
Name = symbol;
_system = system;
Temperature = _system.VariableFactory.CreateVariable("T" + symbol, "Temperature", PhysicalDimension.Temperature);
Pressure = _system.VariableFactory.CreateVariable("p" + symbol, "Pressure", PhysicalDimension.Pressure);
SpecificEnthalpy = _system.VariableFactory.CreateVariable("h" + symbol, "Molar specific enthalpy", PhysicalDimension.SpecificMolarEnthalpy);
TotalEnthalpy = _system.VariableFactory.CreateVariable("H" + symbol, "Total enthalpy", PhysicalDimension.Enthalpy);
TotalVolumeflow = _system.VariableFactory.CreateVariable("V" + symbol, "Volume flow", PhysicalDimension.VolumeFlow);
TotalMolarflow = _system.VariableFactory.CreateVariable("n" + symbol, "Total molar flow", PhysicalDimension.MolarFlow);
TotalMassflow = _system.VariableFactory.CreateVariable("m" + symbol, "Total mass flow", PhysicalDimension.MassFlow);
Density = _system.VariableFactory.CreateVariable("rho" + symbol, "Density", PhysicalDimension.MassDensity);
DensityMolar = _system.VariableFactory.CreateVariable("rhom" + symbol, "Density", PhysicalDimension.MolarDensity);
TotalMolarVolume = _system.VariableFactory.CreateVariable("v" + symbol, "Total molar volume", PhysicalDimension.MolarVolume);
Variables.Add(Temperature);
Variables.Add(Pressure);
Variables.Add(SpecificEnthalpy);
Variables.Add(Density);
Variables.Add(DensityMolar);
Variables.Add(TotalEnthalpy);
Variables.Add(TotalVolumeflow);
Variables.Add(TotalMolarflow);
Variables.Add(TotalMassflow);
foreach (var comp in system.Components)
{
ComponentMolarFraction.Add(_system.VariableFactory.CreateVariable("x" + symbol, comp.ID, "Molar Fraction of component " + comp.ID, PhysicalDimension.MolarFraction));
ComponentMassFraction.Add(_system.VariableFactory.CreateVariable("w" + symbol, comp.ID, "Molar Fraction of component " + comp.ID, PhysicalDimension.MassFraction));
ComponentMolarflow.Add(_system.VariableFactory.CreateVariable("n" + symbol, comp.ID, "Molar flow of component " + comp.ID, PhysicalDimension.MolarFlow));
ComponentMassflow.Add(_system.VariableFactory.CreateVariable("m" + symbol, comp.ID, "Mass flow of component " + comp.ID, PhysicalDimension.MassFlow));
ComponentMolarVolume.Add(_system.VariableFactory.CreateVariable("v" + symbol, comp.ID, "Molar volume of component " + comp.ID, PhysicalDimension.MolarVolume));
ComponentEnthalpy.Add(_system.VariableFactory.CreateVariable("h" + symbol, comp.ID, "Specific Molar Enthalpy of component " + comp.ID, PhysicalDimension.SpecificMolarEnthalpy));
}
Variables.AddRange(ComponentMolarFraction);
Variables.AddRange(ComponentMassFraction);
Variables.AddRange(ComponentMolarflow);
Variables.AddRange(ComponentMassflow);
Variables.AddRange(ComponentMolarVolume);
Variables.AddRange(ComponentEnthalpy);
}
public void FillBIPs(ThermodynamicSystem system)
{
switch (system.EquilibriumMethod.Activity)
{
case ActivityMethod.NRTL:
case ActivityMethod.NRTLRP:
FillNRTL(system);
break;
case ActivityMethod.UNIQUAC:
FillUniquac(system);
break;
}
if (system.EquilibriumMethod.Fugacity == FugacityMethod.SoaveRedlichKwong || system.EquilibriumMethod.EquationOfState == EquationOfState.SoaveRedlichKwong)
{
FillSRK(system);
}
}
public Decanter(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "Decanter";
Icon.IconType = IconTypes.ThreePhaseFlash;
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("Vap", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("Liq1", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("Liq2", PortDirection.Out, 1));
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p = system.VariableFactory.CreateVariable("P", "Pressure in flash", PhysicalDimension.Pressure);
T = system.VariableFactory.CreateVariable("T", "Temperature in flash", PhysicalDimension.Temperature);
Q = system.VariableFactory.CreateVariable("Q", "Heat Duty", PhysicalDimension.HeatFlow);
VF = system.VariableFactory.CreateVariable("VF", "Vapor Fraction", PhysicalDimension.MolarFraction);
KLL = new Variable[system.Components.Count];
S = new Variable[system.Components.Count];
for (int i = 0; i < system.Components.Count; i++)
{
KLL[i] = system.VariableFactory.CreateVariable("KLL", "Equilibrium partition coefficient (LLE)", PhysicalDimension.Dimensionless);
KLL[i].Subscript = system.Components[i].ID;
KLL[i].ValueInSI = 1.2;
KLL[i].UpperBound = 1e6;
S[i] = system.VariableFactory.CreateVariable("S", "Split fraction between Liquid Phases)", PhysicalDimension.Dimensionless);
S[i].Subscript = system.Components[i].ID;
S[i].ValueInSI = 0.5;
S[i].UpperBound = 1;
}
dp.LowerBound = -1e10;
dp.ValueInSI = 0;
AddVariable(p);
AddVariable(T);
AddVariable(Q);
AddVariable(VF);
AddVariable(dp);
AddVariables(KLL);
AddVariables(S);
}
static void Main(string[] args)
{
var sys = new ThermodynamicSystem("Test", "NRTL", "default");
var adapter = new ChemSepDBAdapter.Adapter();
adapter.SetLogCallback(Console.Write);
var comp1 = adapter.FindComponent("Ethanol");
var comp2 = adapter.FindComponent("Water");
sys.AddComponent(comp1);
sys.AddComponent(comp2);
adapter.FillBIPs(sys);
Console.WriteLine(comp1.Name + "[" + comp1.CasNumber + "]");
Console.WriteLine(comp2.Name + "[" + comp2.CasNumber + "]");
Console.ReadLine();
}
public ThermodynamicSystemEditorViewModel(IEventAggregator aggregator, ThermodynamicSystem source, IThermodynamicSystemImporter importer, IChartViewModelFactory chartFactory)
{
_aggregator = aggregator;
// _source = new ThermodynamicSystemEntity(source.Name);
CurrentSystem = source;
_importer = importer;
_chartFactory = chartFactory;
_aggregator.Subscribe(this);
//ScriptDocument = new TextDocument(_source.SourceCode);
var types = Enum.GetValues(typeof(EvaluatedProperties));
foreach (var type in types.OfType <EvaluatedProperties>())
{
AvailableFunctionTypes.Add(type);
}
// ParseInputFile();
ComponentsForPureAnalysis = CurrentSystem.Components.Select(c => new CheckableComponent()
{
Data = c
}).ToList();
}
public ComponentSplitter(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "CSplitter";
MaterialPorts.Add(new Port <MaterialStream>("In", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("Out1", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("Out2", PortDirection.Out, 1));
dp = system.VariableFactory.CreateVariable("DP", "Pressure Drop", PhysicalDimension.Pressure);
p = system.VariableFactory.CreateVariable("P", "Pressure in splitter", PhysicalDimension.Pressure);
SplitFactors = new Variable[system.Components.Count];
for (int i = 0; i < system.Components.Count; i++)
{
SplitFactors[i] = system.VariableFactory.CreateVariable("K", "Component Split factor (molar)", PhysicalDimension.MolarFraction);
SplitFactors[i].Subscript = system.Components[i].ID;
}
dp.LowerBound = 0;
AddVariable(dp);
AddVariables(SplitFactors);
AddVariable(p);
}
public EnthalpyRoute(ThermodynamicSystem system, Variable T, Variable p, List <Variable> x, PhaseState phase)
{
Symbol = "H" + (phase == PhaseState.Liquid ? "L" : "V");
_system = system;
this.T = T;
this.p = p;
this.x = x;
Parameters.Add(T);
Parameters.Add(p);
foreach (var comp in x)
{
Parameters.Add(comp);
}
NC = _system.Components.Count;
_hi = new Expression[NC];
for (int i = 0; i < NC; i++)
{
if (phase == PhaseState.Liquid)
{
_hi[i] = x[i] * _system.EquationFactory.GetLiquidEnthalpyExpression(_system, i, T);
}
else
{
_hi[i] = x[i] * _system.EquationFactory.GetVaporEnthalpyExpression(_system, i, T);
}
}
_htotal = Sym.Binding(Symbol, (Sym.Sum(0, NC, (idx) => _hi[idx])));
DiffFunctional = (cache, v) => NumDiff(cache, v);
EvalFunctional = (cache) => Evaluate(cache);
}
public NonEquilibriumTray(int number, ThermodynamicSystem system)
{
_system = system;
Number = number;
var numString = number.ToString();
h = system.VariableFactory.CreateVariable("h", numString, "Packing height", PhysicalDimension.Length);
d = system.VariableFactory.CreateVariable("d", numString, "Packing diameter", PhysicalDimension.Length);
aspez = system.VariableFactory.CreateVariable("aspec", numString, "Specific Area", PhysicalDimension.SpecificArea);
aeff = system.VariableFactory.CreateVariable("aeff", numString, "Effective Area", PhysicalDimension.Area);
dhyd = system.VariableFactory.CreateVariable("dhyd", numString, "Hydrodynamic diameter", PhysicalDimension.Length);
uV = system.VariableFactory.CreateVariable("uV", numString, "Superficial velocity", PhysicalDimension.Velocity);
ReV = system.VariableFactory.CreateVariable("ReV", numString, "Reynolds number vapor", PhysicalDimension.Dimensionless);
dhyd.ValueInSI = 0.00723;
h.ValueInSI = 3;
d.ValueInSI = 0.7;
aspez.ValueInSI = 250;
aeff.ValueInSI = 100;
h.IsFixed = true;
d.IsFixed = true;
aspez.IsFixed = true;
dhyd.IsFixed = true;
TL = system.VariableFactory.CreateVariable("TL", numString, "Liquid Temperature", PhysicalDimension.Temperature);
TI = system.VariableFactory.CreateVariable("TI", numString, "Interphase Temperature", PhysicalDimension.Temperature);
TV = system.VariableFactory.CreateVariable("TV", numString, "Vapor Temperature", PhysicalDimension.Temperature);
DP = system.VariableFactory.CreateVariable("DP", numString, "Pressure Drop", PhysicalDimension.Pressure);
DP.LowerBound = 0;
DP.ValueInSI = 0;
p = system.VariableFactory.CreateVariable("P", numString, "Pressure", PhysicalDimension.Pressure);
Q = system.VariableFactory.CreateVariable("Q", numString, "Heat Duty to liquid phase", PhysicalDimension.HeatFlow);
E = system.VariableFactory.CreateVariable("E", numString, "Total heat transfer rate (Interface)", PhysicalDimension.HeatFlow);
L = system.VariableFactory.CreateVariable("L", numString, "Liquid molar flow", PhysicalDimension.MolarFlow);
V = system.VariableFactory.CreateVariable("V", numString, "Vapor molar flow", PhysicalDimension.MolarFlow);
HL = system.VariableFactory.CreateVariable("HL", numString, "Liquid specific molar enthalpy", PhysicalDimension.SpecificMolarEnthalpy);
HV = system.VariableFactory.CreateVariable("HV", numString, "Vapor specific molar enthalpy", PhysicalDimension.SpecificMolarEnthalpy);
K = new Variable[system.Components.Count];
x = new Variable[system.Components.Count];
y = new Variable[system.Components.Count];
xI = new Variable[system.Components.Count];
yI = new Variable[system.Components.Count];
N = new Variable[system.Components.Count];
BetaV = new Variable[system.Components.Count, system.Components.Count];
BetaL = new Variable[system.Components.Count, system.Components.Count];
for (int i = 0; i < system.Components.Count; i++)
{
K[i] = system.VariableFactory.CreateVariable("K", numString + ", " + system.Components[i].ID, "Equilibrium partition coefficient", PhysicalDimension.Dimensionless);
K[i].ValueInSI = 1.2;
x[i] = system.VariableFactory.CreateVariable("x", numString + ", " + system.Components[i].ID, "Liquid molar fraction", PhysicalDimension.MolarFraction);
y[i] = system.VariableFactory.CreateVariable("y", numString + ", " + system.Components[i].ID, "Vapor molar fraction", PhysicalDimension.MolarFraction);
yI[i] = system.VariableFactory.CreateVariable("yI", numString + ", " + system.Components[i].ID, "Vapor molar fraction (Interface)", PhysicalDimension.MolarFraction);
xI[i] = system.VariableFactory.CreateVariable("xI", numString + ", " + system.Components[i].ID, "Liquid molar fraction (Interface)", PhysicalDimension.MolarFraction);
N[i] = system.VariableFactory.CreateVariable("N", numString + ", " + system.Components[i].ID, "Total transfer rate (Interface)", PhysicalDimension.MolarFlow);
N[i].LowerBound = -1e6;
N[i].ValueInSI = 0.0;
for (int j = 0; j < system.Components.Count; j++)
{
BetaV[i, j] = system.VariableFactory.CreateVariable("BetaV", numString + ", " + system.Components[i].ID + ", " + system.Components[j].ID, "Vapor Mass-transfer coefficient)", PhysicalDimension.MassTransferCoefficient);
BetaV[i, j].IsFixed = true;
if (i != j)
{
BetaV[i, j].ValueInSI = 0.02;
}
BetaL[i, j] = system.VariableFactory.CreateVariable("BetaL", numString + ", " + system.Components[i].ID + ", " + system.Components[j].ID, "Liquid Mass-transfer coefficient)", PhysicalDimension.MassTransferCoefficient);
BetaL[i, j].IsFixed = true;
if (i != j)
{
BetaL[i, j].ValueInSI = 0.02;
}
}
}
}
public RateBasedSection(string name, ThermodynamicSystem system, int numberOfElements) : base(name, system)
{
Class = "RateSection";
NumberOfElements = numberOfElements;
Icon.IconType = IconTypes.RateBasedSection;
var NC = system.Components.Count;
MaterialPorts.Add(new Port <MaterialStream>("VIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("LIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("VOut", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("LOut", PortDirection.Out, 1));
for (int i = 0; i < NumberOfElements; i++)
{
var tray = new NonEquilibriumTray(i + 1, system);
_trays.Add(tray);
}
AddVariables(_trays.Select(t => t.TL).ToArray());
AddVariables(_trays.Select(t => t.TI).ToArray());
AddVariables(_trays.Select(t => t.TV).ToArray());
AddVariables(_trays.Select(t => t.p).ToArray());
AddVariables(_trays.Select(t => t.DP).ToArray());
AddVariables(_trays.Select(t => t.Q).ToArray());
AddVariables(_trays.Select(t => t.E).ToArray());
AddVariables(_trays.Select(t => t.L).ToArray());
AddVariables(_trays.Select(t => t.V).ToArray());
AddVariables(_trays.Select(t => t.HL).ToArray());
AddVariables(_trays.Select(t => t.HV).ToArray());
AddVariables(_trays.Select(t => t.aeff).ToArray());
AddVariables(_trays.Select(t => t.aspez).ToArray());
AddVariables(_trays.Select(t => t.d).ToArray());
AddVariables(_trays.Select(t => t.h).ToArray());
AddVariables(_trays.Select(t => t.dhyd).ToArray());
AddVariables(_trays.Select(t => t.ReV).ToArray());
AddVariables(_trays.Select(t => t.uV).ToArray());
for (int i = 0; i < NumberOfElements; i++)
{
AddVariables(_trays[i].K);
}
for (int i = 0; i < NumberOfElements; i++)
{
AddVariables(_trays[i].x);
}
for (int i = 0; i < NumberOfElements; i++)
{
AddVariables(_trays[i].xI);
}
for (int i = 0; i < NumberOfElements; i++)
{
AddVariables(_trays[i].y);
}
for (int i = 0; i < NumberOfElements; i++)
{
AddVariables(_trays[i].yI);
}
for (int i = 0; i < NumberOfElements; i++)
{
AddVariables(_trays[i].N);
}
for (int n = 0; n < NumberOfElements; n++)
{
for (int i = 0; i < NC; i++)
{
for (int j = 0; j < NC; j++)
{
AddVariables(_trays[n].BetaV[i, j]);
}
}
}
}
public ProcessUnit(string name, ThermodynamicSystem system) : base(name, system)
{
}
public ActivityCoefficientNRTL(ThermodynamicSystem system, Variable T, List <Variable> x, int idx)
{
index = idx;
_system = system;
var parameterSet = _system.BinaryParameters.FirstOrDefault(ps => ps.Name == "NRTL");
if (parameterSet == null)
{
throw new ArgumentNullException("No NRTL parameters defined");
}
double[,] a = parameterSet.Matrices["A"];
double[,] b = parameterSet.Matrices["B"];
double[,] c = parameterSet.Matrices["C"];
double[,] d = parameterSet.Matrices["D"];
double[,] e = parameterSet.Matrices["E"];
double[,] f = parameterSet.Matrices["F"];
Symbol = "NRTL_GAMMA";
this.T = T;
this.x = x;
Parameters.Add(T);
foreach (var comp in x)
{
Parameters.Add(comp);
}
NC = system.Components.Count;
tau = new Expression[NC, NC];
G = new Expression[NC, NC];
int i = index;
for (int ii = 0; ii < NC; ii++)
{
for (int j = 0; j < NC; j++)
{
tau[ii, j] = a[ii, j];
if (b[ii, j] != 0.0)
{
tau[ii, j] += b[ii, j] / T;
}
if (e[ii, j] != 0.0)
{
tau[ii, j] += e[ii, j] * Sym.Ln(T);
}
if (f[ii, j] != 0.0)
{
tau[ii, j] += f[ii, j] * T;
}
Expression sij = c[ii, j];
if (d[ii, j] != 0.0)
{
sij += d[ii, j] * (T - 273.15);
}
if (c[ii, j] == 0.0 && d[i, j] == 0.0)
{
G[ii, j] = 1.0;
}
else
{
G[ii, j] = (Sym.Exp(-sij * tau[ii, j]));
}
}
}
Expression lnGamma = 0.0;
Expression S1 = 0.0;
Expression[] S2 = new Expression[NC];
Expression S3 = 0.0;
for (int j = 0; j < NC; j++)
{
if (a[j, i] == 0.0 && b[j, i] == 0.0)
{
continue;
}
if (c[j, i] == 0.0 && d[j, i] == 0.0)
{
continue;
}
S1 += x[j] * tau[j, i] * G[j, i];
}
for (int ii = 0; ii < NC; ii++)
{
S2[ii] = 0.0;
for (int k = 0; k < NC; k++)
{
S2[ii] += x[k] * G[k, ii];
}
}
for (int j = 0; j < NC; j++)
{
Expression S5 = 0.0;
for (int m = 0; m < NC; m++)
{
if (a[m, j] == 0.0 && b[m, j] == 0.0)
{
continue;
}
S5 += x[m] * tau[m, j] * G[m, j];
}
S3 += x[j] * G[i, j] / Sym.Par(S2[j]) * (tau[i, j] - S5 / Sym.Par(S2[j]));
}
lnGamma = S1 / S2[i] + S3;
_gammaExp = Sym.Exp(lnGamma);
_dgammaDx = new Expression[NC];
DiffFunctional = (cache, v) => _gammaExp.Diff(cache, v);
EvalFunctional = (cache) => _gammaExp.Eval(cache);
}
public HeatExchangerCell(string name, ThermodynamicSystem system) : base(name, system)
{
Class = "HexCell";
}
public void Report(ThermodynamicSystem system)
{
WriteLine("");
WriteLine("Report for thermodynamic system " + system.Name);
WriteLine("================================================");
WriteLine("");
WriteLine("Equilibrium");
WriteLine("");
WriteLine("VLEQ Method : " + system.EquilibriumMethod.EquilibriumApproach);
WriteLine("Activity Method : " + system.EquilibriumMethod.Activity);
WriteLine("Fugacity Method : " + system.EquilibriumMethod.Fugacity);
WriteLine("Henry Method : " + system.EquilibriumMethod.AllowHenryComponents);
WriteLine("");
WriteLine("Unit of Measure");
WriteLine("");
WriteLine(String.Format("{0,-25} {1,-15} {2,-15}", "Dimension", "Input", "Output"));
foreach (var unit in system.VariableFactory.Internal.UnitDictionary)
{
WriteLine(String.Format("{0,-25} {1,-15} {2,-15}", unit.Key, unit.Value, system.VariableFactory.Output.UnitDictionary[unit.Key]));
}
WriteLine("");
WriteLine("Components");
WriteLine("");
WriteLine(String.Format("{0,-25} {1,-15} {2,-15} {3,-15} {4,-15} {5,-15} {6,-15}", "Name", "ID", "CAS-No", "Inert", "MOLW", "TC", "PC"));
foreach (var comp in system.Components)
{
WriteLine(String.Format("{0,-25} {1,-15} {2,-15} {3,-15} {4,-15} {5,-15} {6,-15}",
comp.Name,
comp.ID,
comp.CasNumber,
comp.IsInert,
comp.GetConstant(ConstantProperties.MolarWeight).ValueInSI.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo),
comp.GetConstant(ConstantProperties.CriticalTemperature).ValueInSI.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo),
comp.GetConstant(ConstantProperties.CriticalPressure).ValueInSI.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo)));
}
WriteLine("");
WriteLine("Enthalpy Functions");
WriteLine("");
WriteLine(String.Format("{0,-15} {1,-10} {2,-12} {3,-8} {4,-8} {5,-5}", "Comp", "Phase", "Href", "Tref", "TPc", "Fixed Phase Change"));
foreach (var enth in system.EnthalpyMethod.PureComponentEnthalpies)
{
WriteLine(String.Format("{0,-15} {1,-10} {2,-12} {3,-8} {4,-8} {5,-5}",
enth.Component.ID,
enth.ReferenceState,
enth.Href.ValueInOutputUnit.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo),
enth.Tref.ValueInOutputUnit.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo),
enth.TPhaseChange.ValueInOutputUnit.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo),
!enth.PhaseChangeAtSystemTemperature));
}
WriteLine("");
WriteLine("Property Functions");
WriteLine("");
WriteLine(String.Format("{0,-15} {1,-25} {2,-15} {3,-8} {4,-8} {5,-5} {6,-25}", "Comp", "Property", "Form", "Min T", "Max T", "Coeff", "Equation"));
foreach (var comp in system.Components)
{
foreach (var func in comp.Functions)
{
WriteLine(String.Format("{0,-15} {1,-25} {2,-15} {3,-8} {4,-8} {5,-5} {6,-25}",
comp.ID,
func.Property,
func.Type,
func.MinimumX.ValueInSI.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo),
func.MaximumX.ValueInSI.ToString("G6", System.Globalization.NumberFormatInfo.InvariantInfo),
func.Coefficients.Count,
"Y = " + system.CorrelationFactory.CreateExpression(func.Type, func, new OpenFMSL.Core.Expressions.Variable("T", 1), new OpenFMSL.Core.Expressions.Variable("TC", 1), new OpenFMSL.Core.Expressions.Variable("PC", 1)).ToString()));
}
}
WriteLine("");
WriteLine("Chemistry blocks");
WriteLine("");
WriteLine(String.Format("{0,-10} {1,-10} {2,-10} {3,-40} {4,-20} ", "Label", "Type", "DHR", "Reaction", "Stoichiometry"));
foreach (var chem in system.ChemistryBlocks)
{
foreach (var reac in chem.Reactions)
{
WriteLine(String.Format("{0,-10} {1,-10} {2,-10} {3,-40} {4,-20} ",
chem.Label,
reac.Type,
reac.ReactionEnthalpy,
GetReactionFunction(reac),
GetReactionStoichiometry(reac)
));
}
}
}
void ParseSystem(string[] line)
{
_currentSystem = new ThermodynamicSystem();
_currentSystem.Name = line[1];
Systems.Add(_currentSystem);
}
/// <summary>
/// Creates a new instance of the liquid phase activity coefficient calculation object
/// </summary>
/// <param name="sys">Thermodynamic system to take parameters from</param>
/// <param name="T">Temperature variable</param>
/// <param name="x">Vector of composition variables (molar fractions)</param>
/// <param name="idx">Index of the active variables to calculate for</param>
public ActivityCoefficientUNIQUAC(ThermodynamicSystem sys, Variable T, List <Variable> x, int idx)
{
Symbol = "UNIQUAC_GAMMA";
_system = sys;
index = idx;
//Bind variables to this instance
this.T = T;
this.x = x;
Parameters.Add(T);
foreach (var comp in x)
{
Parameters.Add(comp);
}
NC = _system.Components.Count;
tau = new Expression[NC, NC];
int i = index;
var parameterSet = _system.BinaryParameters.FirstOrDefault(ps => ps.Name == "UNIQUAC");
if (parameterSet == null)
{
throw new ArgumentNullException("No UNIQUAC parameters defined");
}
double[,] a = parameterSet.Matrices["A"];
double[,] b = parameterSet.Matrices["B"];
double[,] c = parameterSet.Matrices["C"];
double[,] d = parameterSet.Matrices["D"];
double[,] e = parameterSet.Matrices["E"];
for (int ii = 0; ii < NC; ii++)
{
for (int j = 0; j < NC; j++)
{
tau[ii, j] = Sym.Exp(a[ii, j] + b[ii, j] / T + c[ii, j] * Sym.Ln(T) + d[ii, j] * T + e[ii, j] / Sym.Pow(T, 2));
}
}
Expression lnGamma = 0.0;
Expression lnGammaComb = 0.0;
Expression lnGammaRes = 0.0;
Expression Vi = 0;
Expression Fi = 0;
Expression FiP = 0;
Expression Sxl = 0;
var ri = _system.Components.Select(co => co.GetParameter(MethodTypes.Uniquac, "R").ValueInSI).ToList();
var qi = _system.Components.Select(co => co.GetParameter(MethodTypes.Uniquac, "Q").ValueInSI).ToList();
var qpi = _system.Components.Select(co => co.GetParameter(MethodTypes.Uniquac, "Q'").ValueInSI).ToList();
double[] li = new double[NC];
for (int j = 0; j < NC; j++)
{
li[j] = 5 * (ri[j] - qi[j]) - (ri[j] - 1);
}
Vi = ri[i] * x[i] / Sym.Sum(0, NC, (j) => ri[j] * x[j]);
Fi = qi[i] * x[i] / Sym.Sum(0, NC, (j) => qi[j] * x[j]);
FiP = qpi[i] * x[i] / Sym.Sum(0, NC, (j) => qpi[j] * x[j]);
//Sxl = Sym.Sum(0, NC, (j) => (5 * (_system.Components[j].GetParameter(MethodTypes.Uniquac, "R").ValueInSI - _system.Components[j].GetParameter(MethodTypes.Uniquac, "Q").ValueInSI) - (_system.Components[j].GetParameter(MethodTypes.Uniquac, "R").ValueInSI - 1)) * x[j]);
lnGammaComb = Sym.Ln(Vi / Sym.Max(1e-10, x[i])) + 5 * qi[i] * Sym.Ln(Fi / Vi) + li[i] - Vi / Sym.Max(1e-10, x[i]) * Sym.Sum(0, NC, j => x[j] * li[j]);
Expression[] FPj = new Expression[_system.Components.Count];
for (int j = 0; j < NC; j++)
{
FPj[j] = qpi[j] * x[j] / Sym.Sum(0, NC, (kj) => qpi[kj] * x[kj]);
}
var doubleSum = Sym.Sum(0, NC, (j) => FPj[j] * tau[i, j] / (Sym.Sum(0, NC, (k) => FPj[k] * tau[k, j])));
var SFP = Sym.Sum(0, NC, (j) => FPj[j] * tau[j, i]);
lnGammaRes = qpi[i] * (1.0 - Sym.Ln(SFP) - doubleSum);
lnGamma = lnGammaComb + lnGammaRes;
_gamma_exp = Sym.Exp(lnGamma);
_dgamma_dx = new Expression[NC];
DiffFunctional = (cache, v) => _gamma_exp.Diff(cache, v);
EvalFunctional = (cache) => _gamma_exp.Eval(cache);
}
public K_EOS_SRK(ThermodynamicSystem system, Variable T, Variable p, List <Variable> x, List <Variable> y, int idx)
{
index = idx;
_system = system;
this.T = T;
this.p = p;
this.x = x;
this.y = y;
Symbol = "EQ_SRK";
Parameters.Add(T);
Parameters.Add(p);
foreach (var c in x)
{
Parameters.Add(c);
}
foreach (var c in y)
{
Parameters.Add(c);
}
NC = system.Components.Count;
var ai = new double[NC];
var bi = new double[NC];
var Ai = new Expression[NC];
var aij = new Expression[NC, NC];
var bij = new double[NC, NC];
double[,] kij = new double[NC, NC];
double[,] kbij = new double[NC, NC];
var parameterSet = _system.BinaryParameters.FirstOrDefault(ps => ps.Name == "SRK");
if (parameterSet != null)
{
kij = parameterSet.Matrices["kij"];
if (parameterSet.Matrices.ContainsKey("kbij"))
{
kbij = parameterSet.Matrices["kbij"];
}
}
for (int i = 0; i < system.Components.Count; i++)
{
var comp = system.Components[i];
var TC = comp.GetConstant(ConstantProperties.CriticalTemperature);
var PC = comp.GetConstant(ConstantProperties.CriticalPressure);
var AC = comp.GetConstant(ConstantProperties.AcentricFactor);
if (comp.HasParameter(MethodTypes.RKS, "A"))
{
ai[i] = comp.GetParameter(MethodTypes.RKS, "A").ValueInSI;
}
else
{
ai[i] = 0.42748 * Math.Pow(R.ValueInSI, 2.0) * Math.Pow(TC.ValueInSI, 2.0) / PC.ValueInSI;
}
if (comp.HasParameter(MethodTypes.RKS, "B"))
{
bi[i] = comp.GetParameter(MethodTypes.RKS, "B").ValueInSI;
}
else
{
bi[i] = 0.0867 * R.ValueInSI * TC.ValueInSI / PC.ValueInSI;
}
var mi = 0.48 + 1.574 * AC.ValueInSI - 0.176 * Math.Pow(AC.ValueInSI, 2);
var TR = Sym.Binding("TR", T / TC);
var alphai = Sym.Pow(1.0 + mi * (1 - Sym.Sqrt(TR)), 2.0);
Ai[i] = alphai * ai[i];
}
for (int i = 0; i < system.Components.Count; i++)
{
for (int j = 0; j < system.Components.Count; j++)
{
aij[i, j] = Sym.Sqrt(Ai[i] * Ai[j]) * (1 - kij[i, j]);
bij[i, j] = (bi[i] + bi[j]) / 2.0 * (1 - kbij[i, j]);
}
}
for (int ph = 0; ph < 2; ph++)
{
var z = x;
if (ph == 1)
{
z = y;
}
var am = Sym.Sum(0, NC, i => z[i] * Sym.Sum(0, NC, j => z[j] * aij[i, j]));
var asi = Sym.Sum(0, NC, j => z[j] * aij[idx, j]);
var bm = Sym.Sum(0, NC, i => z[i] * Sym.Sum(0, NC, j => z[j] * bij[i, j]));
var bsi = Sym.Sum(0, NC, j => z[j] * bij[idx, j]);
var vme = new VOL_SRK(T, p, am, bm, ph == 0 ? PhaseState.Liquid : PhaseState.Vapour);
var vm = Sym.Binding("vm", vme);
var Bi = 2 * bsi - bm;
var zm = p * vm / (R * T);
var eterm = -am / (bm * R * T) * (2 * asi / am - Bi / bm) * Sym.Ln(1 + bm / vm) + Bi / bm * (zm - 1);
var eVariable = Sym.Binding("RKS_E", eterm);
//PHI[ph] = (R * T) / ((vm - bm) * p) * Sym.Exp(eVariable);
PHI[ph] = 1.0 / ((vm - bm)) * Sym.Exp(eVariable);
}
//_kEOS_SRK = Sym.Exp(lnPHI[0] - lnPHI[1]);
_kEOS_SRK = PHI[0] / PHI[1];
_dphiDx = new Expression[NC];
_dphiDy = new Expression[NC];
DiffFunctional = (cache, v) => _kEOS_SRK.Diff(cache, v);
EvalFunctional = (cache) => Evaluate(cache);
}
public VOL_SRK(ThermodynamicSystem system, Variable T, Variable p, List <Variable> y)
{
_system = system;
this._T = T;
this._p = p;
this.Phase = PhaseState.Vapour;
Symbol = "VOL_SRK";
var NC = system.Components.Count;
var ai = new double[NC];
var bi = new double[NC];
var Ai = new Expression[NC];
var aij = new Expression[NC, NC];
var bij = new double[NC, NC];
double[,] kij = new double[NC, NC];
double[,] kbij = new double[NC, NC];
// Parameters.Add(T);
// Parameters.Add(p);
// foreach (var c in y)
// Parameters.Add(c);
var parameterSet = _system.BinaryParameters.FirstOrDefault(ps => ps.Name == "SRK");
if (parameterSet != null)
{
kij = parameterSet.Matrices["kij"];
if (parameterSet.Matrices.ContainsKey("kbij"))
{
kbij = parameterSet.Matrices["kbij"];
}
}
for (int i = 0; i < system.Components.Count; i++)
{
var comp = system.Components[i];
var TC = comp.GetConstant(ConstantProperties.CriticalTemperature);
var PC = comp.GetConstant(ConstantProperties.CriticalPressure);
var AC = comp.GetConstant(ConstantProperties.AcentricFactor);
if (comp.HasParameter(MethodTypes.RKS, "A"))
{
ai[i] = comp.GetParameter(MethodTypes.RKS, "A").ValueInSI;
}
else
{
ai[i] = 0.42748 * Math.Pow(_R.ValueInSI, 2.0) * Math.Pow(TC.ValueInSI, 2.0) / PC.ValueInSI;
}
if (comp.HasParameter(MethodTypes.RKS, "B"))
{
bi[i] = comp.GetParameter(MethodTypes.RKS, "B").ValueInSI;
}
else
{
bi[i] = 0.0867 * _R.ValueInSI * TC.ValueInSI / PC.ValueInSI;
}
var mi = 0.48 + 1.574 * AC.ValueInSI - 0.176 * Math.Pow(AC.ValueInSI, 2);
var TR = Sym.Binding("TR", T / TC);
var alphai = Sym.Pow(1.0 + mi * (1 - Sym.Sqrt(TR)), 2.0);
Ai[i] = alphai * ai[i];
}
for (int i = 0; i < system.Components.Count; i++)
{
for (int j = 0; j < system.Components.Count; j++)
{
aij[i, j] = Sym.Sqrt(Ai[i] * Ai[j]) * (1 - kij[i, j]);
bij[i, j] = (bi[i] + bi[j]) / 2.0 * (1 - kbij[i, j]);
}
}
_A = Sym.Sum(0, NC, i => y[i] * Sym.Sum(0, NC, j => y[j] * aij[i, j]));
_B = Sym.Sum(0, NC, i => y[i] * Sym.Sum(0, NC, j => y[j] * bij[i, j]));
DiffFunctional = (cache, v) => NumDiff(cache, v);
EvalFunctional = (cache) => Evaluate(cache);
}
public TraySection(string name, ThermodynamicSystem system, int numberOfTrays) : base(name, system)
{
Class = "TraySection";
NumberOfTrays = numberOfTrays;
Icon.IconType = IconTypes.ColumnSection;
MaterialPorts.Add(new Port <MaterialStream>("Feeds", PortDirection.In, -1));
MaterialPorts.Add(new Port <MaterialStream>("VIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("LIn", PortDirection.In, 1));
MaterialPorts.Add(new Port <MaterialStream>("VOut", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("LOut", PortDirection.Out, 1));
MaterialPorts.Add(new Port <MaterialStream>("Sidestreams", PortDirection.Out, -1));
for (int i = 0; i < NumberOfTrays; i++)
{
var tray = new EquilibriumTray(i + 1, system);
_trays.Add(tray);
}
AddVariables(_trays.Select(t => t.T).ToArray());
AddVariables(_trays.Select(t => t.TV).ToArray());
AddVariables(_trays.Select(t => t.p).ToArray());
AddVariables(_trays.Select(t => t.DP).ToArray());
AddVariables(_trays.Select(t => t.Q).ToArray());
AddVariables(_trays.Select(t => t.F).ToArray());
AddVariables(_trays.Select(t => t.L).ToArray());
AddVariables(_trays.Select(t => t.V).ToArray());
AddVariables(_trays.Select(t => t.U).ToArray());
AddVariables(_trays.Select(t => t.W).ToArray());
AddVariables(_trays.Select(t => t.RL).ToArray());
AddVariables(_trays.Select(t => t.RV).ToArray());
AddVariables(_trays.Select(t => t.eps).ToArray());
AddVariables(_trays.Select(t => t.HF).ToArray());
AddVariables(_trays.Select(t => t.HL).ToArray());
AddVariables(_trays.Select(t => t.HV).ToArray());
for (int i = 0; i < NumberOfTrays; i++)
{
AddVariables(_trays[i].K);
}
for (int i = 0; i < NumberOfTrays; i++)
{
AddVariables(_trays[i].x);
}
for (int i = 0; i < NumberOfTrays; i++)
{
AddVariables(_trays[i].y);
}
for (int i = 0; i < NumberOfTrays; i++)
{
AddVariables(_trays[i].yeq);
}
for (int i = 0; i < NumberOfTrays; i++)
{
AddVariables(_trays[i].z);
}
int NC = System.Components.Count;
for (var tray = 0; tray < NumberOfTrays; tray++)
{
_trays[tray].U.FixValue(0);
_trays[tray].W.FixValue(0);
_trays[tray].RL.FixValue(0);
_trays[tray].RV.FixValue(0);
_trays[tray].F.FixValue(0);
_trays[tray].HF.FixValue(0);
/* _trays[tray].U.IsConstant = true;
* _trays[tray].W.IsConstant = true;
* _trays[tray].RL.IsConstant = true;
* _trays[tray].RV.IsConstant = true;
* _trays[tray].F.IsConstant = true;
* _trays[tray].HF.IsConstant = true;*/
for (var comp = 0; comp < NC; comp++)
{
_trays[tray].z[comp].FixValue(0);
// _trays[tray].z[comp].IsConstant = true;
}
}
}