public void TestCyanoallene()
{
IAtomContainer mol = null;
mol = CDK.SmilesParser.ParseSmiles("C=C=CC#N");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
AddImplicitHydrogens(mol);
CDK.LonePairElectronChecker.Saturate(mol);
Aromaticity.CDKLegacy.Apply(mol);
var acSet = ConjugatedPiSystemsDetector.Detect(mol);
Assert.AreEqual(1, acSet.Count);
IAtomContainer ac1 = acSet[0];
Assert.AreEqual(4, ac1.Atoms.Count);
Assert.AreEqual(3, ac1.Bonds.Count);
for (int i = 0; i < ac1.Atoms.Count; i++)
{
Assert.IsTrue(mol.Contains(ac1.Atoms[i]));
}
for (int i = 0; i < ac1.Bonds.Count; i++)
{
Assert.IsTrue(mol.Contains(ac1.Bonds[i]));
}
}
public void TestDetectNaphtalene()
{
Trace.TraceInformation("Entering testDetectNaphtalene.");
IAtomContainer mol = null;
var filename = "NCDK.Data.CML.naphtalene.cml";
mol = ReadCMLMolecule(filename);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
Aromaticity.CDKLegacy.Apply(mol);
var acSet = ConjugatedPiSystemsDetector.Detect(mol);
Assert.AreEqual(1, acSet.Count);
IAtomContainer ac = acSet[0];
Assert.AreEqual(10, ac.Atoms.Count);
Assert.AreEqual(11, ac.Bonds.Count);
for (int i = 0; i < ac.Atoms.Count; i++)
{
Assert.IsTrue(mol.Contains(ac.Atoms[i]));
}
for (int i = 0; i < ac.Bonds.Count; i++)
{
Assert.IsTrue(mol.Contains(ac.Bonds[i]));
}
}
/// <summary>
/// Returns an IAtomContainer which contains all the atoms and bonds which
/// are involved in ring systems.
/// </summary>
/// <seealso cref="GetAllRings"/>
/// <seealso cref="GetBasicRings"/>
/// <returns>the IAtomContainer as described above</returns>
public IAtomContainer GetCyclicFragmentsContainer()
{
IAtomContainer fragContainer = this.molecule.Builder.NewAtomContainer();
IAtomContainer spt = GetSpanningTree();
for (int i = 0; i < totalEdgeCount; i++)
{
if (!bondsInTree[i])
{
IRing ring = GetRing(spt, molecule.Bonds[i]);
for (int b = 0; b < ring.Bonds.Count; b++)
{
IBond ringBond = ring.Bonds[b];
if (!fragContainer.Contains(ringBond))
{
for (int atomCount = 0; atomCount < ringBond.Atoms.Count; atomCount++)
{
IAtom atom = ringBond.Atoms[atomCount];
if (!fragContainer.Contains(atom))
{
atom.IsInRing = true;
fragContainer.Atoms.Add(atom);
}
}
fragContainer.Bonds.Add(ringBond);
}
}
}
}
return(fragContainer);
}
/// <summary>
/// Adds a bond to this container.
/// </summary>
/// <param name="atom1">the first atom</param>
/// <param name="atom2">the second atom</param>
/// <param name="order">bond order</param>
public static void AddBond(this IAtomContainer mol, IAtom atom1, IAtom atom2, BondOrder order)
{
if (!(mol.Contains(atom1) && mol.Contains(atom2)))
{
throw new InvalidOperationException();
}
IBond bond = mol.Builder.NewBond(atom1, atom2, order);
mol.Bonds.Add(bond);
}
/// <summary>
/// Adds a bond to this container.
/// </summary>
/// <param name="atom1">the first atom</param>
/// <param name="atom2">the second atom</param>
/// <param name="order">bond order</param>
/// <param name="stereo">Stereochemical orientation</param>
/// <returns>The bond added</returns>
public static IBond AddBond(this IAtomContainer mol, IAtom atom1, IAtom atom2, BondOrder order, BondStereo stereo)
{
if (!(mol.Contains(atom1) && mol.Contains(atom2)))
{
throw new InvalidOperationException();
}
var bond = mol.Builder.NewBond(atom1, atom2, order, stereo);
mol.Bonds.Add(bond);
return(bond);
}
public static void RemoveElectronContainer(IReaction reaction, IElectronContainer electrons)
{
var reactants = reaction.Reactants;
for (int i = 0; i < reactants.Count; i++)
{
IAtomContainer mol = reactants[i];
if (mol.Contains(electrons))
{
mol.Remove(electrons);
}
}
var agents = reaction.Reactants;
for (int i = 0; i < agents.Count; i++)
{
var mol = agents[i];
if (mol.Contains(electrons))
{
mol.Remove(electrons);
}
}
var products = reaction.Products;
for (int i = 0; i < products.Count; i++)
{
var mol = products[i];
if (mol.Contains(electrons))
{
mol.Remove(electrons);
}
}
}
public static void RemoveAtomAndConnectedElectronContainers(IReaction reaction, IAtom atom)
{
var reactants = reaction.Reactants;
for (int i = 0; i < reactants.Count; i++)
{
IAtomContainer mol = reactants[i];
if (mol.Contains(atom))
{
mol.RemoveAtom(atom);
}
}
var agents = reaction.Reactants;
for (int i = 0; i < agents.Count; i++)
{
var mol = agents[i];
if (mol.Contains(atom))
{
mol.RemoveAtom(atom);
}
}
var products = reaction.Products;
for (int i = 0; i < products.Count; i++)
{
var mol = products[i];
if (mol.Contains(atom))
{
mol.RemoveAtom(atom);
}
}
}
public void TestPiSystemWithCarbokation()
{
Trace.TraceInformation("Entering testPiSystemWithCarbokation.");
IAtomContainer mol = null;
var filename = "NCDK.Data.MDL.piSystemWithCarbokation.mol";
var ins = ResourceLoader.GetAsStream(filename);
MDLReader reader = new MDLReader(ins);
var chemFile = reader.Read(builder.NewChemFile());
mol = chemFile[0][0].MoleculeSet[0];
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
Aromaticity.CDKLegacy.Apply(mol);
var acSet = ConjugatedPiSystemsDetector.Detect(mol);
Assert.AreEqual(2, acSet.Count);
IAtomContainer ac1 = acSet[0];
Assert.AreEqual(4, ac1.Atoms.Count);
Assert.AreEqual(3, ac1.Bonds.Count);
for (int i = 0; i < ac1.Atoms.Count; i++)
{
Assert.IsTrue(mol.Contains(ac1.Atoms[i]));
}
for (int i = 0; i < ac1.Bonds.Count; i++)
{
Assert.IsTrue(mol.Contains(ac1.Bonds[i]));
}
IAtomContainer ac2 = acSet[0];
Assert.AreEqual(4, ac2.Atoms.Count);
Assert.AreEqual(3, ac2.Bonds.Count);
for (int i = 0; i < ac2.Atoms.Count; i++)
{
Assert.IsTrue(mol.Contains(ac2.Atoms[i]));
}
for (int i = 0; i < ac2.Bonds.Count; i++)
{
Assert.IsTrue(mol.Contains(ac2.Bonds[i]));
}
}
public void TestFusedRingFragments()
{
var ringSearch = new RingSearch(fusedRings);
var fragments = ringSearch.FusedRingFragments().ToReadOnlyList();
Assert.AreEqual(1, fragments.Count);
IAtomContainer fragment = fragments[0];
foreach (var atom in fusedRings.Atoms)
{
Assert.IsTrue(fragment.Contains(atom));
}
foreach (var bond in fusedRings.Bonds)
{
Assert.IsTrue(fragment.Contains(bond));
}
}
/// <summary>
/// Adds a <see cref="ILonePair"/> to this <see cref="IAtom"/>.
/// </summary>
/// <param name="atom">The atom to which the <see cref="ILonePair"/> is added</param>
public static void AddLonePairTo(this IAtomContainer mol, IAtom atom)
{
if (!mol.Contains(atom))
{
throw new InvalidOperationException();
}
var e = mol.Builder.NewLonePair(atom);
mol.LonePairs.Add(e);
}
/// <summary>
/// Adds a <see cref="ISingleElectron"/> to this <see cref="IAtom"/>.
/// </summary>
/// <param name="atom">The atom to which the <see cref="ISingleElectron"/> is added</param>
public static void AddSingleElectronTo(this IAtomContainer mol, IAtom atom)
{
if (!mol.Contains(atom))
{
throw new InvalidOperationException();
}
var e = mol.Builder.NewSingleElectron(atom);
mol.SingleElectrons.Add(e);
}
public void PseuDoAtomReplacement()
{
using (MDLV3000Reader reader = new MDLV3000Reader(GetType().Assembly.GetManifestResourceStream(GetType(), "pseudoAtomReplacement.mol")))
{
IAtomContainer container = reader.Read(builder.NewAtomContainer());
foreach (var atom in container.Bonds[9].Atoms)
{
Assert.IsTrue(container.Contains(atom));
}
}
}
public void TestMakeAtomContainer()
{
var builder = CDK.Builder;
IAtom atom = builder.NewAtom("C");
IAtom exclude = builder.NewAtom("C");
IAtom a1 = builder.NewAtom("C");
IAtom a2 = builder.NewAtom("C");
IBond[] bonds = new IBond[] { builder.NewBond(atom, exclude),
builder.NewBond(a1, a2), builder.NewBond(a1, atom),
builder.NewBond(a2, exclude) };
IAtomContainer part = FragmentUtils.MakeAtomContainer(atom, bonds, exclude);
Assert.AreEqual(3, part.Atoms.Count);
Assert.AreEqual(2, part.Bonds.Count);
Assert.IsTrue(part.Contains(atom));
Assert.IsTrue(part.Contains(a1));
Assert.IsTrue(part.Contains(a2));
Assert.IsFalse(part.Contains(exclude));
Assert.IsTrue(part.Contains(bonds[1]));
Assert.IsTrue(part.Contains(bonds[2]));
}
/// <summary>
/// Set the Flags to atoms and bonds which are not contained in an atomContainer.
/// </summary>
/// <param name="container">Container with the flags</param>
/// <param name="ac">Container to put the flags</param>
/// <param name="number"><see langword="true"/>, if the the flag is true</param>
/// <param name="b">Container with added flags</param>
/// <returns></returns>
private static IAtomContainer SetAntiFlags(IAtomContainer container, IAtomContainer ac, int number, bool b)
{
var bond = ac.Bonds[number];
if (!container.Contains(bond))
{
bond.IsReactiveCenter = b;
bond.Atoms[0].IsReactiveCenter = b;
bond.Atoms[1].IsReactiveCenter = b;
}
else
{
return(null);
}
return(ac);
}
/// Given a list of bonds representing a fragment obtained by splitting the molecule
/// at a bond, we need to create an IAtomContainer from it, containing *one* of the atoms
/// of the splitting bond. In addition, the new IAtomContainer should not contain the
/// splitting bond itself
internal static IAtomContainer MakeAtomContainer(IAtom atom, IEnumerable <IBond> parts, IAtom excludedAtom)
{
IAtomContainer partContainer = atom.Builder.NewAtomContainer();
partContainer.Atoms.Add(atom);
foreach (var aBond in parts)
{
foreach (var bondedAtom in aBond.Atoms)
{
if (!bondedAtom.Equals(excludedAtom) && !partContainer.Contains(bondedAtom))
{
partContainer.Atoms.Add(bondedAtom);
}
}
if (!aBond.Contains(excludedAtom))
{
partContainer.Bonds.Add(aBond);
}
}
return(partContainer);
}
void Main()
{
IAtomContainer queryStructure = null;
IAtomContainer targetStructure = null;
{
#region 1
IAtomContainer query = queryStructure;
IAtomContainer target = targetStructure;
Mappings mappings = Pattern.FindSubstructure(query).MatchAll(target);
#endregion
#region enum_mappings
foreach (int[] p in mappings)
{
for (int i = 0; i < p.Length; i++)
{
// query.Atoms[i] is mapped to target.Atoms[p[i]];
}
}
#endregion
#region stereochemistry
foreach (int[] p in mappings.GetStereochemistry())
{
// ...
}
#endregion
#region unique_matches
foreach (int[] p in mappings.GetUniqueAtoms())
{
// ...
}
foreach (int[] p in mappings.GetUniqueBonds())
{
// ...
}
#endregion
{
#region toarray
int[][] ps = mappings.ToArray();
foreach (int[] p in ps)
{
// ...
}
#endregion
}
{
#region limit_matches
// first ten matches
foreach (int[] p in mappings.Limit(10))
{
// ...
}
// first 10 unique matches
foreach (int[] p in mappings.GetUniqueAtoms().Limit(10))
{
// ...
}
// ensure we don't waste memory and only 'fix' up to 100 unique matches
int[][] ps = mappings.GetUniqueAtoms().Limit(100).ToArray();
#endregion
}
#region all
// first 100 unique matches
Mappings m1 = mappings.GetUniqueAtoms().Limit(100);
// unique matches in the first 100 matches
Mappings m2 = mappings.Limit(100).GetUniqueAtoms();
// first 10 unique matches in the first 100 matches
Mappings m3 = mappings.Limit(100).GetUniqueAtoms().Limit(10);
// number of unique atom matches
int n1 = mappings.CountUnique();
// number of unique atom matches with correct stereochemistry
int n2 = mappings.GetStereochemistry().CountUnique();
#endregion
}
{
#region Filter
IAtomContainer query = queryStructure;
IAtomContainer target = targetStructure;
// obtain only the mappings where the first atom in the query is
// mapped to the first atom in the target
Mappings mappings = Pattern.FindSubstructure(query)
.MatchAll(target)
.Filter(input => input[0] == 0);
#endregion
}
{
#region GetMapping
IAtomContainer query = queryStructure;
IAtomContainer target = targetStructure;
Mappings mappings = Pattern.FindSubstructure(query).MatchAll(target);
// a string that indicates the mapping of atom elements and numbers
IEnumerable <string> strs = mappings.GetMapping(
input =>
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < input.Length; i++)
{
if (i > 0)
{
sb.Append(", ");
}
sb.Append(query.Atoms[i])
.Append(i + 1)
.Append(" -> ")
.Append(target.Atoms[input[i]])
.Append(input[i] + 1);
}
return(sb.ToString());
});
#endregion
}
{
#region ToArray1
IAtomContainer query = queryStructure;
IAtomContainer target = targetStructure;
Pattern pat = Pattern.FindSubstructure(query);
// lazily iterator
foreach (int[] mapping in pat.MatchAll(target))
{
// logic...
}
int[][] mappings = pat.MatchAll(target).ToArray();
// same as lazy iterator but we now can refer to and parse 'mappings'
// to other methods without regenerating the graph match
foreach (int[] mapping in mappings)
{
// logic...
}
#endregion
}
{
#region ToArray2
IAtomContainer query = queryStructure;
IAtomContainer target = targetStructure;
Pattern pat = Pattern.FindSubstructure(query);
// array of the first 5 unique atom mappings
int[][] mappings = pat.MatchAll(target)
.GetUniqueAtoms()
.Limit(5)
.ToArray();
#endregion
}
{
Mappings mappings = null;
#region ToAtomMap
foreach (IDictionary <IAtom, IAtom> map in mappings.ToAtomMap())
{
foreach (KeyValuePair <IAtom, IAtom> e in map)
{
IAtom queryAtom = e.Key;
IAtom targetAtom = e.Value;
}
}
#endregion
}
{
Mappings mappings = null;
#region ToBondMap
foreach (IDictionary <IBond, IBond> map in mappings.ToBondMap())
{
foreach (KeyValuePair <IBond, IBond> e in map)
{
IBond queryBond = e.Key;
IBond targetBond = e.Value;
}
}
#endregion
}
{
IAtomContainer query = queryStructure;
Mappings mappings = null;
int i = 0;
#region ToAtomBondMap
foreach (var map in mappings.ToAtomBondMap())
{
foreach (var e in map)
{
IChemObject queryObj = e.Key;
IChemObject targetObj = e.Value;
}
IAtom matchedAtom = (IAtom)map[query.Atoms[i]];
IBond matchedBond = (IBond)map[query.Bonds[i]];
}
#endregion
}
{
Mappings mappings = null;
#region ToChemObjects
foreach (var obj in mappings.ToChemObjects())
{
if (obj is IAtom)
{
// this atom was 'hit' by the pattern
}
}
#endregion
}
{
Mappings someMappings = null;
#region ToSubstructures
IAtomContainer target = targetStructure;
Mappings mappings = someMappings;
foreach (var mol in mappings.ToSubstructures())
{
foreach (var atom in mol.Atoms)
{
target.Contains(atom); // always true
}
foreach (var atom in target.Atoms)
{
mol.Contains(atom); // not always true
}
}
#endregion
}
{
Mappings someMappings = null;
#region AtLeast
Mappings mappings = someMappings;
if (mappings.AtLeast(5))
{
// set bit flag etc.
}
// are the at least 5 unique matches?
if (mappings.GetUniqueAtoms().AtLeast(5))
{
// set bit etc.
}
#endregion
}
}
private void PlaceBridgedRing(IRing ring, IAtomContainer sharedAtoms, Vector2 sharedAtomsCenter, Vector2 ringCenterVector, double bondLength)
{
IAtom[] bridgeAtoms = GetBridgeAtoms(sharedAtoms);
IAtom bondAtom1 = bridgeAtoms[0];
IAtom bondAtom2 = bridgeAtoms[1];
List <IAtom> otherAtoms = new List <IAtom>();
foreach (IAtom atom in sharedAtoms.Atoms)
{
if (atom != bondAtom1 && atom != bondAtom2)
{
otherAtoms.Add(atom);
}
}
bool snap = ring.GetProperty <bool>(SnapHint, false);
bool swap = snap ? Det(bondAtom1.Point2D.Value, GeometryUtil.Get2DCenter(otherAtoms), bondAtom2.Point2D.Value) < 0
: Det(bondAtom1.Point2D.Value, GeometryUtil.Get2DCenter(otherAtoms), bondAtom2.Point2D.Value) > 0;
if (swap)
{
IAtom tmp = bondAtom1;
bondAtom1 = bondAtom2;
bondAtom2 = tmp;
}
Vector2 bondAtom1Vector = bondAtom1.Point2D.Value;
Vector2 bondAtom2Vector = bondAtom2.Point2D.Value;
Vector2 midPoint = GetMidPoint(bondAtom1Vector, bondAtom2Vector);
Vector2 ringCenter;
double radius = GetNativeRingRadius(ring, bondLength);
double offset = 0;
if (snap)
{
ringCenter = midPoint;
ringCenterVector = GetPerpendicular(bondAtom1Vector, bondAtom2Vector,
new Vector2(midPoint.X - sharedAtomsCenter.X, midPoint.Y - sharedAtomsCenter.Y));
offset = 0;
foreach (IAtom atom in otherAtoms)
{
double dist = Vector2.Distance(atom.Point2D.Value, midPoint);
if (dist > offset)
{
offset = dist;
}
}
}
else
{
ringCenter = sharedAtomsCenter;
}
Vector2.Normalize(ringCenterVector);
ringCenterVector = ringCenterVector * (radius - offset);
ringCenter += ringCenterVector;
bondAtom1Vector -= ringCenter;
bondAtom2Vector -= ringCenter;
int numUnplaced = ring.RingSize - sharedAtoms.Atoms.Count;
double dot = bondAtom2Vector.X * bondAtom1Vector.X + bondAtom2Vector.Y * bondAtom1Vector.Y;
double det = bondAtom2Vector.X * bondAtom1Vector.Y - bondAtom2Vector.Y * bondAtom1Vector.X;
// theta remain/step
double tRemain = Math.Atan2(det, dot);
if (tRemain < 0)
{
tRemain = Math.PI + (Math.PI + tRemain);
}
double tStep = tRemain / (numUnplaced + 1);
Debug.WriteLine($"placeBridgedRing->tRemain: {Vectors.RadianToDegree(tRemain)}");
Debug.WriteLine($"placeBridgedRing->tStep: {Vectors.RadianToDegree(tStep)}");
double startAngle;
startAngle = GeometryUtil.GetAngle(bondAtom1.Point2D.Value.X - ringCenter.X, bondAtom1.Point2D.Value.Y - ringCenter.Y);
IAtom currentAtom = bondAtom1;
IBond currentBond = sharedAtoms.GetConnectedBonds(currentAtom).First();
List <IAtom> atoms = new List <IAtom>();
for (int i = 0; i < ring.Bonds.Count; i++)
{
currentBond = ring.GetNextBond(currentBond, currentAtom);
currentAtom = currentBond.GetOther(currentAtom);
if (!sharedAtoms.Contains(currentAtom))
{
atoms.Add(currentAtom);
}
}
#if DEBUG
Debug.WriteLine($"{nameof(PlaceBridgedRing)}->atomsToPlace: {AtomPlacer.ListNumbers(Molecule, atoms)}");
Debug.WriteLine($"{nameof(PlaceBridgedRing)}->startAngle: {Vectors.RadianToDegree(startAngle)}");
Debug.WriteLine($"{nameof(PlaceBridgedRing)}->tStep: {Vectors.RadianToDegree(tStep)}");
#endif
AtomPlacer.PopulatePolygonCorners(atoms, ringCenter, startAngle, -tStep, radius);
}
/// <summary>
/// Gets if neighbours of an atom are in an atom container.
/// </summary>
/// <param name="neighs">atoms</param>
/// <param name="ac">container</param>
/// <returns>The boolean result</returns>
private static bool IsANeighboorsInAnAtomContainer(IEnumerable <IAtom> neighs, IAtomContainer ac)
{
int count = neighs.Where(neigh => ac.Contains(neigh)).Count();
return(count > 0);
}
