bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var Name1 = coolpropPlugin.GetStringParam(args[0], ref context);
var Prop1 = coolpropPlugin.GetNumberParam(args[1], ref context);
Unit.match(Name1, Prop1, context);
var Name2 = coolpropPlugin.GetStringParam(args[2], ref context);
var Prop2 = coolpropPlugin.GetNumberParam(args[3], ref context);
Unit.match(Name2, Prop2, context);
var FluidName = coolpropPlugin.GetStringParam(args[4], ref context);
var phase = new System.Text.StringBuilder(10000);
var Result = CoolPropDLLfunc(Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName, phase, phase.Capacity);
coolpropPlugin.LogInfo("[INFO ]",
"Name1 = {0}, Prop1 = {1}, Name2 = {2}, Prop2 = {3}, FluidName = {4}, phase = {5}, Result = {6}",
Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName, phase.ToString(), Result);
if (Result != 1)
{
coolpropPlugin.CoolPropError();
}
result = coolpropPlugin.MakeStringResult(phase.ToString());
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var Name1 = coolpropPlugin.GetStringParam(value.Items[0], context);
var Prop1 = coolpropPlugin.GetNumberParam(value.Items[1], context);
Unit.match(Name1, Prop1, context);
var Name2 = coolpropPlugin.GetStringParam(value.Items[2], context);
var Prop2 = coolpropPlugin.GetNumberParam(value.Items[3], context);
Unit.match(Name2, Prop2, context);
var FluidName = coolpropPlugin.GetStringParam(value.Items[4], context);
var phase = new System.Text.StringBuilder(10000);
var Result = CoolPropDLLfunc(Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName, phase, phase.Capacity);
coolpropPlugin.LogInfo("[INFO]",
"Name1 = {0}, Prop1 = {1}, Name2 = {2}, Prop2 = {3}, FluidName = {4}, phase = {5}, Result = {6}",
Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName, phase.ToString(), Result);
if (Result != 1)
{
coolpropPlugin.CoolPropError();
}
result = coolpropPlugin.MakeStringResult(phase.ToString());
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
result = null;
if (value.Type != TermType.Function)
{
return(false);
}
foreach (var func in functions)
{
if (!func.Info.Equals(value.ToTerm()))
{
continue;
}
try
{
return(func.TryEvaluateExpression(value, context, out result));
}
catch (System.Exception ex)
{
LogInfo("[ERROR]", "{0}({1}) {2}", value.Text, value.ArgsCount, ex.Message);
throw;
}
}
return(false);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var param = coolpropPlugin.GetStringParam(args[0], ref context);
var Result = CoolPropDLLfunc(param);
coolpropPlugin.LogInfo("[INFO ]", "param = {0}, Result = {1}", param, Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.unitless);
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var param = coolpropPlugin.GetStringParam(value.Items[0], context);
var Result = CoolPropDLLfunc(param);
coolpropPlugin.LogInfo("[INFO]", "param = {0}, Result = {1}", param, Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.unitless);
return(true);
}
public static string GetStringParam(Term[] arg, ref SMath.Math.Store context)
{
var dbl = GetNumberParam(arg, ref context).obj as SMath.Math.Numeric.TDouble;
if (!dbl.isText)
{
throw new SMath.Manager.EvaluationException(Errors.ArgumentMustBeString);
}
return(dbl.ToString().Trim('"'));
}
public static string GetStringParam(Entry arg, SMath.Math.Store context)
{
var dbl = GetNumberParam(arg, context).obj as SMath.Math.Numeric.TDouble;
if (!dbl.isText)
{
throw new SMath.Manager.MathException(Errors.ArgumentMustBeString);
}
return(dbl.ToString().Trim(Symbols.StringChar[0]));
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
string FluidName = coolpropPlugin.GetStringParam(args[0], ref context),
Output = coolpropPlugin.GetStringParam(args[1], ref context);
var Result = CoolPropDLLfunc(FluidName, Output);
coolpropPlugin.LogInfo("[INFO ]", "FluidName = {0}, Output = {1}, Result = {2}", FluidName, Output, Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.Find(Output));
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var Ref = coolpropPlugin.GetStringParam(args[0], ref context);
var reference_state = coolpropPlugin.GetStringParam(args[1], ref context);
var Result = CoolPropDLLfunc(Ref, reference_state);
coolpropPlugin.LogInfo("[INFO ]", "Ref = {0}, reference_state = {1} Result = {2}", Ref, reference_state, Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.unitless);
return(true);
}
static void matchInternal(MItem unit, SMath.Math.Numeric.TNumber val, ref SMath.Math.Store context)
{
// First, reduce our units to basic representation to allow MathEqual()
var t = SMath.Math.Decision.Preprocessing(unit.ToEntry(), context);
var u = Expression.SimplifyEx(Converter.ToMItem(t), context);
if (!val.obj.Units.MathEqual(u) && !val.obj.Units.MathEqual(unitless))
{
throw new SMath.Manager.MathException(SMath.Manager.Errors.UnitsDontMatch);
}
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var Ref = coolpropPlugin.GetStringParam(value.Items[0], context);
var reference_state = coolpropPlugin.GetStringParam(value.Items[1], context);
var Result = CoolPropDLLfunc(Ref, reference_state);
coolpropPlugin.LogInfo("[INFO]", "Ref = {0}, reference_state = {1} Result = {2}", Ref, reference_state, Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.unitless);
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
// Possible inputs:
// "Omega"="HumRat"="W" = Humidity ratio
// "Tdp"="T_dp"="DewPoint"="D" = Dewpoint temperature
// "Twb"="T_wb"="WetBulb"="B" = Wet bulb temperature
// "Enthalpy"="H" = Enthalpy
// "Entropy"="S" = Entropy
// "RH"="RelHum"="R" = Relative humidity
// "Tdb"="T_db"="T" = Dry-bulb temperature
// "P" = Pressure
// "V"="Vda" = Volume of dry air
// "mu"="Visc"="M" = Viscosity
// "k"="Conductivity"="K" = Conductivity
// Output:
// "Vda"="V"[m^3/kg_da]
// "Vha"[m^3/kg_ha]
// "Y"[mol_w/mol]
// "Hda"="H"
// "Hha"[kJ/kg_ha]
// "S"="Entropy"[kJ/kg_da]
// "C"="cp"[kJ/kg_da]
// "Cha"="cp_ha"[kJ/kg_da]
// "Tdp"="D"[K]
// "Twb"="T_wb"="WetBulb"="B"[K]
// "Omega"="HumRat"="W"
// "RH"="RelHum"="R"
// "mu"="Visc"="M"
// "k"="Conductivity"="K"
var Output = coolpropPlugin.GetStringParam(args[0], ref context);
var Name1 = coolpropPlugin.GetStringParam(args[1], ref context);
var Prop1 = coolpropPlugin.GetNumberParam(args[2], ref context);
Unit.matchHA(Name1, Prop1, context);
var Name2 = coolpropPlugin.GetStringParam(args[3], ref context);
var Prop2 = coolpropPlugin.GetNumberParam(args[4], ref context);
Unit.matchHA(Name2, Prop2, context);
var Name3 = coolpropPlugin.GetStringParam(args[5], ref context);
var Prop3 = coolpropPlugin.GetNumberParam(args[6], ref context);
Unit.matchHA(Name3, Prop3, context);
var Result = CoolPropDLLfunc(Output, Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), Name3, Prop3.obj.ToDouble());
coolpropPlugin.LogInfo("[INFO ]",
"Output = {0}, Name1 = {1}, Prop1 = {2}, Name2 = {3}, Prop2 = {4}, Name3 = {5}, Prop3 = {6}, Result = {7}",
Output, Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), Name3, Prop3.obj.ToDouble(), Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.FindHA(Output));
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var param = coolpropPlugin.GetStringParam(args[0], ref context);
string resultStr;
if (!CoolPropDLLfunc(param, out resultStr))
{
coolpropPlugin.CoolPropError();
}
result = coolpropPlugin.MakeStringResult(resultStr);
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var param = coolpropPlugin.GetStringParam(value.Items[0], context);
string resultStr;
if (!CoolPropDLLfunc(param, out resultStr))
{
coolpropPlugin.CoolPropError();
}
result = coolpropPlugin.MakeStringResult(resultStr);
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var param = coolpropPlugin.GetStringParam(args[0], ref context);
var output = new System.Text.StringBuilder(10000);
var Result = CoolPropDLLfunc(param, output, output.Capacity);
coolpropPlugin.LogInfo("[INFO ]", "param = {0} output = {1} Result = {2}", param, output.ToString(), Result);
if (Result != 1)
{
throw new EvaluationException(Errors.ArgumentDoesNotMatchToExpectedKind);
}
result = coolpropPlugin.MakeStringResult(output.ToString());
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var Ref = coolpropPlugin.GetStringParam(value.Items[0], context);
var T = coolpropPlugin.GetNumberParam(value.Items[1], context);
var rho = coolpropPlugin.GetNumberParam(value.Items[2], context);
var h0 = coolpropPlugin.GetNumberParam(value.Items[3], context);
var s0 = coolpropPlugin.GetNumberParam(value.Items[4], context);
var Result = CoolPropDLLfunc(Ref, T.obj.ToDouble(), rho.obj.ToDouble(), h0.obj.ToDouble(), s0.obj.ToDouble());
coolpropPlugin.LogInfo("[INFO]",
"Ref = {0} T = {1} rho = {2} h0 = {3} s0 = {4} Result = {5}",
Ref, T.obj.ToDouble(), rho.obj.ToDouble(), h0.obj.ToDouble(), s0.obj.ToDouble(), Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.unitless);
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var Ref = coolpropPlugin.GetStringParam(args[0], ref context);
var T = coolpropPlugin.GetNumberParam(args[1], ref context);
var rho = coolpropPlugin.GetNumberParam(args[2], ref context);
var h0 = coolpropPlugin.GetNumberParam(args[3], ref context);
var s0 = coolpropPlugin.GetNumberParam(args[4], ref context);
var Result = CoolPropDLLfunc(Ref, T.obj.ToDouble(), rho.obj.ToDouble(), h0.obj.ToDouble(), s0.obj.ToDouble());
coolpropPlugin.LogInfo("[INFO ]",
"Ref = {0} T = {1} rho = {2} h0 = {3} s0 = {4} Result = {5}",
Ref, T.obj.ToDouble(), rho.obj.ToDouble(), h0.obj.ToDouble(), s0.obj.ToDouble(), Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.unitless);
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var fluid = coolpropPlugin.GetStringParam(args[0], ref context);
var param = coolpropPlugin.GetStringParam(args[1], ref context);
var output = new System.Text.StringBuilder(10000);
var Result = CoolPropDLLfunc(fluid, param, output, output.Capacity);
coolpropPlugin.LogInfo("[INFO ]", "fluid = {0} param = {1} output = {2} Result = {3}", fluid, param, output.ToString(), Result);
if (Result != 1)
{
coolpropPlugin.CoolPropError();
}
result = coolpropPlugin.MakeStringResult(output.ToString());
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var fluid = coolpropPlugin.GetStringParam(value.Items[0], context);
var param = coolpropPlugin.GetStringParam(value.Items[1], context);
var output = new System.Text.StringBuilder(10000);
var Result = CoolPropDLLfunc(fluid, param, output, output.Capacity);
coolpropPlugin.LogInfo("[INFO]", "fluid = {0} param = {1} output = {2} Result = {3}", fluid, param, output.ToString(), Result);
if (Result != 1)
{
coolpropPlugin.CoolPropError();
}
result = coolpropPlugin.MakeStringResult(output.ToString());
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
string FluidName = coolpropPlugin.GetStringParam(value.Items[0], context),
Output = coolpropPlugin.GetStringParam(value.Items[1], context);
var Result = CoolPropDLLfunc(FluidName, Output);
coolpropPlugin.LogInfo("[INFO]", "FluidName = {0}, Output = {1}, Result = {2}", FluidName, Output, Result);
var ResUnit = Unit.Find(Output);
// Props1SI may take parameters in either order; so, Output may actually be in FluidName
if (ResUnit == Unit.unitless)
{
ResUnit = Unit.Find(FluidName);
}
result = coolpropPlugin.MakeDoubleResult(Result, ResUnit);
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
string FluidName = coolpropPlugin.GetStringParam(args[0], ref context),
Output = coolpropPlugin.GetStringParam(args[1], ref context);
var Result = CoolPropDLLfunc(FluidName, Output);
coolpropPlugin.LogInfo("[INFO ]", "FluidName = {0}, Output = {1}, Result = {2}", FluidName, Output, Result);
var ResUnit = Unit.Find(Output);
// Props1SI may take parameters in either order; so, Output may actually be in FluidName
if (ResUnit == Unit.unitless)
{
ResUnit = Unit.Find(FluidName);
}
result = coolpropPlugin.MakeDoubleResult(Result, ResUnit);
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var fluid_name = coolpropPlugin.GetStringParam(args[0], ref context);
var output = coolpropPlugin.GetStringParam(args[1], ref context);
var Q = (int)coolpropPlugin.GetNumberParam(args[2], ref context).obj.ToDouble();
var input = coolpropPlugin.GetStringParam(args[3], ref context);
var value = coolpropPlugin.GetNumberParam(args[4], ref context);
Unit.match(input, value, context);
var Result = CoolPropDLLfunc(fluid_name, output, Q, input, value.obj.ToDouble());
coolpropPlugin.LogInfo("[INFO ]",
"fluid_name = {0}, output = {1}, Q = {2}, input = {3}, value = {4}, Result = {5}",
fluid_name, output, Q, input, value.obj.ToDouble(), Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.Find(output));
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var fluid_name = coolpropPlugin.GetStringParam(value.Items[0], context);
var output = coolpropPlugin.GetStringParam(value.Items[1], context);
var Q = (int)coolpropPlugin.GetNumberParam(value.Items[2], context).obj.ToDouble();
var inputVar = coolpropPlugin.GetStringParam(value.Items[3], context);
var inputVal = coolpropPlugin.GetNumberParam(value.Items[4], context);
Unit.match(inputVar, inputVal, context);
var Result = CoolPropDLLfunc(fluid_name, output, Q, inputVar, inputVal.obj.ToDouble());
coolpropPlugin.LogInfo("[INFO]",
"fluid_name = {0}, output = {1}, Q = {2}, input = {3}, value = {4}, Result = {5}",
fluid_name, output, Q, inputVar, inputVal.obj.ToDouble(), Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.Find(output));
return(true);
}
bool IFunction.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
var Output = coolpropPlugin.GetStringParam(args[0], ref context);
var Name1 = coolpropPlugin.GetStringParam(args[1], ref context);
var Prop1 = coolpropPlugin.GetNumberParam(args[2], ref context);
Unit.match(Name1, Prop1, context);
var Name2 = coolpropPlugin.GetStringParam(args[3], ref context);
var Prop2 = coolpropPlugin.GetNumberParam(args[4], ref context);
Unit.match(Name2, Prop2, context);
var FluidName = coolpropPlugin.GetStringParam(args[5], ref context);
var Result = CoolPropDLLfunc(Output, Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName);
coolpropPlugin.LogInfo("[INFO ]",
"Output = {0}, Name1 = {1}, Prop1 = {2}, Name2 = {3}, Prop2 = {4}, FluidName = {5}, Result = {6}",
Output, Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName, Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.Find(Output));
return(true);
}
public bool TryEvaluateExpression(Entry value, SMath.Math.Store context, out Entry result)
{
var Output = coolpropPlugin.GetStringParam(value.Items[0], context);
var Name1 = coolpropPlugin.GetStringParam(value.Items[1], context);
var Prop1 = coolpropPlugin.GetNumberParam(value.Items[2], context);
Unit.match(Name1, Prop1, context);
var Name2 = coolpropPlugin.GetStringParam(value.Items[3], context);
var Prop2 = coolpropPlugin.GetNumberParam(value.Items[4], context);
Unit.match(Name2, Prop2, context);
var FluidName = coolpropPlugin.GetStringParam(value.Items[5], context);
var Result = CoolPropDLLfunc(Output, Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName);
coolpropPlugin.LogInfo("[INFO]",
"Output = {0}, Name1 = {1}, Prop1 = {2}, Name2 = {3}, Prop2 = {4}, FluidName = {5}, Result = {6}",
Output, Name1, Prop1.obj.ToDouble(), Name2, Prop2.obj.ToDouble(), FluidName, Result);
result = coolpropPlugin.MakeDoubleResult(Result, Unit.Find(Output));
return(true);
}
bool SMath.Math.IPluginLowLevelEvaluation.ExpressionEvaluation(Term root, Term[][] args, ref SMath.Math.Store context, ref Term[] result)
{
if (root.Type != TermType.Function)
{
return(false);
}
foreach (var func in functions)
{
if (!func.Info.Equals(root))
{
continue;
}
try {
return(func.ExpressionEvaluation(root, args, ref context, ref result));
}
catch (System.Exception ex) {
LogInfo("[ERROR]", "{0}({1}) {2}", root.Text, root.ChildCount, ex.Message);
throw;
}
}
return(false);
}
public static void matchHA(string param, SMath.Math.Numeric.TNumber val, SMath.Math.Store context)
{
matchInternal(FindHA(param), val, ref context);
}
public static SMath.Math.Numeric.TNumber GetNumberParam(Term[] arg, ref SMath.Math.Store context)
{
// var arg1 = SMath.Math.Decision.Preprocessing(arg, ref context);
// return SMath.Math.Numeric.Expression.Calculate(arg1, context).obj as SMath.Math.Numeric.TDouble;
return(SMath.Math.Decision.NumericCalculation(arg, ref context));
}
