public static IAtom FromSubset(IAtom a, int sum, int deg)
{
// atom is already a non-subset atom
if (!a.Subset)
{
return(a);
}
Element e = a.Element;
if (a.IsAromatic())
{
sum++;
}
int hCount = a.IsAromatic() ? e.NumOfAromaticImplicitHydrogens(sum)
: e.NumOfImplicitHydrogens(sum);
// XXX: if there was an odd number of availableElectrons there was an odd number
// or aromatic bonds (usually 1 or 3) - if there was one it was
// only a single bond it's likely a spouting from a ring - otherwise
// someones making our life difficult (e.g. c1=cc=cc=c1) in which we
// 'give' back 2 free availableElectrons for use indeterminacy the hCount
// int hCount = (electrons & 0x1) == 1 ? deg > 1 ? (electrons + 2) / 2
// : electrons / 2
// : electrons / 2;
return(new AtomImpl.BracketAtom(-1,
a.Element,
hCount,
0,
0,
a.IsAromatic()));
}
public static IAtom ToSubset(IAtom a, Graph g, int u)
{
// atom is already a subset atom
if (a.Subset)
{
return(a);
}
// element is not organic and thus cannot be part of the subset
if (!a.Element.IsOrganic())
{
return(a);
}
// if any of these values are set the atom cannot be a subset atom
if (a.Charge != 0 || a.AtomClass != 0 || a.Isotope >= 0)
{
return(a);
}
IAtom subset = a.IsAromatic() ? AtomImpl.AromaticSubset.OfElement(a.Element)
: AtomImpl.AliphaticSubset.OfElement(a.Element);
// does the implied availableElectrons from the bond Order sum match that
// which was stored - if aromatic we only check the lowest valence state
int impliedHCount = subset.GetNumberOfHydrogens(g, u);
// mismatch in number of hydrogens we must write this as a bracket atom
return(impliedHCount != a.NumOfHydrogens ? a : subset);
}
private static IAtom AsBracketAtom(int u, Graph g)
{
IAtom a = g.GetAtom(u);
int sum = a.IsAromatic() ? 1 : 0;
foreach (var e in g.GetEdges(u))
{
sum += e.Bond.Order;
}
return(new AtomImpl.BracketAtom(-1,
a.Element,
a.IsAromatic() ? a.Element.NumOfAromaticImplicitHydrogens(sum)
: a.Element.NumOfImplicitHydrogens(sum),
0,
0,
a.IsAromatic()));
}
public void Aliphatic_symbol_c()
{
IAtom a = AtomBuilder.Aliphatic("C").Build();
Assert.AreEqual(a.Element, Element.Carbon);
Assert.AreEqual(a.Isotope, -1);
Assert.AreEqual(a.Charge, 0);
Assert.AreEqual(a.AtomClass, 0);
Assert.AreEqual(a.IsAromatic(), false);
}
public void IsAromatic_element_c()
{
IAtom a = AtomBuilder.Aromatic(Carbon).Build();
Assert.AreEqual(a.Element, Element.Carbon);
Assert.AreEqual(a.Isotope, -1);
Assert.AreEqual(a.Charge, 0);
Assert.AreEqual(a.AtomClass, 0);
Assert.AreEqual(a.IsAromatic(), true);
}
/// <summary>
/// Given two atoms which are explicit connected determine the implicit bond
/// type. If both atoms are aromatic but connected by a single bond the bond
/// type is <see cref="Bond.Single"/> otherwise it is implicit.
/// </summary>
/// <param name="u">an atom</param>
/// <param name="v">another atom </param>(connected to u)
/// <param name="b">explicit bond type</param>
/// <returns>the bond type</returns>
static Bond GetBondType(IAtom u, IAtom v, Bond b)
{
if (u.IsAromatic() && v.IsAromatic())
{
return(b == Bond.Aromatic ? Bond.Implicit : b);
}
else
{
return(b == Bond.Aromatic ? Bond.Aromatic : Bond.Implicit);
}
}
public override void Append(StringBuilder sb)
{
bool hExpand = atom.Element == Element.Hydrogen &&
Graph.Degree(Index) == 0;
sb.Append('[');
if (atom.Isotope >= 0)
{
sb.Append(atom.Isotope);
}
sb.Append(
atom.IsAromatic() ?
atom.Element.Symbol.ToLowerInvariant() :
atom.Element.Symbol);
if (c != Configuration.Unknown)
{
sb.Append(c.Shorthand.Symbol);
}
if (atom.NumOfHydrogens > 0 && !hExpand)
{
sb.Append(Element.Hydrogen.Symbol);
}
if (atom.NumOfHydrogens > 1 && !hExpand)
{
sb.Append(atom.NumOfHydrogens);
}
if (atom.Charge != 0)
{
sb.Append(atom.Charge > 0 ? '+' : '-');
int absCharge = Math.Abs(atom.Charge);
if (absCharge > 1)
{
sb.Append(absCharge);
}
}
if (atom.AtomClass != 0)
{
sb.Append(':').Append(atom.AtomClass);
}
sb.Append(']');
if (hExpand)
{
int h = atom.NumOfHydrogens;
while (h > 1)
{
sb.Append("([H])");
h--;
}
if (h > 0)
{
sb.Append("[H]");
}
}
}
private static IAtom ToSubset(IAtom a)
{
if (a.IsAromatic())
{
return(AtomImpl.AromaticSubset.OfElement(a.Element));
}
else
{
return(AtomImpl.AliphaticSubset.OfElement(a.Element));
}
}
public void Aliphatic_element_n()
{
IAtom a = AtomBuilder.Aliphatic(Element.Nitrogen)
.Build();
Assert.AreEqual(a.Element, Element.Nitrogen);
Assert.AreEqual(a.Isotope, -1);
Assert.AreEqual(a.Charge, 0);
Assert.AreEqual(a.AtomClass, 0);
Assert.AreEqual(a.IsAromatic(), false);
}
public void Create_symbol_IsAromatic_c()
{
IAtom a = AtomBuilder.Create("c")
.Build();
Assert.AreEqual(a.Element, Element.Carbon);
Assert.AreEqual(a.Isotope, -1);
Assert.AreEqual(a.Charge, 0);
Assert.AreEqual(a.AtomClass, 0);
Assert.AreEqual(a.IsAromatic(), true);
}
public void IsAromatic_symbol_n()
{
IAtom a = AtomBuilder.Aromatic("N")
.Build();
Assert.AreEqual(a.Element, Element.Nitrogen);
Assert.AreEqual(a.Isotope, -1);
Assert.AreEqual(a.Charge, 0);
Assert.AreEqual(a.AtomClass, 0);
Assert.AreEqual(a.IsAromatic(), true);
}
public static AtomBuilder FromExisting(IAtom a)
{
if (a == null)
{
throw new ArgumentNullException(nameof(a), "no atom provided");
}
return(new AtomBuilder(a.Element, a.IsAromatic())
.Charge(a.Charge)
.NumOfHydrogens(a.NumOfHydrogens)
.Isotope(a.Isotope)
.AtomClass(a.AtomClass));
}
private static bool Suppressible(IAtom a, int v)
{
if (!a.Subset &&
a.Element.IsOrganic() &&
a.Isotope < 0 &&
a.Charge == 0 &&
a.AtomClass == 0)
{
int h = a.NumOfHydrogens;
if (a.IsAromatic())
{
return(h == a.Element.NumOfAromaticImplicitHydrogens(1 + v));
}
else
{
return(h == a.Element.NumOfImplicitHydrogens(v));
}
}
return(false);
}
/// <summary>
/// Given two atoms which are implicitly connected determine the explicit
/// bond type. The type is 'aromatic' if both atoms are aromatic, if either
/// or both atoms are non-aromatic then the bond type is 'single'.
/// </summary>
/// <param name="u">an atom</param>
/// <param name="v">another atom </param>(connected to u)
/// <returns>the bond type</returns>
public static Bond Type(IAtom u, IAtom v)
{
return(u.IsAromatic() && v.IsAromatic() ? Bond.Aromatic : Bond.Single);
}
