/// <summary>
/// Calculates the f-Factor: fLi_Xc, defining the fraction of lipids in
/// composites Xc
/// </summary>
/// <param name="RL">must be measured in % TS</param>
/// <param name="VS">must be measured in % TS</param>
/// <returns>fLi_Xc</returns>
/// <exception cref="exception">value out of bounds</exception>
public static double calcfLi_Xc(double RL, double VS)
{
physValue pRL = new science.physValue("RL", RL, "% TS");
physValue pVS = new science.physValue("VS", VS, "% TS");
return(calcfLi_Xc(pRL, pVS));
}
// -------------------------------------------------------------------------------------
// !!! PRIVATE METHODS !!!
// -------------------------------------------------------------------------------------
/// <summary>
/// Get a value out of the state vector x in the given unit.
/// </summary>
/// <param name="x">ADM state vector</param>
/// <param name="symbol">element of the state vector as defined in the ADM state vector</param>
/// <param name="unit"></param>
/// <returns></returns>
/// <exception cref="exception">Unknown symbol</exception>
private static physValue getFromADMstate(double[] x, string symbol,
string unit)
{
physValue value;
if (isofkind(symbol, "acid"))
{
string Acid;
string Base;
string Sum;
biogas.ADMstate.defineAcidBasePairs(symbol, out Acid, out Base, out Sum);
double conc_base;
double conc_sum;
biogas.ADMstate.getADMstatevariables(x, out conc_base, Base);
biogas.ADMstate.getADMstatevariables(x, out conc_sum, Sum);
value = new science.physValue(symbol, conc_sum - conc_base, unit);
}
else
{
double conc;
biogas.ADMstate.getADMstatevariables(x, out conc, symbol);
value = new science.physValue(symbol, conc, unit);
}
return(value);
}
/// <summary>
/// Calculates the f-Factor: fPr_Xc, defining the fraction of proteins in
/// composites Xc
/// </summary>
/// <param name="RP">must be measured in % TS</param>
/// <param name="VS">must be measured in % TS</param>
/// <returns>fPr_Xc</returns>
/// <exception cref="exception">value out of bounds</exception>
public static double calcfPr_Xc(double RP, double VS)
{
physValue pRP = new science.physValue("RP", RP, "% TS");
physValue pVS = new science.physValue("VS", VS, "% TS");
return(calcfPr_Xc(pRP, pVS));
}
// -------------------------------------------------------------------------------------
// !!! CONSTRUCTOR METHODS !!!
// -------------------------------------------------------------------------------------
/// <summary>
/// constructor with all parameters
/// </summary>
/// <param name="symbol">
/// symbol of the physical value, such as m for mass, T for temperature, ...
/// </param>
/// <param name="value">
/// value of the physical value
/// </param>
/// <param name="unit">
/// unit of the physical value, without rectangular brackets
/// </param>
/// <param name="label">
/// label of the physical value, such as temperature, mass, ...
/// </param>
/// <param name="reference">
/// reference for a physical value gotten out of literature, or from plants
/// </param>
/// <param name="lb">
/// lower boundary of the physical value
/// </param>
/// <param name="ub">
/// upper boundary of the physical value
/// </param>
public physValueBounded(string symbol, double value, string unit, string label,
string reference, physValue lb, physValue ub) :
base(symbol, value, unit, label, reference)
{
_lb = lb;
_ub = ub;
}
/// <summary>
/// constructor used to copy physValues, the returned physValue
/// is identical to the template
/// </summary>
/// <param name="template"></param>
public physValue(physValue template)
{
_symbol = template.Symbol;
_value = template.Value;
_unit = template.Unit;
_label = template.Label;
_reference = template.Reference;
}
/// <summary>
/// unary minus: Returns -v
/// </summary>
/// <param name="v">v</param>
/// <returns>-v</returns>
public static physValue operator-(physValue v)
{
physValue v_new = new physValue(v);
v_new._value = -v.Value;
return(v_new);
}
/// <summary>
/// Calculates the f-Factor: fXI_Xc, defining the fraction of particulate inerts in
/// composites Xc
/// </summary>
/// <param name="ADL">must be measured in % TS</param>
/// <param name="NDF">must be measured in % TS</param>
/// <param name="VS">must be measured in % TS</param>
/// <param name="D_VS">must be measured in 100 %</param>
/// <returns>fXI_Xc</returns>
public static double calcfXI_Xc(double ADL, double NDF, double VS, double D_VS)
{
physValue pADL = new science.physValue("ADL", ADL, "% TS");
physValue pNDF = new science.physValue("NDF", NDF, "% TS");
physValue pVS = new science.physValue("VS", VS, "% TS");
physValue pD_VS = new science.physValue("D_VS", D_VS, "100 %");
return(calcfXI_Xc(pADL, pNDF, pVS, pD_VS));
}
/// <summary>
/// Rounds the double Value of the given physValue to the given digits
/// </summary>
/// <param name="value">physValue</param>
/// <param name="digits">number of digits</param>
/// <returns>physValue the same as the given one, only value round to number of digits
/// </returns>
public static physValue round(physValue value, int digits)
{
physValue new_value = new physValue(value);
// new_value.Value
new_value._value = Math.Round(new_value.Value, digits);
return(new_value);
}
/// <summary>
/// Returns the arithemtic mean of the physical values in the given array
/// </summary>
/// <param name="inputs">physValue vector</param>
/// <returns>arithmetic mean of the components of inputs</returns>
/// <exception cref="exception">inputs is empty</exception>
/// <exception cref="exception">unit mismatch</exception>
public static physValue mean(physValue[] inputs) // const
{
physValue mean = sum(inputs);
if (inputs.Length > 0)
{
mean /= inputs.Length;
}
return(mean);
}
/// <summary>
/// Returns the arithmetic mean of the physical values given.
/// Call: physValue.meanVar(v1, v2, v3), v1-v3: physValues
/// </summary>
/// <param name="inputs">physValue objects</param>
/// <returns>arithmetic mean of given values</returns>
/// <exception cref="exception">inputs is empty</exception>
/// <exception cref="exception">unit mismatch</exception>
public static physValue meanVar(params physValue[] inputs) // const
{
physValue[] input_array = new physValue[inputs.Length];
for (int iValue = 0; iValue < inputs.Length; iValue++)
{
input_array[iValue] = inputs[iValue];
}
return(mean(input_array));
}
/// <summary>
/// Rounds the double Value of each element inside the given physValue
/// array to the given digits
/// </summary>
/// <param name="values">array of physValue</param>
/// <param name="digits">number of digits</param>
/// <returns>vector of rounded physValues</returns>
public static physValue[] round(physValue[] values, int digits)
{
physValue[] new_value = new physValue[values.Length];
for (int ivalue = 0; ivalue < new_value.Length; ivalue++)
{
new_value[ivalue] = round(values[ivalue], digits);
}
return(new_value);
}
// -------------------------------------------------------------------------------------
// !!! PUBLIC METHODS: MATHEMATICAL STUFF !!!
// -------------------------------------------------------------------------------------
/// <summary>
/// Multiply a physValue array with a double scalar.
/// Each value inside the array is multiplied with the scalar
/// </summary>
/// <param name="v">physValue vector</param>
/// <param name="scalar">double scalar</param>
/// <returns>v multiplied with scalar, componentwise</returns>
public static physValue[] times(physValue[] v, double scalar)
{
physValue[] v_result = new physValue[v.Length];
for (int iel = 0; iel < v_result.Length; iel++)
{
v_result[iel] = v[iel] * scalar;
}
return(v_result);
}
/// <summary>
/// Returns the object out of both objects v1 and v2, which has the smaller
/// numerical value. If Unit of both are not the same, then an error is
/// thrown.
/// </summary>
/// <param name="v1">first physValue</param>
/// <param name="v2">2nd physValue</param>
/// <returns>min(v1, v2)</returns>
/// <exception cref="exception">unit mismatch</exception>
public static physValue min(physValue v1, physValue v2) // const
{
if (v1.Unit != v2.Unit)
{
throw new exception(String.Format(
"Cannot compare! The units of both physical values are not equal: {0} != {1}!",
v1.Unit, v2.Unit));
}
return(new physValue(String.Format("Min({0}, {1})", v1.Symbol, v2.Symbol),
Math.Min(v1.Value, v2.Value), v1.Unit));
}
/// <summary>
/// Calculate g C / kg substrate fresh matter
/// </summary>
/// <param name="RF">must be measured in % TS</param>
/// <param name="RP">must be measured in % TS</param>
/// <param name="RL">must be measured in % TS</param>
/// <param name="NfE">must be measured in % TS</param>
/// <param name="ADL">must be measured in % TS</param>
/// <param name="TS">must be measured in % FM</param>
/// <returns>g C / kg fresh matter</returns>
private static physValue calcC(double RF, double RP, double RL,
double NfE, double ADL, double TS)
{
physValue pRF = new science.physValue("RF", RF, "% TS");
physValue pRP = new science.physValue("RP", RP, "% TS");
physValue pRL = new science.physValue("RL", RL, "% TS");
physValue pNfE = new science.physValue("NfE", NfE, "% TS");
physValue pADL = new science.physValue("ADL", ADL, "% TS");
physValue pTS = new science.physValue("TS", TS, "% FM");
return(calcC(pRF, pRP, pRL, pNfE, pADL, pTS));
}
/// <summary>
/// Math.Pow for physValues: Math.Pow(value, numerator/denominator)
/// </summary>
/// <param name="value">physValue</param>
/// <param name="numerator">Zähler</param>
/// <param name="denominator">Nenner</param>
/// <returns>value^(numerator/denominator)</returns>
public static physValue Pow(physValue value, int numerator, int denominator)
{
physValue new_value = new physValue(value);
// new_value.Value
new_value._value = Math.Pow(new_value.Value, ((double)numerator / (double)denominator));
new_value._symbol = String.Format("{0}^({1}/{2})", new_value.Symbol, numerator, denominator);
new_value._unit = String.Format("({0})^({1}/{2})", new_value.Unit, numerator, denominator);
new_value._label = String.Format("({0})^({1}/{2})", new_value.Label, numerator, denominator);
return(new_value);
}
/// <summary>
/// Math.Pow for physValues: Math.Pow(value, power)
/// </summary>
/// <param name="value">physValue</param>
/// <param name="power">power</param>
/// <returns>value^power</returns>
public static physValue Pow(physValue value, int power)
{
physValue new_value = new physValue(value);
// new_value.Value
new_value._value = Math.Pow(new_value.Value, power);
new_value._symbol = String.Format("{0}^{1}", new_value.Symbol, power);
new_value._unit = String.Format("({0})^{1}", new_value.Unit, power);
new_value._label = String.Format("({0})^{1}", new_value.Label, power);
return(new_value);
}
/// <summary>
/// Creates a physValue vector containing 0s
/// </summary>
/// <param name="dim">dimension of zero vector</param>
/// <returns>zero vector with no unit "-"</returns>
/// <exception cref="exception">dim < 1</exception>
public static physValue[] zeros(int dim)
{
if (dim <= 0)
{
throw new exception(String.Format("dim must be >= 1, but is {0}!", dim));
}
physValue[] v = new physValue[dim];
// TODO - what is the definition of no unit? 1 or -?
for (int iel = 0; iel < v.Length; iel++)
{
v[iel] = new physValue(String.Format("v{0}", iel), 0, "-");
}
return(v);
}
/// <summary>
/// Math.Sqrt for physValues: Math.Sqrt(value)
/// </summary>
/// <param name="value">physValue</param>
/// <returns>sqrt(value)</returns>
public static physValue Sqrt(physValue value)
{
physValue new_value = new physValue(value);
// new_value.Value
new_value._value = Math.Sqrt(new_value.Value);
//if (new_value.Symbol.Length > 0)
new_value._symbol = String.Format("{0}^(1/2)", new_value.Symbol);
//if (new_value.Unit.Length > 0)
new_value._unit = String.Format("({0})^(1/2)", new_value.Unit);
//if (new_value.Label.Length > 0)
new_value._label = String.Format("({0})^(1/2)", new_value.Label);
return(new_value);
}
/// <summary>
/// concatenate both vectors v1 and v2 vertically
/// </summary>
/// <param name="v1">first vector</param>
/// <param name="v2">2nd vector</param>
/// <returns>[v1; v2]</returns>
public static physValue[] concat(physValue[] v1, physValue[] v2)
{
physValue[] v = new physValue[v1.Length + v2.Length];
for (int iel = 0; iel < v.Length; iel++)
{
if (iel < v1.Length)
{
v[iel] = v1[iel];
}
else
{
v[iel] = v2[iel - v1.Length];
}
}
return(v);
}
/// <summary>
/// Returns the min of the physical values in the given array
/// if array is empty, then negative infinity is returned, with no unit
/// </summary>
/// <param name="inputs">physValue vector</param>
/// <returns>min(inputs)</returns>
/// <exception cref="exception">unit mismatch</exception>
public static physValue min(physValue[] inputs) // const
{
physValue minVal;
if (inputs.Length > 0)
{
minVal = inputs[0];
}
else
{
minVal = new physValue(Double.NegativeInfinity, "");
}
for (int iel = 0; iel < inputs.Length - 1; iel++)
{
minVal = min(minVal, inputs[iel + 1]);
}
return(minVal);
}
/// <summary>
/// Calculates total alkalinity out of given ADM state vector
///
/// the buffer consists out of:
/// - acetate of VFAs, HCO3, aniona and cations
/// </summary>
/// <param name="x">ADM state vector</param>
/// <param name="unit"></param>
/// <returns></returns>
public static physValueBounded calcTACOfADMstate(double[] x, string unit)
{
string unit_temp = "mol/l";
// kmol/m³ = mol/l
physValue San = new science.physValue("San", x[biogas.ADMstate.pos_San - 1], "mol/l");
// mol/l
physValue Shco3 = biogas.ADMstate.calcFromADMstate(x, "Shco3", unit_temp);
// mol/l
physValue Sac_ = biogas.ADMstate.calcFromADMstate(x, "Sac_", unit_temp);
// mol/l
physValue Spro_ = biogas.ADMstate.calcFromADMstate(x, "Spro_", unit_temp);
// mol/l
physValue Sbu_ = biogas.ADMstate.calcFromADMstate(x, "Sbu_", unit_temp);
// mol/l
physValue Sva_ = biogas.ADMstate.calcFromADMstate(x, "Sva_", unit_temp);
// kmol/m³ = mol/l
physValue Scat = new science.physValue("Scat", x[biogas.ADMstate.pos_Scat - 1], "mol/l");
//
// mol/l
physValueBounded TAC = new physValueBounded(San + Shco3 + Sac_ + Spro_ + Sva_ + Sbu_ - Scat);
//
TAC = TAC.convertUnit(unit);
TAC.Symbol = "TAC";
//TAC.setLB(-double.Epsilon);
TAC.printIsOutOfBounds();
return(TAC);
}
public static physValue[] mtimes(physValue[] v1, double[] v2)
{
if (v1.Length != v2.Length)
{
throw new exception(String.Format(
"The length of both vectors is not the same: {0} != {1}!",
v1.Length, v2.Length));
}
if (v1.Length <= 0)
{
throw new exception(String.Format(
"The length of both vectors is <= 0: {0}!", v1.Length));
}
physValue[] v_result = new physValue[v1.Length];
for (int iel = 0; iel < v_result.Length; iel++)
{
v_result[iel] = v1[iel] * v2[iel];
}
return(v_result);
}
/// <summary>
/// Sets upper bound to max and LB to -infinity.
/// The unit is the one the object currently has.
/// </summary>
/// <param name="max">max value</param>
public void setUB(double max)
{
_lb = new physValue(double.NegativeInfinity, Unit);
_ub = new physValue(max, Unit);
}
/// <summary>
/// Sets lower bound to min and UB to infinity.
/// The unit is the one the object currently has.
/// </summary>
/// <param name="min">min value</param>
public void setLB(double min)
{
_lb = new physValue(min, Unit);
_ub = new physValue(double.PositiveInfinity, Unit);
}
/// <summary>
/// Sets boundaries of physValueBounded to min and max.
/// The unit is the one the object currently has.
/// </summary>
/// <param name="min">min value</param>
/// <param name="max">max value</param>
public void setBounds(double min, double max)
{
_lb = new physValue(min, Unit);
_ub = new physValue(max, Unit);
}
/// <summary>
/// Rounds the double Value to 2 digits
/// </summary>
/// <param name="value">some value</param>
/// <returns>same value round to 2 digits</returns>
public static physValue round(physValue value)
{
return(round(value, 2));
}
/// <summary>
/// constructor used to copy physValus, the returned physValueBounded
/// is identical to the template. Just adds boundaries at pos. and negative
/// infinity.
/// </summary>
/// <param name="template">template</param>
public physValueBounded(physValue template) : base(template)
{
_lb = new physValue(double.NegativeInfinity, Unit);
_ub = new physValue(double.PositiveInfinity, Unit);
}
/// <summary>
/// constructor used to copy physValus, the returned physValueBounded
/// is identical to the template. Just adds boundaries at lb and ub
/// </summary>
/// <param name="template">template</param>
/// <param name="lb">lower boundary of the new physValueBounded</param>
/// <param name="ub">upper boundary of the new physValueBounded</param>
public physValueBounded(physValue template, double lb, double ub)
: base(template)
{
_lb = new physValue(lb, Unit);
_ub = new physValue(ub, Unit);
}
/// <summary>
/// Reads the params out of the XmlTextReader and writes them in the object.
/// not const. Only reads one physValueBounded then returns. the 2nd parameter symbol
/// is not read out of the xml file but must be read before out of the xml file.
///
/// TODO: why not call it physValueBounded ???
/// <physValue symbol= "...">
/// </summary>
/// <param name="reader">an open xml textreader</param>
/// <param name="symbol">symbol of the to be read physValueBounded</param>
/// <returns>true, if physValue not empty</returns>
override public bool getParamsFromXMLReader(ref XmlTextReader reader, string symbol)
{
string param = "";
// if physValue is empty: "<physValue></physValue>", then false, else true
bool notEmpty = false;
_symbol = symbol;
while (reader.Read())
{
switch (reader.NodeType)
{
case System.Xml.XmlNodeType.Element: // this knot is an element
param = reader.Name;
break;
case System.Xml.XmlNodeType.Text: // text, thus value, of each element
switch (param)
{
case "value":
_value = System.Xml.XmlConvert.ToDouble(reader.Value);//Convert.ToDouble(reader.Value);
notEmpty = true;
break;
case "unit":
_unit = reader.Value;
notEmpty = true;
break;
case "label":
_label = reader.Value;
notEmpty = true;
break;
case "reference":
_reference = reader.Value;
notEmpty = true;
break;
case "LB":
_lb = new physValue(System.Xml.XmlConvert.ToDouble(reader.Value), Unit);
notEmpty = true;
break;
case "UB":
_ub = new physValue(System.Xml.XmlConvert.ToDouble(reader.Value), Unit);
notEmpty = true;
break;
}
break;
case System.Xml.XmlNodeType.EndElement:
if (reader.Name == "physValue")
{
return(notEmpty);
}
break;
}
}
return(notEmpty);
}
/// <summary>
/// constructor with no upper boundary
/// </summary>
/// <param name="symbol">
/// symbol of the physical value, such as m for mass, T for temperature, ...
/// </param>
/// <param name="value">
/// value of the physical value
/// </param>
/// <param name="unit">
/// unit of the physical value, without rectangular brackets
/// </param>
/// <param name="label">
/// label of the physical value, such as temperature, mass, ...
/// </param>
/// <param name="reference">
/// reference for a physical value gotten out of literature, or from plants
/// </param>
/// <param name="lb">
/// lower boundary of the physical value
/// </param>
public physValueBounded(string symbol, double value, string unit, string label,
string reference, physValue lb) :
this(symbol, value, unit, label, reference, lb,
new physValue(double.PositiveInfinity, unit))
{
}
