/// <summary>
/// Select the best coordinates
/// </summary>
/// <param name="ps">template points</param>
/// <param name="coords">best coordinates (updated by this method)</param>
/// <param name="macrocycle">the macrocycle</param>
/// <param name="ringset">rest of the ring system</param>
/// <returns>offset into the coordinates</returns>
private static int SelectCoords(IEnumerable <Vector2[]> ps, Vector2[] coords, IRing macrocycle, IRingSet ringset)
{
Debug.Assert(ps.Any());
var winding = new int[coords.Length];
MacroScore best = null;
foreach (var p in ps)
{
var wind = Winding(p, winding);
var score = BestScore(macrocycle, ringset, wind, winding);
if (score.CompareTo(best) < 0)
{
best = score;
Array.Copy(p, 0, coords, 0, p.Length);
}
}
// never null
return(best != null ? best.offset : 0);
}
/// <summary>
/// Select the best scoring template + offset for the given macrocycle.
/// </summary>
/// <param name="macrocycle">macrocycle</param>
/// <param name="ringset">entire ring system</param>
/// <param name="wind">winding of ring CW/CCW</param>
/// <param name="winding">winding of each turn in the ring</param>
/// <returns>the best scoring configuration</returns>
private static MacroScore BestScore(IRing macrocycle, IRingSet ringset, int wind, int[] winding)
{
var numAtoms = macrocycle.Atoms.Count;
var heteroIdxs = new List <int>();
var ringAttachs = new List <IList <int> >();
// hetero atoms
for (int i = 0; i < numAtoms; i++)
{
if (macrocycle.Atoms[i].AtomicNumber != 6)
{
heteroIdxs.Add(i);
}
}
foreach (var other in ringset)
{
if (other == macrocycle)
{
continue;
}
var shared = AtomContainerManipulator.GetIntersection(macrocycle, other);
if (shared.Atoms.Count >= 2 && shared.Atoms.Count <= 4)
{
ringAttachs.Add(GetAttachedInOrder(macrocycle, shared));
}
}
// convex and concave are relative
var convex = wind;
var concave = -wind;
MacroScore best = null;
for (int i = 0; i < winding.Length; i++)
{
// score ring attachs
int nRingClick = 0;
foreach (var ringAttach in ringAttachs)
{
int r1, r2, r3, r4;
switch (ringAttach.Count)
{
case 2:
r1 = (ringAttach[0] + i) % numAtoms;
r2 = (ringAttach[1] + i) % numAtoms;
if (winding[r1] == winding[r2])
{
if (winding[r1] == convex)
{
nRingClick += 5;
}
else
{
nRingClick++;
}
}
break;
case 3:
r1 = (ringAttach[0] + i) % numAtoms;
r2 = (ringAttach[1] + i) % numAtoms;
r3 = (ringAttach[2] + i) % numAtoms;
if (winding[r1] == convex &&
winding[r2] == concave &&
winding[r3] == convex)
{
nRingClick += 5;
}
else if (winding[r1] == concave &&
winding[r2] == convex &&
winding[r3] == concave)
{
nRingClick++;
}
break;
case 4:
r1 = (ringAttach[0] + i) % numAtoms;
r2 = (ringAttach[1] + i) % numAtoms;
r3 = (ringAttach[2] + i) % numAtoms;
r4 = (ringAttach[3] + i) % numAtoms;
if (winding[r1] == convex &&
winding[r2] == concave &&
winding[r3] == concave &&
winding[r4] == convex)
{
nRingClick++;
}
else if (winding[r1] == concave &&
winding[r2] == convex &&
winding[r3] == convex &&
winding[r4] == concave)
{
nRingClick++;
}
break;
}
}
// score hetero atoms in concave positions
int nConcaveHetero = 0;
foreach (var heteroIdx in heteroIdxs)
{
var k = (heteroIdx + i) % numAtoms;
if (winding[k] == concave)
{
nConcaveHetero++;
}
}
int nCorrectStereo = 0;
int nIncorrectStereo = 0;
foreach (var se in macrocycle.StereoElements)
{
if (se.Class == StereoClass.CisTrans)
{
var bond = (IBond)se.Focus;
var beg = bond.Begin;
var end = bond.End;
StereoConfigurations cfg;
if (winding[(macrocycle.Atoms.IndexOf(beg) + i) % numAtoms] ==
winding[(macrocycle.Atoms.IndexOf(end) + i) % numAtoms])
{
cfg = StereoConfigurations.Together;
}
else
{
cfg = StereoConfigurations.Opposite;
}
if (cfg == se.Configure)
{
nCorrectStereo++;
}
else
{
nIncorrectStereo++;
}
}
}
var score = new MacroScore(i, nConcaveHetero, nCorrectStereo, nRingClick);
if (score.CompareTo(best) < 0)
{
best = score;
}
}
return(best);
}
