/// <summary>
/// Calculate 'reference' codons
/// </summary>
/// <param name="numCodons"></param>
/// <returns></returns>
protected string CodonsRef(int numCodons)
{
ISequence cds = Transcript.RetrieveCodingSequence();
string codon = "";
int start = CodonStartNumber * CODON_SIZE;
int more = numCodons * CODON_SIZE;
int end = start + more;
int len = (int)cds.Count;
if (start >= len)
{
start = len;
}
if (end >= len)
{
end = len;
}
// Capitalize
codon = SequenceExtensions.ConvertToString(cds.GetSubSequence(start, more));
// Codon not multiple of three? Add missing bases as 'N'
if (codon.Length % 3 == 1)
{
codon += "NN";
}
else if (codon.Length % 3 == 2)
{
codon += "N";
}
return(codon);
}
/// <summary>
/// Calculate base number in a cds where 'pos' is
/// </summary>
/// <param name="pos"></param>
/// <returns></returns>
protected long CdsBaseNumber(long pos)
{
long cdsbn = Transcript.BaseNumberCds(pos, true);
// Does not intersect the transcript?
if (cdsbn < 0)
{
// 'pos' before transcript start
if (pos <= Transcript.CdsOneBasedStart)
{
if (Transcript.IsStrandPlus())
{
return(0);
}
return(Transcript.RetrieveCodingSequence().Count);
}
// 'pos' is after CDS end
if (Transcript.IsStrandPlus())
{
return(Transcript.RetrieveCodingSequence().Count);
}
return(0);
}
return(cdsbn);
}
/// <summary>
/// Calculate codons by applying the variant and calculating the differences in CDS sequences.
/// This is a slow method, makes sense only for complex variants
/// </summary>
protected void CodonsRefAlt()
{
Transcript trNew = Transcript.ApplyVariant(Variant) as Transcript;
cdsAlt = SequenceExtensions.ConvertToString(trNew.RetrieveCodingSequence());
cdsRef = SequenceExtensions.ConvertToString(Transcript.RetrieveCodingSequence());
cdsDiff(); // Calculate differences: CDS
}
/// <summary>
/// CDS length (negative if there is none)
/// </summary>
/// <returns></returns>
public long GetCdsLength()
{
Transcript tr = GetTranscript();
return(tr != null && tr.IsProteinCoding() ?
tr.RetrieveCodingSequence().Count :
-1);
}
private long cdsBaseNumber(long pos, bool usePrevBaseIntron)
{
if (pos < cdsStart)
{
return(Transcript.IsStrandPlus() ? 0 : Transcript.RetrieveCodingSequence().Count - 1);
}
if (pos > cdsEnd)
{
return(Transcript.IsStrandPlus() ? Transcript.RetrieveCodingSequence().Count - 1 : 0);
}
return(Transcript.BaseNumberCds(pos, usePrevBaseIntron));
}
/// <summary>
/// Get original codons in CDS
/// </summary>
/// <returns></returns>
protected override string CodonsRef()
{
int numCodons = 1;
// Get CDS
ISequence cdsStr = Transcript.RetrieveCodingSequence();
long cdsLen = cdsStr.Count;
// Calculate minBase (first codon base in the CDS)
int minBase = CodonStartNumber * CODON_SIZE;
if (minBase < 0)
{
minBase = 0;
}
// Calculate maxBase (last codon base in the CDS)
long maxBase = CodonStartNumber * CODON_SIZE + numCodons * CODON_SIZE;
if (maxBase > cdsLen)
{
maxBase = cdsLen;
}
// Sanity checks
if (cdsLen == 0 || // Empty CDS => Cannot get codon (e.g. one or more exons are missing their sequences
(cdsLen <= minBase) // Codon past CDS sequence => Cannot get codon
)
{
return("");
}
// Create codon sequence
char[] codonChars = SequenceExtensions.ConvertToString(cdsStr).Substring(minBase, CODON_SIZE).ToLower(CultureInfo.InvariantCulture).ToCharArray();
// Capitatlize changed base
if (CodonStartIndex < codonChars.Length)
{
codonChars[CodonStartIndex] = char.ToUpper(codonChars[CodonStartIndex]);
}
string codon = new String(codonChars);
return(codon);
}
/// <summary>
/// Get original codons in CDS
/// </summary>
/// <returns></returns>
protected override string CodonsRef()
{
if (NetCodingSequenceChange == "")
{
return("");
}
long min = Variant.OneBasedStart;
long max = Variant.OneBasedEnd;
long cdsBaseMin = CdsBaseNumber(min);
long cdsBaseMax = CdsBaseNumber(max);
// Swap?
if (Transcript.IsStrandMinus())
{
long swap = cdsBaseMin;
cdsBaseMin = cdsBaseMax;
cdsBaseMax = swap;
}
if (cdsBaseMax < cdsBaseMin)
{
throw new ArgumentOutOfRangeException("This should never happen!\n\tcdsBaseMin: " + cdsBaseMin + "\n\tcdsBaseMax: " + cdsBaseMax + "\n\tmin: " + min + "\n\tmax: " + max + "\n\tSeqChange: " + Variant + "\n\ttranscript: " + Transcript + "\n\tCDS.len: " + Transcript.RetrieveCodingSequence().Count);
}
long maxCodon = cdsBaseMax / CODON_SIZE;
long minCodon = cdsBaseMin / CODON_SIZE;
long oldCodonCdsStart = (CODON_SIZE * minCodon);
long oldCodonCdsEnd = (CODON_SIZE * (maxCodon + 1)) - 1;
string codons = oldCodonCdsEnd >= Transcript.RetrieveCodingSequence().Count ?
SequenceExtensions.ConvertToString(Transcript.RetrieveCodingSequence()).Substring((int)oldCodonCdsStart) :
SequenceExtensions.ConvertToString(Transcript.RetrieveCodingSequence().GetSubSequence(oldCodonCdsStart, (maxCodon - minCodon + 1) * CODON_SIZE));
return(codons);
}
/// <summary>
/// Calculate codons old / codons new
/// </summary>
protected void codonOldNew()
{
if (!Transcript.Intersects(Variant))
{
return;
}
// CDS coordinates
cdsStart = Transcript.IsStrandPlus() ? Transcript.CdsOneBasedStart : Transcript.CdsOneBasedEnd;
cdsEnd = Transcript.IsStrandPlus() ? Transcript.CdsOneBasedEnd : Transcript.CdsOneBasedStart;
// Does it intersect CDS?
if (cdsStart > Variant.OneBasedEnd)
{
return;
}
if (cdsEnd < Variant.OneBasedStart)
{
return;
}
// Base number relative to CDS start
long scStart, scEnd;
if (Transcript.IsStrandPlus())
{
scStart = cdsBaseNumber(Variant.OneBasedStart, false);
scEnd = cdsBaseNumber(Variant.OneBasedEnd, true);
}
else
{
scEnd = cdsBaseNumber(Variant.OneBasedStart, true);
scStart = cdsBaseNumber(Variant.OneBasedEnd, false);
}
// Update coordinates
CodonStartNumber = (int)(scStart / CODON_SIZE);
CodonStartIndex = (int)(scStart % CODON_SIZE);
// MNP overlap in coding part
long scLen = scEnd - scStart;
if (scLen < 0)
{
return;
}
// Round to codon position
long scStart3 = round3(scStart, false);
long scEnd3 = round3(scEnd, true);
long scLen3 = scEnd3 - scStart3;
if (scEnd3 == scStart3)
{
scEnd3 += 3;
} // At least one codon
// Append 'N'
string padN = "";
long diff = scEnd3 - (Transcript.RetrieveCodingSequence().Count - 1);
if (diff > 0)
{
scEnd3 = Transcript.RetrieveCodingSequence().Count - 1;
// Pad with 'N'
switch (diff)
{
case 1:
padN = "N";
break;
case 2:
padN = "NN";
break;
default:
throw new ArgumentOutOfRangeException("Sanity check failed. Number of 'N' pading is :" + diff + ". This should not happen!");
}
}
// Get old codon (reference)
CodonsReference = SequenceExtensions.ConvertToString(Transcript.RetrieveCodingSequence().GetSubSequence(scStart3, scLen3));
// Get new codon (change)
string prepend = CodonsReference.Substring(0, (int)(scStart - scStart3));
string append = scEnd3 > scEnd?CodonsReference.Substring(CodonsReference.Length - (int)(scEnd3 - scEnd)) : "";
CodonsAlternate = prepend + NetCdsChange() + append;
// Pad codons with 'N' if required
CodonsReference += padN;
CodonsAlternate += padN;
//---
// Can we simplify codons?
//---
if ((CodonsReference != null) && (CodonsAlternate != null))
{
while ((CodonsReference.Length >= 3) && (CodonsAlternate.Length >= 3))
{
// First codon
string cold = CodonsReference.Substring(0, 3);
string cnew = CodonsAlternate.Substring(0, 3);
// Are codons equal? => Simplify
if (cold.Equals(cnew, StringComparison.InvariantCultureIgnoreCase))
{
CodonsReference = CodonsReference.Substring(3);
CodonsAlternate = CodonsAlternate.Substring(3);
CodonStartNumber++;
}
else
{
break;
}
}
}
}
