private bool ParseElectricalResistivity(string v, Qualities q)
{
ValueQualifier vq = DoubleValue.FindQualifier(ref v);
string[] UNITS = { "nΩ·m", "Ω·m", "µΩ·m" };
double f = 1;
for (int i = 0; i < UNITS.Length; ++i)
{
string s = UNITS[i];
int ndx = v.IndexOf(s);
if (ndx > 0)
{
v = v.Substring(0, ndx - 1).Trim();
switch (i)
{
case 0: f = 0.001; break;
case 1: f = 1000000; break;
}
}
double d;
if (UnitValue.TryParse(v, out d))
{
q.ElectricalResistivity = new UnitValue(d * f, UNITS[2], vq);
return(true);
}
}
return(false);
}
public static new UnitValueRange Parse(string v, string u)
{
ValueQualifier vq = DoubleValue.FindQualifier(ref v);
string[] parts = v.Split('-');
double d1 = Double.NaN, d2 = 0;
switch (parts.Length)
{
case 0:
d1 = d2 = double.Parse(v);
break;
case 1:
d1 = d2 = double.Parse(parts[0].Trim());
break;
case 2:
d1 = double.Parse(parts[0].Trim());
d2 = double.Parse(parts[1].Trim());
break;
}
if (!double.IsNaN(d1))
{
return(new UnitValueRange(d1, d2, u, vq));
}
throw new Exception(String.Format("UnitValueRange.Parse failed: {0}", v));
}
private bool ParseYoungsModulus(string s, Qualities q)
{
const string UNIT = "GPa", EST = "est.";
ValueQualifier vq = ValueQualifier.None;
int n = s.IndexOf(EST);
if (n > 0)
{
vq = ValueQualifier.Estimated;
s = s.Substring(n + EST.Length).Trim();
}
n = s.IndexOf(UNIT);
if (n > 0)
{
s = s.Substring(0, n - 1).Trim();
double d, d1;
if (DoubleValue.TryParseRange(s, out d, out d1))
{
d = (d + d1) / 2;
}
else
{
UnitValue.TryParse(s, out d);
}
if (!Double.IsNaN(d))
{
q.YoungsModulus = new UnitValue(d, UNIT, vq);
return(true);
}
}
return(false);
}
private bool ParseCovalentRadius(string s, Qualities q)
{
const string UNIT = Units.PicoMeter;
ValueQualifier vq = DoubleValue.FindQualifier(ref s);
int n = s.IndexOf(UNIT);
if (n > 0)
{
s = s.Substring(0, n - 1).Trim();
int n2 = s.IndexOf("–");
if (n2 > 0)
{
string[] parts = s.Split('–');
double d1, d2;
if (UnitValue.TryParse(parts[0], out d1) && UnitValue.TryParse(parts[1], out d2))
{
q.CovalentRadius = new UnitValue((d1 + d2) / 2, UNIT, vq);
return(true);
}
}
if (s.StartsWith("sp3"))
{
s = s.Substring(5);
}
double d;
if (UnitValue.TryParse(s, out d))
{
q.CovalentRadius = new UnitValue(d, UNIT, vq);
return(true);
}
}
return(false);
}
private bool ParseElectronConfiguration(string s, Qualities q)
{
s = StringEx.RemoveReferences(s);
const string LB = "or\n";
ValueQualifier vq = DoubleValue.FindQualifier(ref s);
if (s.IndexOf(LB) > 0)
{
s = s.Replace(LB, ";");
}
q.ElectronConfiguration = new QualifiedString(s.Trim(), vq);
return(true);
}
public static UnitValue Parse(string v, string unit)
{
if (String.IsNullOrEmpty(v))
{
throw new ArgumentException("v cannot be null or empty.");
}
ValueQualifier vq = DoubleValue.FindQualifier(ref v);
double d;
//"2.267 moststableallotrope"
if (double.TryParse(v, out d) || DoubleValue.TryParseScientific(v, out d))
{
return(new UnitValue(d, unit, vq));
}
throw new ArgumentException("Failed to parse UnitValue: " + v);
}
public static ValueQualifier FindQualifier(ref string s)
{
ValueQualifier r = ValueQualifier.None;
if (String.IsNullOrEmpty(s))
{
return(r);
}
string sret = s.ToLower();
if (s.StartsWith(CA))
{
s = s.Substring(CA.Length).TrimStart();
return(ValueQualifier.Circa);
}
Func <int, Func <string, string> > findQ3 = (nn) =>
{
string vq = _qualifiers[nn];
int ndx = sret.IndexOf(vq);
Func <string, string> ret = null;
if (ndx > 0)
{
if (ndx > 0 && sret[ndx - 1] == '(')
{
ret = (ss) => ss.Remove(ndx - 1, vq.Length + 2);
}
else
{
ret = (ss) => ss.Remove(ndx, vq.Length);
}
r = (ValueQualifier)(nn + 1);
}
return(ret);
};
Func <string, string> trimmer = null;
for (int i = 0; i < _qualifiers.Length; ++i)
{
trimmer = findQ3(i);
if (trimmer != null)
{
s = trimmer(s).Trim();
break;
}
}
return(r);
}
private bool ParseDU(string v, string unitName, Qualities q)
{
if (String.IsNullOrEmpty(v))
{
return(false);
}
v = StringEx.RemoveReferences(v);
ValueQualifier vq = DoubleValue.FindQualifier(ref v);
double d;
if (UnitValue.TryParse(v, unitName, out d))
{
UnitValue uv = new UnitValue(d, unitName, vq);
return(SetValue(q, uv));
}
return(false);
}
private bool ParseAtomicRadius(string s, Qualities q)
{
const string UNIT = Units.PicoMeter;
ValueQualifier vq = DoubleValue.FindQualifier(ref s);
int ndx = s.IndexOf(UNIT);
if (ndx > 0)
{
s = s.Substring(0, ndx - 1).Trim();
double d;
if (UnitValue.TryParse(s, out d))
{
q.AtomicRadius = new UnitValue(d, UNIT, vq);
return(true);
}
}
return(false);
}
private bool ParseVanDerWaalsRadius(string s, Qualities q)
{
const string UNIT = "pm";
ValueQualifier vq = DoubleValue.FindQualifier(ref s);
int n = s.IndexOf(UNIT);
if (n > 0)
{
s = s.Substring(0, n - 1).Trim();
double d;
if (UnitValue.TryParse(s, out d))
{
q.VanDerWaalsRadius = new UnitValue(d, UNIT, vq);
return(true);
}
}
return(false);
}
public UnitValue(string sVal)
{
if (String.IsNullOrWhiteSpace(sVal))
{
throw new ArgumentException();
}
ValueQualifier vq = DoubleValue.FindQualifier(ref sVal);
foreach (String fs in _falseStarts)
{
if (sVal.StartsWith(fs))
{
sVal = sVal.Substring(fs.Length + 1).Trim();
break;
}
}
sVal = RemoveBrackets(sVal);
int i1 = 0;
bool dF = false;
while (i1 < sVal.Length && !IsDigit(sVal[i1], ref dF))
{
i1++;
}
StringBuilder sb = new StringBuilder();
dF = false;
while (i1 < sVal.Length && IsDigit(sVal[i1], ref dF))
{
sb.Append(sVal[i1++]);
}
if (sb.Length == 0)
{
throw new ArgumentException(String.Format("Unable to parse double from string '{0}'.", sVal));
}
Value = double.Parse(sb.ToString());
sVal = sVal.Substring(i1).Trim();
Units = sVal;
Qualifier = vq;
}
private bool ParseHeatOfFusion(string s, Qualities q)
{
string UNIT = "kJ/mol";
int n = 0;
ValueQualifier vq = DoubleValue.FindQualifier(ref s);
if (s.StartsWith("("))
{
n = s.IndexOf(')');
s = s.Substring(n + 1);
}
n = s.IndexOf(UNIT);
if (n > 0)
{
s = s.Substring(0, n - 1).Trim();
double d;
if (UnitValue.TryParse(s, out d))
{
q.HeatOfFusion = new UnitValue(d, UNIT, vq);
return(true);
}
}
return(false);
}
private bool ParseMeltingPoint(string s, Qualities q)
{
const string UNIT = "K";
ValueQualifier vq = DoubleValue.FindQualifier(ref s);
if (s.StartsWith("?"))
{
vq = ValueQualifier.Extrapolated;
s = s.Substring(1).Trim();
}
int n = s.IndexOf(UNIT);
if (n > 0)
{
s = s.Substring(0, n - 1).Trim();
double d;
if (UnitValue.TryParse(s, out d))
{
q.MeltingPoint = new UnitValue(d, UNIT, vq);
return(true);
}
}
return(false);
}
private bool ParseThermalConductivity(string s, Qualities q)
{
const string UNIT = "W/(m·K)", EST = "est.";
ValueQualifier vq = ValueQualifier.None;
if (s.StartsWith(EST))
{
vq = ValueQualifier.Estimated;
s = s.Substring(EST.Length).Trim();
}
int n = s.IndexOf(UNIT);
if (n > 0)
{
s = s.Substring(0, n - 1).Trim();
double d;
if (DoubleValue.TryParseScientific(s, out d) || UnitValue.TryParse(s, out d))
{
q.ThermalConductivity = new UnitValue(d, UNIT, vq);
return(true);
}
}
return(false);
}
public QualifiedPhase(Phase p, ValueQualifier vq = ValueQualifier.None)
{
Phase = p;
Qualifier = vq;
}
public QualifiedString(string v, ValueQualifier vq = ValueQualifier.None)
{
Value = v;
Qualifier = vq;
}
public static QualifiedString Parse(string v)
{
ValueQualifier vq = DoubleValue.FindQualifier(ref v);
return(new QualifiedString(v.Trim(), vq));
}
public DoubleValue(double value, ValueQualifier vq = ValueQualifier.None)
{
Value = value;
Qualifier = vq;
}
public UnitValue(double v, string units, ValueQualifier qualifier) : base(v, qualifier)
{
Units = units;
}
public UnitValueRange(double d, double d2, string unit, ValueQualifier vq = ValueQualifier.None) :
base(d, unit, vq)
{
Value2 = d2;
}
private bool ParseDensity(string v, Qualities q)
{
const string GPL = "g/L", GCM3 = Units.GramsPerCC, GRPH = "graphite:", BLK = "black:";
if (String.IsNullOrEmpty(v))
{
return(false);
}
int ndx, ndx2; // General vars
ValueQualifier vq = DoubleValue.FindQualifier(ref v);
v = StringEx.RemoveReferences(v);
Action <string> getAllotrope = (string n) =>
{
ndx = v.IndexOf(n) + n.Length; ndx2 = v.IndexOf(GCM3, ndx);
v = v.Substring(ndx);
if (ndx2 > ndx)
{
ndx2 -= ndx;
ndx2 += GCM3.Length;
while (ndx2 > v.Length)
{
ndx2--;
}
v = v.Substring(0, ndx2);
}
v = v.Trim();
vq = ValueQualifier.MostStableAllotrope;
};
switch (q.Element.Symbol)
{ // Choose most stable allotropes:
case "C": getAllotrope(GRPH); break;
case "P": getAllotrope(BLK); break;
case "S": getAllotrope("alpha:"); break;
case "Se": getAllotrope("gray:"); break;
case "Sn": getAllotrope("gray, α:"); break;
case "Po": getAllotrope("alpha:"); break;
// special case
case "Br": v = v.Remove(0, "Br2, liquid:".Length).Trim(); break;
}
double d;
string u;
if (UnitValue.TryParse(v, out d, out u))
{
if (u == GPL)
{
d /= 1000;
u = GCM3;
}
q.Density = new UnitValue(d, u, vq);
return(true);
}
return(false);
}
