public void TestElement()
{
Assert.IsNull(ChemicalElement.Get(0));
Assert.IsNull(ChemicalElement.Get(-1));
Assert.IsNull(ChemicalElement.Get("Nothing"));
Assert.IsFalse(new ChemicalElement(-1, null, "Nothing", true).IsValid());
Assert.IsFalse(ChemicalElement.IsValid("Nothing"));
var h = ChemicalElement.Get(1);
Assert.IsTrue(h.IsValid());
Assert.AreEqual(1, h.AtomicNumber);
Assert.AreEqual("H", h.Symbol);
Assert.AreEqual("Hydrogen", h.EnglishName);
Assert.AreEqual(1, h.Period);
Assert.AreEqual(1, h.Group);
Assert.AreEqual(0, h.IndexInPeriod);
Assert.AreEqual("s", h.Block);
Assert.AreEqual(h, ChemicalElement.Get("H"));
Assert.AreEqual(h, ChemicalElement.H);
Assert.AreEqual(h, new ChemicalElement(1, "H", "No.1", true));
Assert.IsTrue(h.HasAtomicWeight);
Assert.IsTrue(h.AtomicWeight >= 1);
Assert.IsTrue(h.ToString().Contains(h.Symbol));
Assert.IsTrue(h.IsNonMetallic);
Assert.IsFalse(h.IsAlkaliMetal);
Assert.IsFalse(h.IsAlkalineEarthMetal);
Assert.IsFalse(h.IsChalcogen);
Assert.IsFalse(h.IsHalogen);
Assert.IsFalse(h.IsInBoronGroup);
Assert.IsFalse(h.IsInCarbonGroup);
Assert.IsFalse(h.IsInNitrogenGroup);
Assert.IsFalse(h.IsInVIII);
Assert.IsFalse(h.IsMetal);
Assert.IsFalse(h.IsNoble);
Assert.IsFalse(h.IsTransition);
Assert.IsFalse(h.IsRadioelement());
Assert.AreEqual("H", ((JsonObjectNode)h).TryGetStringValue("symbol"));
var d = h.Isotope(2);
Assert.AreEqual("D", d.ToString());
Assert.AreEqual(h, d.Element);
Assert.AreEqual(1, d.AtomicNumber);
Assert.AreEqual(2, d.AtomicMassNumber);
Assert.AreEqual(1, d.Neutrons);
Assert.IsTrue(d.HasAtomicWeight);
Assert.AreEqual(d, new Isotope(h, 2));
Assert.IsFalse(h.Isotope(10).HasAtomicWeight);
var c = ChemicalElement.Get(6);
Assert.IsTrue(c.IsValid());
Assert.IsFalse(c == h);
Assert.IsTrue(c != h);
Assert.IsTrue(c > h);
Assert.IsTrue(c >= h);
Assert.IsFalse(c < h);
Assert.IsFalse(c <= h);
Assert.AreNotEqual(h, c);
Assert.AreEqual(6, c.AtomicNumber);
Assert.AreEqual("C", c.Symbol);
Assert.AreEqual("Carbon", c.EnglishName);
Assert.AreEqual(2, c.Period);
Assert.AreEqual(14, c.Group);
Assert.AreEqual(3, c.IndexInPeriod);
Assert.AreEqual("p", c.Block);
Assert.AreEqual(c, ChemicalElement.Get("C"));
Assert.AreEqual(c, ChemicalElement.C);
Assert.AreEqual(c, new ChemicalElement(6, "C", "No.6", true));
Assert.IsTrue(c.HasAtomicWeight);
Assert.IsTrue(c.AtomicWeight >= 12);
Assert.IsTrue(c.ToString().Contains(c.Symbol));
Assert.AreEqual(6, ((JsonObjectNode)c).TryGetInt32Value("number"));
var c12 = c.Isotope(12);
Assert.AreNotEqual(h, c12);
Assert.AreEqual(3, c12.ToString().Length);
Assert.IsTrue(c12.ToString().EndsWith("C"));
Assert.AreEqual(c, c12.Element);
Assert.AreEqual(6, c12.AtomicNumber);
Assert.AreEqual(12, c12.AtomicMassNumber);
Assert.AreEqual(6, c12.Neutrons);
Assert.IsTrue(c12.HasAtomicWeight);
Assert.AreEqual(12, c12.AtomicWeight);
Assert.AreEqual(c12, new Isotope(6, 12));
var count = 0;
foreach (var prop in typeof(ChemicalElement).GetProperties(BindingFlags.Static | BindingFlags.Public))
{
if (!prop.CanRead || prop.PropertyType != typeof(ChemicalElement))
{
continue;
}
var ele = (ChemicalElement)prop.GetValue(null);
Assert.IsNotNull(ele);
Assert.AreEqual(prop.Name, ele.Symbol);
Assert.AreEqual(ele, ChemicalElement.Get(ele.AtomicNumber));
Assert.AreEqual(ele, ChemicalElement.Get(ele.Symbol));
Assert.IsFalse(string.IsNullOrWhiteSpace(ele.Name));
count++;
}
Assert.IsTrue(count >= 118);
var usn = ChemicalElement.Get(170);
Assert.AreNotEqual(h, usn);
Assert.AreNotEqual(c, usn);
Assert.AreEqual("Usn", usn.Symbol);
Assert.AreEqual("Unseptnilium", usn.EnglishName);
Assert.AreEqual(9, usn.Period);
Assert.AreEqual(2, usn.Group);
Assert.AreEqual(1, usn.IndexInPeriod);
Assert.AreEqual("s", usn.Block);
Assert.AreEqual(usn, ChemicalElement.Get("Usn"));
Assert.IsFalse(usn.HasAtomicWeight);
Assert.IsTrue(double.IsNaN(usn.AtomicWeight));
Assert.IsTrue(usn.ToString().Contains(usn.Symbol));
var bbb = ChemicalElement.Get(222);
Assert.AreEqual("Bbb", bbb.Symbol);
Assert.AreEqual("i", bbb.Block);
var one = new ChemicalElement(17, "Seventeen", "A new sample element", true);
Assert.IsTrue(one.IsValid());
Assert.AreNotEqual(ChemicalElement.Get(17), one);
}
/// <inheritdoc />
protected override async Task OnProcessAsync(CancellationToken cancellationToken = default)
{
await RunAsync(null, cancellationToken);
var s = Arguments.Verb?.TryGet(0);
var console = GetConsole();
if (s == "period" || s == "p" || s == "周期" || (s == "Period" && Arguments.Verb.Count > 1))
{
s = Arguments.Verb.TryGet(1);
if (string.IsNullOrEmpty(s))
{
ChemistryCommandLine.WriteTable(GetConsole(), ChemicalElementStyle);
}
else if (int.TryParse(s, out var period) && period > 0)
{
if (period > 7)
{
var start = ChemicalElement.FirstAtomicNumberInPeriod(period);
var end = ChemicalElement.LastAtomicNumberInPeriod(period);
if (start <= 0 || end <= 0 || start >= end)
{
WriteError(" The period was too large.");
}
else
{
console.WriteLine(ChemistryResource.ChemicalElement);
console.WriteLine($"{start} - {end} (Total {end - start + 1})");
}
return;
}
var elements = ChemicalElement.GetExisted();
var has = false;
foreach (var element in elements)
{
if (element is null)
{
continue;
}
if (element.Period != period)
{
if (has)
{
break;
}
continue;
}
WriteSimpleInfo(element, Arguments.Has("en"));
}
}
else if (s.Equals("help", StringComparison.OrdinalIgnoreCase) || s.Equals("?", StringComparison.Ordinal))
{
WriteHelp(Arguments.Verb?.Key, "period");
}
else
{
WriteError(" The period should be a natural number.");
}
return;
}
var q = Arguments.GetMergedValue("q")?.Trim();
if (q.Length < 1)
{
q = null;
}
if (s == "*" || s == "all" || s == "a")
{
foreach (var i in ChemicalElement.Where(GetFilter(q)))
{
WriteSimpleInfo(i, Arguments.Has("en"));
}
return;
}
if (s == "ls" || s == "l" || s == "list" || s == "dir" || s == "全部")
{
var filter = Arguments.Verb.TryGet(1)?.Trim()?.Split('-');
List <ChemicalElement> col = null;
if (filter is null || filter.Length < 1 || string.IsNullOrWhiteSpace(filter[0]))
{
}
else if (filter[0].Equals("help", StringComparison.OrdinalIgnoreCase) || filter[0].Equals("?", StringComparison.Ordinal))
{
WriteHelp(Arguments.Verb?.Key, "ls");
return;
}
else if (!int.TryParse(filter[0], out var begin))
{
}
else if (filter.Length == 1)
{
col = ChemicalElement.Range(0, begin).ToList();
}
else if (filter.Length == 2 && int.TryParse(filter[1], out var end))
{
col = ChemicalElement.Range(begin, end - begin).ToList();
}
if (col is null)
{
col = ChemicalElement.Where(null).ToList();
}
var filter2 = GetFilter(q);
foreach (var i in filter2 is null ? col : col.Where(filter2))
{
WriteSimpleInfo(i, Arguments.Has("en"));
}
return;
}
public void Update(List <PlatformObject> objects)
{
if (!triggered)
{
return;
}
foreach (PlatformObject obj in objects)
{
if (obj.bounds.Intersects(bounds))
{
return;
}
}
ChemicalSignature signature = Game1.instance.platformLevel.SpawnInputChemical(inputIndex);
if (signature == null)
{
return;
}
triggered = false;
int height = signature.height;
int width = signature.width;
float startX = bounds.CenterX - width * 32 / 2;
float startY = bounds.CenterY - height * 32 / 2;
float curX = startX;
float curY = startY;
ChemBlock[,] blocksSpawned = new ChemBlock[width, height];
for (int col = 0; col < width; ++col)
{
for (int row = 0; row < height; ++row)
{
ChemicalElement c = signature[col, row];
if (c != ChemicalElement.NONE)
{
ChemBlock newBlock = new ChemBlock(c, c.ToTexture(false), new Vector2(curX, curY), new Vector2(32, 32), c.ToColor());
objects.Add(newBlock);
blocksSpawned[col, row] = newBlock;
if (col > 0 && blocksSpawned[col - 1, row] != null)
{
blocksSpawned[col - 1, row].NailOnto(newBlock);
}
if (row > 0 && blocksSpawned[col, row - 1] != null)
{
blocksSpawned[col, row - 1].NailOnto(newBlock);
}
}
curY += 32.5f;
}
curX += 32.5f;
curY = startY;
Game1.instance.platformLevel.UpdateAnyBlocksLeft();
}
}
public IPseudoAtom NewPseudoAtom(ChemicalElement element) => (IPseudoAtom) new PseudoAtom(element);
public Color GetAtomColor(IAtom atom, Color defaultColor)
{
var elem = ChemicalElement.OfSymbol(atom.Symbol).AtomicNumber;
if (elem == AtomicNumbers.Unknown)
{
elem = atom.AtomicNumber;
}
switch (elem)
{
case AtomicNumbers.Helium:
return(hexD9FFFF);
case AtomicNumbers.Lithium:
return(hexCC80FF);
case AtomicNumbers.Beryllium:
return(hexC2FF00);
case AtomicNumbers.Boron:
return(hexFFB5B5);
case AtomicNumbers.Hydrogen:
case AtomicNumbers.Carbon:
case AtomicNumbers.Unknown:
return(WPF.Media.Colors.Black);
case AtomicNumbers.Nitrogen:
return(hex3050F8);
case AtomicNumbers.Oxygen:
return(hexFF0D0D);
case AtomicNumbers.Fluorine:
return(hex90E050);
case AtomicNumbers.Neon:
return(hexB3E3F5);
case AtomicNumbers.Sodium:
return(hexAB5CF2);
case AtomicNumbers.Magnesium:
return(hex8AFF00);
case AtomicNumbers.Aluminium:
return(hexBFA6A6);
case AtomicNumbers.Silicon:
return(hexF0C8A0);
case AtomicNumbers.Phosphorus:
return(hexFF8000);
case AtomicNumbers.Sulfur:
return(hexFFFF30);
case AtomicNumbers.Chlorine:
return(hex1FF01F);
case AtomicNumbers.Argon:
return(hex80D1E3);
case AtomicNumbers.Potassium:
return(hex8F40D4);
case AtomicNumbers.Calcium:
return(hex3DFF00);
case AtomicNumbers.Scandium:
return(hexE6E6E6);
case AtomicNumbers.Titanium:
return(hexBFC2C7);
case AtomicNumbers.Vanadium:
return(hexA6A6AB);
case AtomicNumbers.Chromium:
return(hex8A99C7);
case AtomicNumbers.Manganese:
return(hex9C7AC7);
case AtomicNumbers.Iron:
return(hexE06633);
case AtomicNumbers.Cobalt:
return(hexF090A0);
case AtomicNumbers.Nickel:
return(hex50D050);
case AtomicNumbers.Copper:
return(hexC88033);
case AtomicNumbers.Zinc:
return(hex7D80B0);
case AtomicNumbers.Gallium:
return(hexC28F8F);
case AtomicNumbers.Germanium:
return(hex668F8F);
case AtomicNumbers.Arsenic:
return(hexBD80E3);
case AtomicNumbers.Selenium:
return(hexFFA100);
case AtomicNumbers.Bromine:
return(hexA62929);
case AtomicNumbers.Krypton:
return(hex5CB8D1);
case AtomicNumbers.Rubidium:
return(hex702EB0);
case AtomicNumbers.Strontium:
return(hex00FF00);
case AtomicNumbers.Yttrium:
return(hex94FFFF);
case AtomicNumbers.Zirconium:
return(hex94E0E0);
case AtomicNumbers.Niobium:
return(hex73C2C9);
case AtomicNumbers.Molybdenum:
return(hex54B5B5);
case AtomicNumbers.Technetium:
return(hex3B9E9E);
case AtomicNumbers.Ruthenium:
return(hex248F8F);
case AtomicNumbers.Rhodium:
return(hex0A7D8C);
case AtomicNumbers.Palladium:
return(hex006985);
case AtomicNumbers.Silver:
return(hexC0C0C0);
case AtomicNumbers.Cadmium:
return(hexFFD98F);
case AtomicNumbers.Indium:
return(hexA67573);
case AtomicNumbers.Tin:
return(hex668080);
case AtomicNumbers.Antimony:
return(hex9E63B5);
case AtomicNumbers.Tellurium:
return(hexD47A00);
case AtomicNumbers.Iodine:
return(hex940094);
case AtomicNumbers.Xenon:
return(hex429EB0);
case AtomicNumbers.Caesium:
return(hex57178F);
case AtomicNumbers.Barium:
return(hex00C900);
case AtomicNumbers.Lanthanum:
return(hex70D4FF);
case AtomicNumbers.Cerium:
return(hexFFFFC7);
case AtomicNumbers.Praseodymium:
return(hexD9FFC7);
case AtomicNumbers.Neodymium:
return(hexC7FFC7);
case AtomicNumbers.Promethium:
return(hexA3FFC7);
case AtomicNumbers.Samarium:
return(hex8FFFC7);
case AtomicNumbers.Europium:
return(hex61FFC7);
case AtomicNumbers.Gadolinium:
return(hex45FFC7);
case AtomicNumbers.Terbium:
return(hex30FFC7);
case AtomicNumbers.Dysprosium:
return(hex1FFFC7);
case AtomicNumbers.Holmium:
return(hex00FF9C);
case AtomicNumbers.Erbium:
return(hex00E675);
case AtomicNumbers.Thulium:
return(hex00D452);
case AtomicNumbers.Ytterbium:
return(hex00BF38);
case AtomicNumbers.Lutetium:
return(hex00AB24);
case AtomicNumbers.Hafnium:
return(hex4DC2FF);
case AtomicNumbers.Tantalum:
return(hex4DA6FF);
case AtomicNumbers.Tungsten:
return(hex2194D6);
case AtomicNumbers.Rhenium:
return(hex267DAB);
case AtomicNumbers.Osmium:
return(hex266696);
case AtomicNumbers.Iridium:
return(hex175487);
case AtomicNumbers.Platinum:
return(hexD0D0E0);
case AtomicNumbers.Gold:
return(hexFFD123);
case AtomicNumbers.Mercury:
return(hexB8B8D0);
case AtomicNumbers.Thallium:
return(hexA6544D);
case AtomicNumbers.Lead:
return(hex575961);
case AtomicNumbers.Bismuth:
return(hex9E4FB5);
case AtomicNumbers.Polonium:
return(hexAB5C00);
case AtomicNumbers.Astatine:
return(hex754F45);
case AtomicNumbers.Radon:
return(hex428296);
case AtomicNumbers.Francium:
return(hex420066);
case AtomicNumbers.Radium:
return(hex007D00);
case AtomicNumbers.Actinium:
return(hex70ABFA);
case AtomicNumbers.Thorium:
return(hex00BAFF);
case AtomicNumbers.Protactinium:
return(hex00A1FF);
case AtomicNumbers.Uranium:
return(hex008FFF);
case AtomicNumbers.Neptunium:
return(hex0080FF);
case AtomicNumbers.Plutonium:
return(hex006BFF);
case AtomicNumbers.Americium:
return(hex545CF2);
case AtomicNumbers.Curium:
return(hex785CE3);
case AtomicNumbers.Berkelium:
return(hex8A4FE3);
case AtomicNumbers.Californium:
return(hexA136D4);
case AtomicNumbers.Einsteinium:
return(hexB31FD4);
case AtomicNumbers.Fermium:
return(hexB31FBA);
case AtomicNumbers.Mendelevium:
return(hexB30DA6);
case AtomicNumbers.Nobelium:
return(hexBD0D87);
case AtomicNumbers.Lawrencium:
return(hexC70066);
case AtomicNumbers.Rutherfordium:
return(hexCC0059);
case AtomicNumbers.Dubnium:
return(hexD1004F);
case AtomicNumbers.Seaborgium:
return(hexD90045);
case AtomicNumbers.Bohrium:
return(hexE00038);
case AtomicNumbers.Hassium:
return(hexE6002E);
case AtomicNumbers.Meitnerium:
return(hexEB0026);
default:
return(defaultColor);
}
}
public IAtomType NewAtomType(ChemicalElement element) => (IAtomType) new AtomType(element);
public IIsotope NewIsotope(ChemicalElement element, int massNumber) => (IIsotope) new Isotope(element, massNumber);
/// <summary>
/// Get the period of the element.
/// </summary>
/// <param name="symbol">the symbol of the element</param>
/// <returns>the period</returns>
public static int GetPeriod(string symbol)
{
return(NaturalElement.Periods[ChemicalElement.OfSymbol(symbol).AtomicNumber]);
}
/// <summary>
/// Get the Pauling electronegativity of an element.
/// </summary>
/// <param name="symbol">the symbol of the element</param>
/// <returns>the Pauling electronegativity</returns>
public static double?GetPaulingElectronegativity(string symbol)
{
return(NaturalElement.Electronegativities[ChemicalElement.OfSymbol(symbol).AtomicNumber]);
}
/// <summary>
/// Get the name of the element.
/// </summary>
/// <param name="symbol">the symbol of the element</param>
/// <returns>the name of the element</returns>
public static string GetName(string symbol)
{
return(GetName(ChemicalElement.OfSymbol(symbol).AtomicNumber));
}
/// <summary>
/// Get the name of the element.
/// </summary>
/// <param name="atomicNumber">Atomic number</param>
/// <returns>The name of the element</returns>
public static string GetName(int atomicNumber)
{
return(ChemicalElement.Of(atomicNumber).Name);
}
/// <summary>
/// Find all enabled abbreviations in the provided molecule. They are not
/// added to the existing Sgroups and may need filtering.
/// </summary>
/// <param name="mol">molecule</param>
/// <returns>list of new abbreviation Sgroups</returns>
public IList <Sgroup> Generate(IAtomContainer mol)
{
// mark which atoms have already been abbreviated or are
// part of an existing Sgroup
var usedAtoms = new HashSet <IAtom>();
var sgroups = mol.GetCtabSgroups();
if (sgroups != null)
{
foreach (var sgroup in sgroups)
{
foreach (var atom in sgroup.Atoms)
{
usedAtoms.Add(atom);
}
}
}
// disconnected abbreviations, salts, common reagents, large compounds
if (!usedAtoms.Any())
{
try
{
var copy = AtomContainerManipulator.CopyAndSuppressedHydrogens(mol);
string cansmi = usmigen.Create(copy);
if (disconnectedAbbreviations.TryGetValue(cansmi, out string label) && !disabled.Contains(label))
{
var sgroup = new Sgroup
{
Type = SgroupType.CtabAbbreviation,
Subscript = label
};
foreach (var atom in mol.Atoms)
{
sgroup.Atoms.Add(atom);
}
return(new[] { sgroup });
}
else if (cansmi.Contains("."))
{
var parts = ConnectivityChecker.PartitionIntoMolecules(mol);
// partiton in two two parts
Sgroup best = null;
for (int i = 0; i < parts.Count; i++)
{
var a = parts[i];
var b = a.Builder.NewAtomContainer();
for (int j = 0; j < parts.Count; j++)
{
if (j != i)
{
b.Add(parts[j]);
}
}
var sgroup1 = GetAbbr(a);
var sgroup2 = GetAbbr(b);
if (sgroup1 != null && sgroup2 != null)
{
var combined = new Sgroup();
label = null;
foreach (var atom in sgroup1.Atoms)
{
combined.Atoms.Add(atom);
}
foreach (var atom in sgroup2.Atoms)
{
combined.Atoms.Add(atom);
}
if (sgroup1.Subscript.Length > sgroup2.Subscript.Length)
{
combined.Subscript = sgroup1.Subscript + String_Interpunct + sgroup2.Subscript;
}
else
{
combined.Subscript = sgroup2.Subscript + String_Interpunct + sgroup1.Subscript;
}
combined.Type = SgroupType.CtabAbbreviation;
return(new[] { combined });
}
if (sgroup1 != null && (best == null || sgroup1.Atoms.Count > best.Atoms.Count))
{
best = sgroup1;
}
if (sgroup2 != null && (best == null || sgroup2.Atoms.Count > best.Atoms.Count))
{
best = sgroup2;
}
}
if (best != null)
{
return new[] { best }
}
;
}
}
catch (CDKException)
{
}
}
var newSgroups = new List <Sgroup>();
var fragments = GenerateFragments(mol);
var sgroupAdjs = new MultiDictionary <IAtom, Sgroup>();
foreach (var frag in fragments)
{
try
{
var smi = usmigen.Create(AtomContainerManipulator.CopyAndSuppressedHydrogens(frag));
if (!connectedAbbreviations.TryGetValue(smi, out string label) || disabled.Contains(label))
{
continue;
}
bool overlap = false;
// note: first atom is '*'
var numAtoms = frag.Atoms.Count;
var numBonds = frag.Bonds.Count;
for (int i = 1; i < numAtoms; i++)
{
if (usedAtoms.Contains(frag.Atoms[i]))
{
overlap = true;
break;
}
}
// overlaps with previous assignment
if (overlap)
{
continue;
}
// create new abbreviation Sgroup
var sgroup = new Sgroup
{
Type = SgroupType.CtabAbbreviation,
Subscript = label
};
var attachBond = frag.Bonds[0].GetProperty <IBond>(PropertyName_CutBond);
IAtom attachAtom = null;
sgroup.Bonds.Add(attachBond);
for (int i = 1; i < numAtoms; i++)
{
var atom = frag.Atoms[i];
usedAtoms.Add(atom);
sgroup.Atoms.Add(atom);
if (attachBond.Begin.Equals(atom))
{
attachAtom = attachBond.End;
}
else if (attachBond.End.Equals(atom))
{
attachAtom = attachBond.Begin;
}
}
if (attachAtom != null)
{
sgroupAdjs.Add(attachAtom, sgroup);
}
newSgroups.Add(sgroup);
}
catch (CDKException)
{
// ignore
}
}
if (!ContractOnHetero)
{
return(newSgroups);
}
// now collapse
foreach (var attach in mol.Atoms)
{
if (usedAtoms.Contains(attach))
{
continue;
}
// skip charged or isotopic labelled, C or R/*, H, He
if ((attach.FormalCharge != null && attach.FormalCharge != 0) ||
attach.MassNumber != null ||
attach.AtomicNumber == 6 ||
attach.AtomicNumber < 2)
{
continue;
}
var hcount = attach.ImplicitHydrogenCount.Value;
var xatoms = new HashSet <IAtom>();
var xbonds = new HashSet <IBond>();
var newbonds = new HashSet <IBond>();
xatoms.Add(attach);
var nbrSymbols = new List <string>();
var todelete = new HashSet <Sgroup>();
foreach (var sgroup in sgroupAdjs[attach])
{
if (ContainsChargeChar(sgroup.Subscript))
{
continue;
}
if (sgroup.Bonds.Count != 1)
{
continue;
}
var xbond = sgroup.Bonds.First();
xbonds.Add(xbond);
foreach (var a in sgroup.Atoms)
{
xatoms.Add(a);
}
if (attach.Symbol.Length == 1 &&
char.IsLower(sgroup.Subscript[0]))
{
if (ChemicalElement.OfSymbol(attach.Symbol + sgroup.Subscript[0]) != ChemicalElement.R)
{
goto continue_collapse;
}
}
nbrSymbols.Add(sgroup.Subscript);
todelete.Add(sgroup);
}
int numSGrpNbrs = nbrSymbols.Count;
foreach (var bond in mol.GetConnectedBonds(attach))
{
if (!xbonds.Contains(bond))
{
var nbr = bond.GetOther(attach);
// contract terminal bonds
if (mol.GetConnectedBonds(nbr).Count() == 1)
{
if (nbr.MassNumber != null ||
(nbr.FormalCharge != null && nbr.FormalCharge != 0))
{
newbonds.Add(bond);
}
else if (nbr.AtomicNumber == 1)
{
hcount++;
xatoms.Add(nbr);
}
else if (nbr.AtomicNumber > 0)
{
nbrSymbols.Add(NewSymbol(nbr.AtomicNumber, nbr.ImplicitHydrogenCount.Value, false));
xatoms.Add(nbr);
}
}
else
{
newbonds.Add(bond);
}
}
}
// reject if no symbols
// reject if no bonds (<1), except if all symbols are identical... (HashSet.size==1)
// reject if more that 2 bonds
if (!nbrSymbols.Any() ||
newbonds.Count < 1 && (new HashSet <string>(nbrSymbols).Count != 1) ||
newbonds.Count > 2)
{
continue;
}
// create the symbol
var sb = new StringBuilder();
sb.Append(NewSymbol(attach.AtomicNumber, hcount, newbonds.Count == 0));
string prev = null;
int count = 0;
nbrSymbols.Sort((o1, o2) =>
{
int cmp = o1.Length.CompareTo(o2.Length);
if (cmp != 0)
{
return(cmp);
}
return(o1.CompareTo(o2));
});
foreach (string nbrSymbol in nbrSymbols)
{
if (nbrSymbol.Equals(prev))
{
count++;
}
else
{
bool useParen = count == 0 || CountUpper(prev) > 1 || (prev != null && nbrSymbol.StartsWith(prev));
AppendGroup(sb, prev, count, useParen);
prev = nbrSymbol;
count = 1;
}
}
AppendGroup(sb, prev, count, false);
// remove existing
foreach (var e in todelete)
{
newSgroups.Remove(e);
}
// create new
var newSgroup = new Sgroup
{
Type = SgroupType.CtabAbbreviation,
Subscript = sb.ToString()
};
foreach (var bond in newbonds)
{
newSgroup.Bonds.Add(bond);
}
foreach (var atom in xatoms)
{
newSgroup.Atoms.Add(atom);
}
newSgroups.Add(newSgroup);
foreach (var a in xatoms)
{
usedAtoms.Add(a);
}
continue_collapse:
;
}
return(newSgroups);
}
public IntToChemicalData(int c, ChemicalElement t, bool e = false)
{
this.couple = c;
this.type = t;
this.empty = e;
}
public ChemicalToArrayData(ChemicalElement e, ChemicalElement[] a)
{
this.element = e;
this.array = a;
}
public IAtom NewAtom(ChemicalElement element) => (IAtom) new Atom(element);
/// <summary>
/// Get the symbol for the specified atomic number.
/// </summary>
/// <param name="atomicNumber">the atomic number of the element</param>
/// <returns>the corresponding symbol</returns>
public static string GetSymbol(int atomicNumber)
{
return(ChemicalElement.Of(atomicNumber).Symbol);
}
public IAtom NewAtom(ChemicalElement element, Vector3 point3d) => (IAtom) new Atom(element, point3d);
/// <summary>
/// Get the Van der Waals radius for the element in question.
/// </summary>
/// <param name="symbol">The symbol of the element</param>
/// <returns>the Van der waals radius</returns>
public static double?GetVdwRadius(string symbol)
{
return(GetVdwRadius(ChemicalElement.OfSymbol(symbol).AtomicNumber));
}
public IIsotope NewIsotope(ChemicalElement element) => (IIsotope) new Isotope(element);
/// <summary>
/// Get the covalent radius for an element.
/// </summary>
/// <param name="symbol">the symbol of the element</param>
/// <returns>the covalent radius</returns>
public static double?GetCovalentRadius(string symbol)
{
return(NaturalElement.CovalentRadiuses[ChemicalElement.OfSymbol(symbol).AtomicNumber]);
}
public IIsotope NewIsotope(ChemicalElement element, double exactMass, double abundance) => (IIsotope) new Isotope(element, exactMass, abundance);
/// <summary>
/// Get the CAS ID for an element.
/// </summary>
/// <param name="symbol">the symbol of the element</param>
/// <returns>the CAS ID</returns>
public static string GetCASId(string symbol)
{
return(MapToCasId[ChemicalElement.OfSymbol(symbol).AtomicNumber]);
}
public IPDBAtom NewPDBAtom(ChemicalElement element) => (IPDBAtom) new PDBAtom(element);
/// <summary>
/// Get the group of the element.
/// </summary>
/// <param name="symbol">the symbol of the element</param>
/// <returns>the group</returns>
public static int GetGroup(string symbol)
{
return(GetGroup(ChemicalElement.OfSymbol(symbol).AtomicNumber));
}
/// <summary>
/// Initializes a new instance of the <see cref="ChemicalFormulaComponent"/> class.
/// </summary>
/// <param name="element">The chemical element that is part of the molecule.</param>
/// <param name="atomCount">The number of atoms contributed to the molecule.</param>
public ChemicalFormulaComponent(ChemicalElement element, int atomCount = 1)
{
this.Element = element;
this.AtomCount = atomCount;
}
/// <summary>
/// Read a Reaction from a file in MDL RXN format
/// </summary>
/// <returns>The Reaction that was read from the MDL file.</returns>
private IAtomContainer ReadMolecule(IAtomContainer molecule)
{
try
{
int atomCount = 0;
int bondCount = 0;
string line;
while (true)
{
line = input.ReadLine();
if (line == null)
{
return(null);
}
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
break;
}
if (!line.StartsWithChar('#') && line.Trim().Length > 0)
{
break;
}
}
// ok, if we're coming from the chemfile function, we've already read the molecule RTI
if (firstLineisMolecule)
{
molecule.Title = line;
}
else
{
line = input.ReadLine();
molecule.Title = line;
}
// get atom and bond counts
var counts = input.ReadLine();
var tokenizer = Strings.Tokenize(counts);
try
{
atomCount = int.Parse(tokenizer[0], NumberFormatInfo.InvariantInfo);
}
catch (FormatException nfExc)
{
string error = "Error while reading atom count from MOLECULE block";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
if (tokenizer.Count > 1)
{
try
{
bondCount = int.Parse(tokenizer[1], NumberFormatInfo.InvariantInfo);
}
catch (FormatException nfExc)
{
string error = "Error while reading atom and bond counts";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
}
else
{
bondCount = 0;
}
Trace.TraceInformation("Reading #atoms: ", atomCount);
Trace.TraceInformation("Reading #bonds: ", bondCount);
// we skip mol type, charge type and status bit lines
Trace.TraceWarning("Not reading molecule qualifiers");
line = input.ReadLine();
bool molend = false;
while (line != null)
{
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
molend = true;
break;
}
else if (line.StartsWith("@<TRIPOS>ATOM", StringComparison.Ordinal))
{
Trace.TraceInformation("Reading atom block");
for (int i = 0; i < atomCount; i++)
{
line = input.ReadLine().Trim();
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
molend = true;
break;
}
tokenizer = Strings.Tokenize(line);
// disregard the id token
var nameStr = tokenizer[1];
var xStr = tokenizer[2];
var yStr = tokenizer[3];
var zStr = tokenizer[4];
var atomTypeStr = tokenizer[5];
// replace unrecognised atom type
if (ATOM_TYPE_ALIASES.ContainsKey(atomTypeStr))
{
atomTypeStr = ATOM_TYPE_ALIASES[atomTypeStr];
}
var atom = molecule.Builder.NewAtom();
IAtomType atomType;
try
{
atomType = atFactory.GetAtomType(atomTypeStr);
}
catch (Exception)
{
// ok, *not* an mol2 atom type
atomType = null;
}
// Maybe it is just an element
if (atomType == null && IsElementSymbol(atomTypeStr))
{
atom.Symbol = atomTypeStr;
}
else
{
if (atomType == null)
{
atomType = atFactory.GetAtomType("X");
Trace.TraceError($"Could not find specified atom type: {atomTypeStr}");
}
AtomTypeManipulator.Configure(atom, atomType);
}
atom.AtomicNumber = ChemicalElement.OfSymbol(atom.Symbol).AtomicNumber;
atom.Id = nameStr;
atom.AtomTypeName = atomTypeStr;
try
{
var x = double.Parse(xStr, NumberFormatInfo.InvariantInfo);
var y = double.Parse(yStr, NumberFormatInfo.InvariantInfo);
var z = double.Parse(zStr, NumberFormatInfo.InvariantInfo);
atom.Point3D = new Vector3(x, y, z);
}
catch (FormatException nfExc)
{
string error = "Error while reading atom coordinates";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
molecule.Atoms.Add(atom);
}
}
else if (line.StartsWith("@<TRIPOS>BOND", StringComparison.Ordinal))
{
Trace.TraceInformation("Reading bond block");
for (int i = 0; i < bondCount; i++)
{
line = input.ReadLine();
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
molend = true;
break;
}
tokenizer = Strings.Tokenize(line);
// disregard the id token
var atom1Str = tokenizer[1];
var atom2Str = tokenizer[2];
var orderStr = tokenizer[3];
try
{
var atom1 = int.Parse(atom1Str, NumberFormatInfo.InvariantInfo);
var atom2 = int.Parse(atom2Str, NumberFormatInfo.InvariantInfo);
if (string.Equals("nc", orderStr, StringComparison.Ordinal))
{
// do not connect the atoms
}
else
{
var bond = molecule.Builder.NewBond(molecule.Atoms[atom1 - 1], molecule.Atoms[atom2 - 1]);
switch (orderStr)
{
case "1":
bond.Order = BondOrder.Single;
break;
case "2":
bond.Order = BondOrder.Double;
break;
case "3":
bond.Order = BondOrder.Triple;
break;
case "am":
case "ar":
bond.Order = BondOrder.Single;
bond.IsAromatic = true;
bond.Begin.IsAromatic = true;
bond.End.IsAromatic = true;
break;
case "du":
bond.Order = BondOrder.Single;
break;
case "un":
bond.Order = BondOrder.Single;
break;
default:
break;
}
molecule.Bonds.Add(bond);
}
}
catch (FormatException nfExc)
{
var error = "Error while reading bond information";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
}
}
if (molend)
{
return(molecule);
}
line = input.ReadLine();
}
}
catch (IOException exception)
{
var error = "Error while reading general structure";
Trace.TraceError(error);
Debug.WriteLine(exception);
throw new CDKException(error, exception);
}
return(molecule);
}