public void FillAlignedSequencesWithDifferentCountTest()
{
// AACGCTAG
// ATCCTAG
var sequence1 =
new Sequence(
new[]
{
Nucleotide.A, Nucleotide.A, Nucleotide.C, Nucleotide.G, Nucleotide.C, Nucleotide.T,
Nucleotide.A, Nucleotide.G
},
1);
var sequence2 =
new Sequence(
new[]
{
Nucleotide.A, Nucleotide.T, Nucleotide.C, Nucleotide.C, Nucleotide.T, Nucleotide.A,
Nucleotide.G
},
2);
var estimator = new OperationDistanceEstimator(4, 2, 0, 1);
var multipleAlignment1 = new MultipleAlignment(1, new[] { sequence1 }, estimator);
var multipleAlignment2 = new MultipleAlignment(2, new[] { sequence2 }, estimator);
var newMultipleAlignment = new MultipleAlignment(3, multipleAlignment1, multipleAlignment2);
var algorithm = new MultipleAlignmentAlgorithm(estimator);
var groupAlgorithm = new GroupAlignmentAlgorithm(estimator);
algorithm.FillAlignedSequences(newMultipleAlignment, groupAlgorithm.GeneratePairAlignmentsMap(newMultipleAlignment));
}
/// <summary>
/// The generate method.
/// </summary>
/// <param name="alignment">The pair alignment.</param>
public void FillProfilesTable(MultipleAlignment alignment)
{
var firstProfiles = alignment.First.Profiles;
var secondProfiles = alignment.Second.Profiles;
alignment.ProfilesTable = new ProfilesTable();
for (var i = 0; i < firstProfiles.Count; i++)
{
for (var j = 0; j < secondProfiles.Count; ++j)
{
alignment.ProfilesTable.Add(new Index(i, j), this.GenerateDynamicTable(firstProfiles[i], secondProfiles[j]));
}
}
}
/// <summary>
/// The generate method.
/// </summary>
/// <param name="alignment">The multiple alignment.</param>
public void FillAlignedSequences(MultipleAlignment alignment, Dictionary<Index, PairAlignment> pairsMap)
{
if (alignment.First == null || alignment.Second == null)
{
return;
}
alignment.AlignedSequences = this.GenerateAlignedSequences(alignment);
alignment.Size =
alignment.First.Size +
alignment.Second.Size +
alignment.ProfilesTable.Min(p => p.Value[new Index(p.Value.First.Count, p.Value.Second.Count)].Distance);
var pairsFromFirstAndSecond = (from m in alignment.First
from m2 in alignment.Second
select new Index(m.Id.Value, m2.Id.Value)).ToList();
alignment.Diameter = new[]
{
alignment.First.Diameter,
alignment.Second.Diameter,
pairsFromFirstAndSecond.Select(index => pairsMap[index].Distance).Max()
}.Max();
}
/// <summary>
/// The fill group tree node.
/// </summary>
/// <param name="nodes">The nodes.</param>
/// <param name="multipleAlignment">The multiple alignment.</param>
private void FillGroupTreeNode(TreeNodeCollection nodes, MultipleAlignment multipleAlignment)
{
var newNode = new TreeNode();
var first = multipleAlignment.First;
var second = multipleAlignment.Second;
if (!((first == null || first.Count == 0) && (second == null || second.Count == 0)))
{
newNode.Text = string.Format("(D = {0}, S = {1})", multipleAlignment.Diameter, multipleAlignment.Size);
this.FillGroupTreeNode(newNode.Nodes, multipleAlignment.Second);
this.FillGroupTreeNode(newNode.Nodes, multipleAlignment.First);
}
else
{
newNode.Text = string.Format("{0} ({1})", multipleAlignment[0].ToString(), multipleAlignment.Id);
newNode.ImageKey = "dna-icon.png";
newNode.SelectedImageKey = "dna-icon.png";
}
newNode.Tag = multipleAlignment.Id;
nodes.Add(newNode);
}
/// <summary>
/// The fill group tree.
/// </summary>
/// <param name="multipleAlignment">The multiple alignment.</param>
private void FillGroupTree(MultipleAlignment multipleAlignment)
{
this.groupTree.BeginUpdate();
this.groupTree.Nodes.Clear();
this.FillGroupTreeNode(this.groupTree.Nodes, multipleAlignment);
this.groupTree.ExpandAll();
this.groupTree.EndUpdate();
}
/// <summary>
/// The dynamic table fill.
/// </summary>
/// <param name="alignment">The group alignment.</param>
/// <param name="newGroup">The new group.</param>
public void UpdateCondensateMap(GroupAlignment alignment, MultipleAlignment newGroup)
{
// clean parent elements from condensate map
var removed = alignment.CondensateMap
.Where(item => item.Key.Item1 == newGroup.First.Id || item.Key.Item2 == newGroup.First.Id ||
item.Key.Item1 == newGroup.Second.Id || item.Key.Item2 == newGroup.Second.Id)
.ToList();
foreach (var keyValuePair in removed)
{
alignment.CondensateMap.Remove(keyValuePair.Key);
}
// except the diagonal element
foreach (var group1 in alignment.Groups.Where(a => a.Id != newGroup.Id))
{
MultipleAlignment m;
if (group1.Diameter < newGroup.Diameter
|| (group1.Diameter == newGroup.Diameter && group1.Size < newGroup.Size))
{
m = new MultipleAlignment(alignment.GroupsCounter, group1, newGroup);
}
else
{
m = new MultipleAlignment(alignment.GroupsCounter, newGroup, group1);
}
alignment.GroupsCounter++;
this.MultipleAlignmentAlgorithm.FillAlignedSequences(m, alignment.PairAlignmentsMap);
alignment.CondensateMap[new Index(group1.Id, newGroup.Id)] = m;
alignment.CondensateMap[new Index(newGroup.Id, group1.Id)] = m;
}
}
/// <summary>
/// The dynamic table fill.
/// </summary>
/// <param name="alignment">The group alignment.</param>
public void InitializeCondensateMap(GroupAlignment alignment)
{
if (alignment.PairAlignmentsMap == null || !alignment.PairAlignmentsMap.Any())
{
this.FillPairAlignmentsMap(alignment);
}
if (alignment.Groups == null || !alignment.Groups.Any())
{
this.InitializeGroups(alignment);
}
var map = new Dictionary<Index, MultipleAlignment>();
foreach (var group1 in alignment.Groups)
{
// except the diagonal elements and filled cells (the table is been filling for symmetrical elements in one step)
foreach (var group2 in alignment.Groups.Where(a => a.Id != group1.Id && !map.ContainsKey(new Index(group1.Id, a.Id))))
{
var m = new MultipleAlignment(alignment.GroupsCounter, group1, group2);
alignment.GroupsCounter++;
this.MultipleAlignmentAlgorithm.FillAlignedSequences(m, alignment.PairAlignmentsMap);
map[new Index(group1.Id, group2.Id)] = m;
map[new Index(group2.Id, group1.Id)] = m;
}
}
alignment.CondensateMap = map;
}
/// <summary>
/// The generate aligned.
/// </summary>
/// <param name="alignment">The alignment.</param>
/// <param name="table">The dynamic table.</param>
/// <param name="way">The way in dynamic table</param>
/// <returns>The aligned sequence variants.</returns>
public MultipleSequence GenerateAlignedSequence(MultipleAlignment alignment, ProfileTableItem table, List<Index> way)
{
var sequence = new MultipleSequence();
for (var i = 1; i < way.Count; i++)
{
var pred = way[i - 1];
var cur = way[i];
var ii = cur.Item1 - 1; // in sequence
var jj = cur.Item2 - 1; // in sequence
if (pred.Item1.Equals(cur.Item1))
{
var secondSequence = alignment.Second.AlignedSequences[table.Second.Id];
sequence.Add(new Column(Column.GetClearColumn(alignment.First.Count), secondSequence[jj]));
}
else if (pred.Item2.Equals(cur.Item2))
{
var firstSequence = alignment.First.AlignedSequences[table.First.Id];
sequence.Add(new Column(firstSequence[ii], Column.GetClearColumn(alignment.Second.Count)));
}
else
{
var firstSequence = alignment.First.AlignedSequences[table.First.Id];
var secondSequence = alignment.Second.AlignedSequences[table.Second.Id];
sequence.Add(new Column(firstSequence[ii], secondSequence[jj]));
}
}
return sequence;
}
/// <summary>
/// The generate aligned.
/// </summary>
/// <param name="alignment">The alignment.</param>
/// <returns>The aligned sequence variants.</returns>
public List<MultipleSequence> GenerateAlignedSequences(MultipleAlignment alignment)
{
if (alignment.ProfilesTable.Count == 0)
{
this.FillProfilesTable(alignment);
}
var minDistance =
alignment.ProfilesTable.Min(p => p.Value[new Index(p.Value.First.Count, p.Value.Second.Count)].Distance);
var optimalDynamicTables =
alignment.ProfilesTable.Where(
p => p.Value[new Index(p.Value.First.Count, p.Value.Second.Count)].Distance.IsEqualTo(minDistance)).Select(item => item.Value).ToList();
return (from table in optimalDynamicTables
let ways = this.GenerateGraphWays(table)
from way in ways
select this.GenerateAlignedSequence(alignment, table, way)).ToList();
}
