/// <summary>
/// Tries to saturate a bond by increasing its bond orders by 1.0.
/// </summary>
/// <returns>true if the bond could be increased</returns>
public bool SaturateByIncreasingBondOrder(IBond bond, IAtomContainer atomContainer)
{
var atoms = BondManipulator.GetAtomArray(bond);
var atom = atoms[0];
var partner = atoms[1];
Debug.WriteLine(" saturating bond: ", atom.Symbol, "-", partner.Symbol);
var atomTypes1 = structgenATF.GetAtomTypes(atom.Symbol);
var atomTypes2 = structgenATF.GetAtomTypes(partner.Symbol);
foreach (var aType1 in atomTypes1)
{
Debug.WriteLine($" considering atom type: {aType1}");
if (CouldMatchAtomType(atomContainer, atom, aType1))
{
Debug.WriteLine($" trying atom type: {aType1}");
foreach (var aType2 in atomTypes2)
{
Debug.WriteLine($" considering partner type: {aType1}");
if (CouldMatchAtomType(atomContainer, partner, aType2))
{
Debug.WriteLine($" with atom type: {aType2}");
if (BondManipulator.IsLowerOrder(bond.Order, aType2.MaxBondOrder) &&
BondManipulator.IsLowerOrder(bond.Order, aType1.MaxBondOrder))
{
bond.Order = BondManipulator.IncreaseBondOrder(bond.Order);
Debug.WriteLine($"Bond order now {bond.Order}");
return(true);
}
}
}
}
}
return(false);
}
/// <summary>
/// Saturate atom by adjusting its bond orders.
/// This method is known to fail, especially on pyrrole-like compounds.
/// Consider using <see cref="Smiles.DeduceBondSystemTool"/>, which should work better
/// </summary>
public bool NewSaturate(IBond bond, IAtomContainer atomContainer)
{
var atoms = BondManipulator.GetAtomArray(bond);
var atom = atoms[0];
var partner = atoms[1];
Debug.WriteLine($" saturating bond: {atom.Symbol}-{partner.Symbol}");
var atomTypes1 = structgenATF.GetAtomTypes(atom.Symbol);
var atomTypes2 = structgenATF.GetAtomTypes(partner.Symbol);
bool bondOrderIncreased = true;
while (bondOrderIncreased && !IsSaturated(bond, atomContainer))
{
Debug.WriteLine("Can increase bond order");
bondOrderIncreased = false;
foreach (var aType1 in atomTypes1)
{
if (bondOrderIncreased)
{
break;
}
Debug.WriteLine($" considering atom type: {aType1}");
if (CouldMatchAtomType(atomContainer, atom, aType1))
{
Debug.WriteLine($" trying atom type: {aType1}");
foreach (var aType2 in atomTypes2)
{
if (bondOrderIncreased)
{
break;
}
Debug.WriteLine($" considering partner type: {aType1}");
if (CouldMatchAtomType(atomContainer, partner, aType2))
{
Debug.WriteLine($" with atom type: {aType2}");
if (!BondManipulator.IsLowerOrder(bond.Order, aType2.MaxBondOrder) ||
!BondManipulator.IsLowerOrder(bond.Order, aType1.MaxBondOrder))
{
Debug.WriteLine("Bond order not increased: atoms has reached (or exceeded) maximum bond order for this atom type");
}
else if (BondManipulator.IsLowerOrder(bond.Order, aType2.MaxBondOrder) &&
BondManipulator.IsLowerOrder(bond.Order, aType1.MaxBondOrder))
{
BondManipulator.IncreaseBondOrder(bond);
Debug.WriteLine($"Bond order now {bond.Order}");
bondOrderIncreased = true;
}
}
}
}
}
}
return(IsSaturated(bond, atomContainer));
}
/// <summary>
/// Returns whether a bond is saturated. A bond is saturated if
/// <b>both</b> Atoms in the bond are saturated.
/// </summary>
public bool IsSaturated(IBond bond, IAtomContainer atomContainer)
{
var atoms = BondManipulator.GetAtomArray(bond);
bool isSaturated = true;
for (int i = 0; i < atoms.Length; i++)
{
isSaturated = isSaturated && IsSaturated(atoms[i], atomContainer);
}
return(isSaturated);
}
/// <summary>
/// Returns whether a bond is unsaturated. A bond is unsaturated if
/// <b>all</b> Atoms in the bond are unsaturated.
/// </summary>
public bool IsUnsaturated(IBond bond, IAtomContainer atomContainer)
{
Debug.WriteLine($"isBondUnsaturated?: {bond}");
var atoms = BondManipulator.GetAtomArray(bond);
var isUnsaturated = true;
for (int i = 0; i < atoms.Length && isUnsaturated; i++)
{
isUnsaturated = isUnsaturated && !IsSaturated(atoms[i], atomContainer);
}
Debug.WriteLine($"Bond is unsaturated?: {isUnsaturated}");
return(isUnsaturated);
}
public Result Calculate(IBond bond)
{
if (bond.Atoms.Count != 2)
{
throw new CDKException("Only 2-center bonds are considered");
}
var atoms = BondManipulator.GetAtomArray(bond);
var factory = CDK.IsotopeFactory;
return(new Result(Math.Abs(bond.Begin.AtomicNumber - bond.End.AtomicNumber)));
}
/// <summary>
/// Returns whether a bond is saturated. A bond is saturated if
/// <b>both</b> Atoms in the bond are saturated.
/// </summary>
public bool IsSaturated(IBond bond, IAtomContainer atomContainer)
{
Debug.WriteLine($"isBondSaturated?: {bond}");
var atoms = BondManipulator.GetAtomArray(bond);
bool isSaturated = true;
for (int i = 0; i < atoms.Length; i++)
{
Debug.WriteLine($"IsSaturated(Bond, AC): atom I={i}");
isSaturated = isSaturated && IsSaturated(atoms[i], atomContainer);
}
Debug.WriteLine($"IsSaturated(Bond, AC): result={isSaturated}");
return(isSaturated);
}
/// <summary>
/// This makes sourceAtom map of matching atoms out of sourceAtom map of matching bonds as produced by the Get(Subgraph|Ismorphism)Map methods.
/// </summary>
/// <param name="rMapList">The list produced by the getMap method.</param>
/// <param name="graph1">first molecule. Must not be an IQueryAtomContainer.</param>
/// <param name="graph2">second molecule. May be an IQueryAtomContainer.</param>
/// <returns>The mapping found projected on graph1. This is sourceAtom List of CDKRMap objects containing Ids of matching atoms.</returns>
private static IReadOnlyList <IReadOnlyList <CDKRMap> > MakeAtomsMapOfBondsMap(IReadOnlyList <CDKRMap> rMapList, IAtomContainer graph1, IAtomContainer graph2)
{
if (rMapList == null)
{
return(null);
}
IReadOnlyList <IReadOnlyList <CDKRMap> > result = null;
if (rMapList.Count == 1)
{
result = MakeAtomsMapOfBondsMapSingleBond(rMapList, graph1, graph2);
}
else
{
List <CDKRMap> resultLocal = new List <CDKRMap>();
for (int i = 0; i < rMapList.Count; i++)
{
IBond qBond = graph1.Bonds[rMapList[i].Id1];
IBond tBond = graph2.Bonds[rMapList[i].Id2];
IAtom[] qAtoms = BondManipulator.GetAtomArray(qBond);
IAtom[] tAtoms = BondManipulator.GetAtomArray(tBond);
for (int j = 0; j < 2; j++)
{
var bondsConnectedToAtom1j = graph1.GetConnectedBonds(qAtoms[j]);
foreach (var bondConnectedToAtom1j in bondsConnectedToAtom1j)
{
if (bondConnectedToAtom1j != qBond)
{
IBond testBond = bondConnectedToAtom1j;
foreach (var rMap in rMapList)
{
IBond testBond2;
if ((rMap).Id1 == graph1.Bonds.IndexOf(testBond))
{
testBond2 = graph2.Bonds[(rMap).Id2];
for (int n = 0; n < 2; n++)
{
var bondsToTest = graph2.GetConnectedBonds(tAtoms[n]);
if (bondsToTest.Contains(testBond2))
{
CDKRMap map;
if (j == n)
{
map = new CDKRMap(graph1.Atoms.IndexOf(qAtoms[0]),
graph2.Atoms.IndexOf(tAtoms[0]));
}
else
{
map = new CDKRMap(graph1.Atoms.IndexOf(qAtoms[1]),
graph2.Atoms.IndexOf(tAtoms[0]));
}
if (!resultLocal.Contains(map))
{
resultLocal.Add(map);
}
CDKRMap map2;
if (j == n)
{
map2 = new CDKRMap(graph1.Atoms.IndexOf(qAtoms[1]),
graph2.Atoms.IndexOf(tAtoms[1]));
}
else
{
map2 = new CDKRMap(graph1.Atoms.IndexOf(qAtoms[0]),
graph2.Atoms.IndexOf(tAtoms[1]));
}
if (!resultLocal.Contains(map2))
{
resultLocal.Add(map2);
}
}
}
}
}
}
}
}
}
result = new List <IReadOnlyList <CDKRMap> >
{
resultLocal
};
}
return(result);
}
