private static Dictionary <string, Dictionary <string, int> > CreateMerStringToOriginalAA0PositionToCount(int merLength, TextWriter textWriterForWarnings, Dictionary <string, AASeq> caseToCompressedAASeq) { Dictionary <string, Dictionary <string, int> > merStringToOriginalAA0PositionToCount = new Dictionary <string, Dictionary <string, int> >(); foreach (string caseId in caseToCompressedAASeq.Keys) { AASeq aaSeq = caseToCompressedAASeq[caseId]; Set <string> SeenIt = new Set <string>(); foreach (AASeq mer in aaSeq.SubSeqEnumeration(merLength)) { if (mer.Ambiguous) { continue; } string merString = mer.ToString(); if (SeenIt.Contains(merString)) { textWriterForWarnings.WriteLine("Warning: Mer '{0}' appears again in case '{1}'", merString, caseId); } SeenIt.AddNewOrOld(merString); string originalAA1Position = mer.OriginalAA1Position(0); Dictionary <string, int> originalAA0PositionToCount = merStringToOriginalAA0PositionToCount.GetValueOrDefault(merString); originalAA0PositionToCount[originalAA1Position] = 1 + originalAA0PositionToCount.GetValueOrDefault(originalAA1Position); } } return(merStringToOriginalAA0PositionToCount); }
public IEnumerable <AASeq> SubSeqEnumeration(int merLength) { for (int startIndex = 0; startIndex <= Sequence.Count - merLength; ++startIndex) { AASeq aaSeqOut = SubSeqAA0Pos(startIndex, merLength); yield return(aaSeqOut); } }
static public AASeq GetInstance(string aaSeqAsString, MixtureSemantics mixtureSemantics, int offset) { AASeq aaSeq = new AASeq(aaSeqAsString, mixtureSemantics, offset); //aaSeq.Sequence = aaSeq.CreateCharSetList(aaSeqAsString); //aaSeq.Offset = offset; return(aaSeq); }
public bool TrySubSeqAA0Pos(int aa0Pos, int merLength, out AASeq aaSeq) { if (aa0Pos < 0 || aa0Pos + merLength > this.Sequence.Count) { aaSeq = null; return(false); } aaSeq = SubSeqAA0Pos(aa0Pos, merLength); return(true); }
static public AASeq GetInstance(string aaSeqAsString, List <string> originalAA1PositionTable, MixtureSemantics mixtureSemantics) { Helper.CheckCondition(null != originalAA1PositionTable, "must give a position table"); AASeq aaSeq = new AASeq(mixtureSemantics); aaSeq.Sequence = aaSeq.CreateCharSetList(aaSeqAsString); Helper.CheckCondition(aaSeq.Count == originalAA1PositionTable.Count, "aaSeq and position table must be same length"); aaSeq._originalAA1PositionTableOrNull = originalAA1PositionTable; return(aaSeq); }
//public void CreateSparseFile(string outputFileName, bool keepOneValueVariables) //{ // CreateSparseFile(outputFileName, keepOneValueVariables); //} private Dictionary <string, AASeq> RemoveDeletesAndStopsFromData(bool stopOnStop, TextWriter textWriter) { Dictionary <string, AASeq> compressedDictionary = new Dictionary <string, AASeq>(); foreach (KeyValuePair <string, AASeq> caseIdAndAASeq in _caseIdToAASeq) { AASeq compressedAASeq = AASeq.GetCompressedInstance(caseIdAndAASeq.Key, caseIdAndAASeq.Value, stopOnStop, textWriter); compressedDictionary.Add(caseIdAndAASeq.Key, compressedAASeq); } return(compressedDictionary); }
public IEnumerable <string> SparseLineMerEnumeration(bool keepOneValueVariables, int merLength) { if (_caseIdToAASeq.Count == 0) { Debug.Assert(SequenceLengthOrNull == null); // real assert yield break; } Helper.CheckCondition(SequenceLengthOrNull != null, "This converter to sparse assumes all sequences have the same length"); Dictionary <string, AASeq> caseToCompressedAASeq = RemoveDeletesAndStopsFromData(false, Console.Error); foreach (string mer in EveryUnambiguousStopFreeMer(merLength, caseToCompressedAASeq)) { Regex merAsRegex = AASeq.CreateMerRegex(mer); //!!!look for similar code elsewhere foreach (string protein in EveryProtein()) { Set <bool> valueSet = Set <bool> .GetInstance(); Dictionary <string, bool> caseToVal = new Dictionary <string, bool>(); foreach (string caseId in caseToCompressedAASeq.Keys) { AASeq aaSeq = caseToCompressedAASeq[caseId]; Helper.CheckCondition(aaSeq.MixtureSemantics == MixtureSemantics.Uncertainty, "Code does not expect Mixture semantics"); bool?containsOrNull = aaSeq.ContainsMer(mer, merAsRegex, protein); if (null == containsOrNull) { continue; } else if ((bool)containsOrNull) { caseToVal.Add(caseId, true); valueSet.AddNewOrOld(true); } else { caseToVal.Add(caseId, false); valueSet.AddNewOrOld(false); } } if (keepOneValueVariables || valueSet.Count == 2) { foreach (KeyValuePair <string, bool> caseIdAndVal in caseToVal) { string variableName = protein + "@" + mer; yield return(Helper.CreateTabString( variableName, caseIdAndVal.Key, caseIdAndVal.Value ? 1 : 0)); } } } } }
public override bool Equals(object obj) { AASeq other = obj as AASeq; if (other == null) { return(false); } else { return(ToString() == other.ToString()); } }
// /* // 1189MB MEPVDPNLEPWNHPGSQPKTPCTNCYCKHCSYHCLVCFQTKGLGISYGRK // J112MA MEPVDPNLEPWNHPGSQPITACNKCYCKYCSYHCLVCFQTKGLGISYGRK // 1157M3M MEPVDPNLEPWNHPGSQPKTPCNKCYCKHCSYHCLVCFQTKGLGISYGRK // 1195MB MEPVDPNLEPWNHPGSQPKTPCNKCYCKYCSYHCLVCFQTKGLGISYGRK // */ static public CaseIdToAASeq GetInstance(TextReader textReader, MixtureSemantics mixtureSemantics, int offset) { CaseIdToAASeq caseIdToAASeq = CaseIdToAASeq.GetInstance(); foreach (Dictionary <string, string> row in SpecialFunctions.TabFileTable(textReader, "cid\taaSeq", false)) { string caseId = row["cid"]; //!!!const string aaSeqAsString = row["aaSeq"]; //!!!const AASeq aaSeq = AASeq.GetInstance(aaSeqAsString, mixtureSemantics, offset); caseIdToAASeq.Add(caseId, aaSeq); } return(caseIdToAASeq); }
//static public CaseIdToAASeq GetInstance(TextReader textReader, bool mixture) //{ // return GetInstance(textReader, mixture, 0); //} public void Add(string caseId, AASeq aaSeq) { Helper.CheckCondition(!_caseIdToAASeq.ContainsKey(caseId), string.Format("caseId {0} appears more than once", caseId)); //!!!1205x if (null == SequenceLengthOrNull) { SequenceLengthOrNull = aaSeq.Count; } if (SequenceLengthOrNull != aaSeq.Count) { Console.Error.WriteLine("Warning: Not all amino acid sequences are of the same length"); } _caseIdToAASeq.Add(caseId, aaSeq); }
public void SplitOnProtein(string niceName, string outputDirectory) { Debug.WriteLine(niceName); Dictionary <string, Dictionary <string, string> > proteinToCaseIdToSequence = new Dictionary <string, Dictionary <string, string> >(); foreach (string caseId in _caseIdToAASeq.Keys) { AASeq aaSeq = _caseIdToAASeq[caseId]; string previousProtein = null; Dictionary <string, StringBuilder> proteinToSequence = new Dictionary <string, StringBuilder>(); for (int aa0Pos = 0; aa0Pos < (int)SequenceLengthOrNull; ++aa0Pos) { string posName = aaSeq.OriginalAA1Position(aa0Pos); string[] posParts = posName.Split('@'); string protein = posParts[0]; StringBuilder sequence = proteinToSequence.GetValueOrDefault(protein); if (previousProtein != protein) { Helper.CheckCondition(sequence.Length == 0, "Expect proteins to be contintiguous"); previousProtein = protein; } Set <char> strainAASet = aaSeq[aa0Pos]; sequence.Append(AASeq.AaAsString(strainAASet)); } foreach (string protein in proteinToSequence.Keys) { Dictionary <string, string> caseIdToSequence = proteinToCaseIdToSequence.GetValueOrDefault(protein); caseIdToSequence.Add(caseId, proteinToSequence[protein].ToString()); } } foreach (string protein in proteinToCaseIdToSequence.Keys) { string outputFileName = string.Format(@"{0}\{1}.{2}.aaSeq.txt", outputDirectory, protein, niceName); using (TextWriter textWriter = File.CreateText(outputFileName)) { textWriter.WriteLine("cid\taaSeq"); //!!!const Dictionary <string, string> caseIdToSequence = proteinToCaseIdToSequence[protein]; foreach (string caseId in caseIdToSequence.Keys) { textWriter.WriteLine(Helper.CreateTabString(caseId, caseIdToSequence[caseId])); } } } }
public static NamedSequence GetConsensus(List <NamedSequence> seqs) { int len = -1; //StringBuilder consensusSeq = new StringBuilder(); List <AASeq> aaSeqs = new List <AASeq>(); bool isDna = seqs[0].IsDna(); foreach (NamedSequence seq in seqs) { AASeq aaSeq = isDna ? DnaSeq.GetInstance(seq.Sequence, MixtureSemantics.Uncertainty) : AASeq.GetInstance(seq.Sequence, MixtureSemantics.Uncertainty); len = Math.Max(len, aaSeq.Count); //if (len < 0) //{ // len = aaSeq.Count; //} //else //{ // Helper.CheckCondition(len == aaSeq.Count, String.Format("Sequence {0} is a different length from previous sequences", seq.Name)); //} aaSeqs.Add(aaSeq); } //for (int i = 0; i < len; i++) //{ // Dictionary<string, int> charToCount = new Dictionary<string, int>(); // KeyValuePair<string, int> currentConsensus = new KeyValuePair<string, int>("z", -1); // foreach (AASeq aaSeq in aaSeqs) // { // if (i < aaSeq.Count) // { // string residue = aaSeq.SubSeqAA0Pos(i, 1).ToString(); // charToCount[residue] = SpecialFunctions.GetValueOrDefault(charToCount, residue) + 1; // if (charToCount[residue] > currentConsensus.Value) // { // currentConsensus = new KeyValuePair<string, int>(residue, charToCount[residue]); // } // } // } // consensusSeq.Append(currentConsensus.Key); //} AASeq consensusAaSeq = GetAaSeqConsensus(aaSeqs); NamedSequence consensus = new NamedSequence("consensus", consensusAaSeq.ToString()); return(consensus); }
public AASeq SubSeqAA0Pos(int aa0Pos, int merLength, bool skipDelete) { List <Set <char> > subSequence = new List <Set <char> >(); AASeq aaSeqOut = new AASeq(MixtureSemantics); aaSeqOut.Sequence = subSequence; aaSeqOut._originalAA1PositionTableOrNull = new List <string>(); Debug.Assert(aaSeqOut.Offset == 0); // real assert for (int aa0 = aa0Pos; aa0 < aa0Pos + merLength; ++aa0) { Set <char> charSet = Sequence[aa0]; if (!skipDelete || !AASeq.Delete.Equals(charSet)) { string originalAA1Position = OriginalAA1Position(aa0); aaSeqOut._originalAA1PositionTableOrNull.Add(originalAA1Position); subSequence.Add(charSet); } } return(aaSeqOut); }
public void TriplesAppend(ref Set <string> seenTriple, ref Dictionary <string, List <string> > proteinToTripleList) { AASeq aaSeq = GetFirstAASeq(); for (int aa0Pos = 0; aa0Pos < (int)SequenceLengthOrNull; ++aa0Pos) { string posName = aaSeq.OriginalAA1Position(aa0Pos); string[] posParts = posName.Split('@'); string protein = posParts[0]; string hxb2Pos = posParts[2]; string triple = Helper.CreateTabString(protein, hxb2Pos); if (!seenTriple.Contains(triple)) { seenTriple.AddNew(triple); List <string> tripleList = proteinToTripleList.GetValueOrDefault(protein); tripleList.Add(triple); } } }
public IEnumerable <AASeq> BlowOut() { foreach (List <char> possibleSeq in SpecialFunctions.EveryCombination <char>(this.Sequence)) { List <Set <char> > subSequence = new List <Set <char> >(); AASeq aaSeqOut = new AASeq(MixtureSemantics); aaSeqOut.Sequence = subSequence; aaSeqOut._originalAA1PositionTableOrNull = new List <string>(); Debug.Assert(aaSeqOut.Offset == 0); // real assert for (int aa0 = 0; aa0 < Count; ++aa0) { Set <char> charSet = Set <char> .GetInstance(possibleSeq[aa0]); Helper.CheckCondition(!AASeq.Delete.Equals(charSet), "'delete' not expected"); string originalAA1Position = OriginalAA1Position(aa0); aaSeqOut._originalAA1PositionTableOrNull.Add(originalAA1Position); subSequence.Add(charSet); } yield return(aaSeqOut); } }
private Dictionary <string, bool> FindMerValues(string merAsString, Dictionary <string, AASeq> caseToCompressedAASeq, out Dictionary <bool, int> valueToNonZeroCount) { Regex merAsRegex = AASeq.CreateMerRegex(merAsString); Dictionary <string, bool> merValues = new Dictionary <string, bool>(); valueToNonZeroCount = new Dictionary <bool, int>(); foreach (KeyValuePair <string, AASeq> caseIdAndCompressedAASeq in caseToCompressedAASeq) { string caseId = caseIdAndCompressedAASeq.Key; AASeq compressedAASeq = caseIdAndCompressedAASeq.Value; bool?containsMer = compressedAASeq.ContainsMer(merAsString, merAsRegex); if (null != containsMer) { merValues.Add(caseId, (bool)containsMer); valueToNonZeroCount[(bool)containsMer] = 1 + valueToNonZeroCount.GetValueOrDefault((bool)containsMer); } } return(merValues); }
public static AASeq GetAaSeqConsensus(List <AASeq> aaSeqs) { int len = -1; StringBuilder consensusSeq = new StringBuilder(); foreach (AASeq seq in aaSeqs) { len = Math.Max(len, seq.Count); } for (int pos0 = 0; pos0 < len; pos0++) { consensusSeq.Append(AASeq.CountAasAtPos(aaSeqs, pos0)[0].Key); } //for (int i = 0; i < len; i++) //{ // Dictionary<string, int> charToCount = new Dictionary<string, int>(); // KeyValuePair<string, int> currentConsensus = new KeyValuePair<string, int>("z", -1); // foreach (AASeq aaSeq in aaSeqs) // { // if (i < aaSeq.Count) // { // string residue = aaSeq.SubSeqAA0Pos(i, 1).ToString(); // charToCount[residue] = charToCount.GetValueOrDefault(residue) + 1; // if (charToCount[residue] > currentConsensus.Value) // { // currentConsensus = new KeyValuePair<string, int>(residue, charToCount[residue]); // } // } // } // consensusSeq.Append(currentConsensus.Key); //} AASeq consensus = AASeq.GetInstance(consensusSeq.ToString(), MixtureSemantics.Uncertainty); //NamedSequence consensus = new NamedSequence("consensus", consensusSeq.ToString()); return(consensus); }
static public AASeq GetCompressedInstance(string caseId, AASeq aaSeqIn, bool stopOnStop, TextWriter errorStream) { AASeq aaSeqOut = new AASeq(aaSeqIn.MixtureSemantics); aaSeqOut.Sequence = new List <Set <char> >(); aaSeqOut._originalAA1PositionTableOrNull = new List <string>(); Debug.Assert(aaSeqOut.Offset == 0); // real assert for (int iChar = 0; iChar < aaSeqIn.Count; ++iChar) { Set <char> set = aaSeqIn[iChar]; string originalAA1Position = aaSeqIn.OriginalAA1Position(iChar); if (set.Equals(Delete)) //!!!const { continue; } if (set.Equals(Stop)) //!!!const { if (iChar != aaSeqIn.Count - 1) { errorStream.WriteLine("Warning: The sequence for case id '{0}' contains a '*' before the last position", caseId); if (stopOnStop) { break; } } else { break; } } aaSeqOut.Sequence.Add(set); aaSeqOut._originalAA1PositionTableOrNull.Add(originalAA1Position); } return(aaSeqOut); }
/// <summary> /// Skips over deletes. Is allowed to be short if near end of larger sequence /// </summary> public AASeq SubSeqCenteredAA1Pos(int aa1Pos, int merLength, out Set <char> centerAA) { Helper.CheckCondition(merLength > 0, "merLength must be greater than 0"); int?positionToStartBase1OrNull = FindStartPositionBase1OrNull(aa1Pos); if (positionToStartBase1OrNull == null) { centerAA = AASeq.Delete; return(SubSeqAA0Pos(0, 0, false)); } int positionToStartBase0 = positionToStartBase1OrNull.Value - 1; centerAA = Sequence[positionToStartBase0]; int goalLength = (merLength - 1) / 2; int leftIndex = FindLeftPosBase0(positionToStartBase0, goalLength); int rightIndex = FindRightBase0(positionToStartBase0, goalLength); AASeq result = SubSeqAA0Pos(leftIndex, rightIndex - leftIndex + 1, true); return(result); }
public void WriteAsTable(List <NamedSequence> sequences, TextWriter writer) { CaseIdToAASeq cidToAASeq = CaseIdToAASeq.GetInstance(); bool isDna = sequences[0].IsDna(); foreach (NamedSequence seq in sequences) { cidToAASeq.Add(seq.Name, isDna ? DnaSeq.GetInstance(seq.Sequence, MixtureSemantics) : AASeq.GetInstance(seq.Sequence, MixtureSemantics)); } List <string> header = new List <string>(sequences.Count + 1); header.Add("Var"); header.AddRange(sequences.Select(seq => seq.Name)); writer.WriteLine(header.StringJoin("\t")); int maxLen = cidToAASeq.Dictionary.Values.Select(aaSeq => aaSeq.Count).Max(); for (int pos0 = 0; pos0 < maxLen; pos0++) { foreach (char aa in cidToAASeq.EveryAminoAcid(pos0)) { string merAndPos = (pos0 + 1) + "@" + aa; int?[] values = new int?[sequences.Count]; HashSet <int> nonMissingValues = new HashSet <int>(); for (int pidIdx = 0; pidIdx < sequences.Count; pidIdx++) { int? value; Set <char> observedAAs = cidToAASeq.Dictionary[sequences[pidIdx].Name][pos0]; if (observedAAs.Contains('?') || observedAAs.Count == 0 || (observedAAs.Count > 1 && MixtureSemantics == MixtureSemantics.Uncertainty && observedAAs.Contains(aa))) { value = null; } else if (observedAAs.Contains(aa) && (MixtureSemantics != MixtureSemantics.Pure || observedAAs.Count == 1)) { value = 1; } else { value = 0; } values[pidIdx] = value; if (value != null) { nonMissingValues.Add((int)value); } } if (nonMissingValues.Count > 1 || (KeepOneValueVariables && nonMissingValues.Count == 1 && nonMissingValues.First() == 1)) { writer.WriteLine(Helper.CreateTabString(merAndPos, values.Select(v => v.HasValue ? v.ToString() : MissingStatistics.GetInstance().ToString()).StringJoin("\t"))); } } } writer.Flush(); }
public bool TrySubSeqAA1Pos(int aa1Pos, int merLength, out AASeq aaSeq) { return(TrySubSeqAA0Pos(aa1Pos - 1, merLength, out aaSeq)); }
public static Matrix <string, string, SufficientStatistics> ConvertToMatrix(List <NamedSequence> sequences, MixtureSemantics mix, BinaryOrMultistate dataType, bool keepOneValueVariables) { var colNames = sequences.Select(s => s.Name); //var rowNames = (from posAndAa in sequences.SelectMany(s => s.AASeq) // where !AASeq.IsMissing(posAndAa.Value) // let pos = posAndAa.Key // let aas = posAndAa.Value // from c in aas // let merAndPos = pos + "@" + c // orderby pos, c // select merAndPos).Distinct(); var rowNames = (from posAndAa in sequences.SelectMany(s => s.AASeq) where posAndAa.Value.Count == 1 && !AASeq.IsMissing(posAndAa.Value) let pos = posAndAa.Key let aas = posAndAa.Value let c = aas.First() let merAndPos = pos + "@" + c orderby pos, c select merAndPos).Distinct(); var posToRowNames = (from row in rowNames let pos = (int)Tabulate.GetMerAndPos(row).Value group row by pos into g select new KeyValuePair <int, List <string> >(g.Key, g.ToList())).ToDictionary(); Matrix <string, string, SufficientStatistics> m = DenseMatrix <string, string, SufficientStatistics> .CreateDefaultInstance(rowNames, colNames, MissingStatistics.GetInstance()); foreach (var seq in sequences) { foreach (var posAndAa in seq.AASeq) { int pos = posAndAa.Key; if (!posToRowNames.ContainsKey(pos)) { Helper.CheckCondition(AASeq.IsMissing(posAndAa.Value), "Something's wrong. We thinking everyone is missing at position {0}, but {1} has {2}", pos, seq.Name, posAndAa.Value); continue; } var relevantRows = posToRowNames[pos]; bool isMissing = AASeq.IsMissing(posAndAa.Value); var myRows = posAndAa.Value.Select(c => pos + "@" + c).ToList(); foreach (var row in relevantRows) { SufficientStatistics value; if (isMissing) { value = MissingStatistics.GetInstance(); } else if (!myRows.Contains(row)) { value = (BooleanStatistics)false; //in all cases, this is false } else if (myRows.Count == 1) { value = (BooleanStatistics)true; } else { switch (mix) { case MixtureSemantics.Any: value = (BooleanStatistics)true; break; //Any means we say you have both case MixtureSemantics.Pure: value = (BooleanStatistics)false; break; //Pure means we say you have neither case MixtureSemantics.Uncertainty: value = MissingStatistics.GetInstance(); break; //Uncertainty says we don't know which you have. case MixtureSemantics.Distribution: double pTrue = 1.0 / myRows.Count; value = MultinomialStatistics.GetInstance(new double[] { 1 - pTrue, pTrue }); break; default: throw new NotImplementedException("Missing a case."); } } m.SetValueOrMissing(row, seq.Name, value); } } } if (!keepOneValueVariables) { m = m.SelectRowsView(m.RowKeys.Where(row => m.RowView(row).Values.Distinct().Count() > 1)); } switch (dataType) { case BinaryOrMultistate.Binary: return(m); case BinaryOrMultistate.Multistate: return(new BinaryToMultistateView <string, string, SufficientStatistics>(m, Tabulate.BinaryToMultistateMapping(m), ValueConverter.SufficientStatisticsToMultinomial)); default: throw new NotImplementedException("Missing a case"); } }
private AASeq GetFirstAASeq() { AASeq firstAASeq = this._caseIdToAASeq.Values.First(); return(firstAASeq); }
private IEnumerable <string> EveryProtein() { AASeq firstAASeq = GetFirstAASeq(); return(firstAASeq.EveryProtein()); }
public IEnumerable <string> SparseLineEnumeration(bool keepOneValueVariables) { if (_caseIdToAASeq.Count == 0) { Debug.Assert(SequenceLengthOrNull == null); // real assert yield break; } Helper.CheckCondition(SequenceLengthOrNull != null, "This converter to sparse assumes all sequences have the same length"); /* * n1pos aa pid val * 880 A 3 F * 880 A 5 F * 880 A 9 F * 880 A 13 F * 880 A 14 F * 880 A 15 T * ... */ for (int aa0Pos = 0; aa0Pos < (int)SequenceLengthOrNull; ++aa0Pos) { Set <char> everyAminoAcid = EveryAminoAcid(aa0Pos); if (!keepOneValueVariables && everyAminoAcid.Count == 1) { continue; } string posName = null; foreach (char aa in everyAminoAcid) { Set <bool> valueSet = Set <bool> .GetInstance(); Dictionary <string, bool> caseToVal = new Dictionary <string, bool>(); foreach (string caseId in _caseIdToAASeq.Keys) { AASeq aaSeq = _caseIdToAASeq[caseId]; if (aa0Pos >= aaSeq.Count) { continue; } //Helper.CheckCondition(aaSeq.IsUsingOriginalPositions(), "This converter to sparse assumes all sequences are using their original positions"); Set <char> strainAASet = aaSeq[aa0Pos]; if (posName == null) { posName = aaSeq.OriginalAA1Position(aa0Pos); //if (posName.Contains("68.3B")) //{ // Console.WriteLine("Found it first"); //} } else { Helper.CheckCondition(posName == aaSeq.OriginalAA1Position(aa0Pos)); } // missing: e.g. A/Any or A/AB // 1: e.g. A/A // 0: e.g. A/B or A/BCD if (strainAASet.Equals(AASeq.Any)) { //Do nothing - missing } else if (strainAASet.Contains(aa)) { if (strainAASet.Count > 1) { switch (aaSeq.MixtureSemantics) { case MixtureSemantics.Pure: caseToVal.Add(caseId, false); valueSet.AddNewOrOld(false); break; case MixtureSemantics.Uncertainty: // Do nothing = missing break; case MixtureSemantics.Any: caseToVal.Add(caseId, true); valueSet.AddNewOrOld(true); break; default: Helper.CheckCondition(false, "Unknown mixturesemantics " + aaSeq.MixtureSemantics.ToString()); break; } } else { caseToVal.Add(caseId, true); valueSet.AddNewOrOld(true); } } else { caseToVal.Add(caseId, false); valueSet.AddNewOrOld(false); } } Helper.CheckCondition(posName != null); if (keepOneValueVariables || valueSet.Count == 2) { foreach (KeyValuePair <string, bool> caseIdAndVal in caseToVal) { string variableName = string.Format("{0}@{1}", posName, aa); //string variableName = string.Format("{1}@{0}", posName, aa); //if (variableName.Contains("68.3B")) //{ // Console.WriteLine("Found it first"); //} yield return(Helper.CreateTabString( variableName, caseIdAndVal.Key, caseIdAndVal.Value ? 1 : 0)); } } } } }