/// <summary>
/// Initializes a new instance of the <see cref="SubsequencesSimilarityController"/> class.
/// </summary>
public SubsequencesSimilarityController() : base(TaskType.SubsequencesSimilarity)
{
db = new LibiadaWebEntities();
subsequenceExtractor = new SubsequenceExtractor(db);
characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
sequenceAttributeRepository = new SequenceAttributeRepository(db);
}
/// <summary>
/// The get subsequence characteristic.
/// </summary>
/// <param name="subsequenceId">
/// The subsequence id.
/// </param>
/// <param name="characteristicLinkId">
/// The characteristic type link id.
/// </param>
/// <param name="windowSize">
/// The window size.
/// </param>
/// <param name="step">
/// The step.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public string GetSubsequenceCharacteristic(
long subsequenceId,
short characteristicLinkId,
int windowSize,
int step)
{
Chain chain;
IFullCalculator calculator;
Link link;
using (var db = new LibiadaWebEntities())
{
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
FullCharacteristic characteristic =
characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
var subsequenceExtractor = new SubsequenceExtractor(db);
Subsequence subsequence = db.Subsequence.Single(s => s.Id == subsequenceId);
chain = subsequenceExtractor.GetSubsequenceSequence(subsequence);
}
CutRule cutRule = new SimpleCutRule(chain.Length, step, windowSize);
CutRuleIterator iterator = cutRule.GetIterator();
var fragments = new List <Chain>();
while (iterator.Next())
{
int start = iterator.GetStartPosition();
int end = iterator.GetEndPosition();
var fragment = new List <IBaseObject>();
for (int k = 0; start + k < end; k++)
{
fragment.Add(chain[start + k]);
}
fragments.Add(new Chain(fragment));
}
var characteristics = new double[fragments.Count];
for (int k = 0; k < fragments.Count; k++)
{
characteristics[k] = calculator.Calculate(fragments[k], link);
}
return(JsonConvert.SerializeObject(characteristics));
}
/// <summary>
/// Creates clustalw alignment job
/// and returns it's id.
/// </summary>
/// <param name="subsequencesIds">
/// Ids of subsequences selected for alignment
/// </param>
/// <returns>
/// JSON containing result status (Success / Error)
/// and remote job id or errror message.
/// </returns>
public string CreateAlignmentTask(long[] subsequencesIds)
{
try
{
ISequence[] bioSequences;
using (var db = new LibiadaWebEntities())
{
var subsequenceExtractor = new SubsequenceExtractor(db);
bioSequences = subsequenceExtractor.GetBioSequencesForFastaConverter(subsequencesIds);
}
string fasta;
FastAFormatter formatter = new FastAFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Format(stream, bioSequences);
fasta = Encoding.ASCII.GetString(stream.ToArray());
}
string result;
using (var webClient = new WebClient())
{
webClient.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
Uri url = new Uri("https://www.ebi.ac.uk/Tools/services/rest/clustalo/run");
// TODO: make email global parameter
result = webClient.UploadString(url, $"[email protected]&sequence={fasta}");
}
return(JsonConvert.SerializeObject(new { Status = "Success", Result = result }));
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(new { Status = "Error", ex.Message }));
}
}
/// <summary>
/// Calculates subsequences characteristics.
/// </summary>
/// <param name="characteristicIds">
/// The ids of characteristic types, arrangement types and links as <see cref="FullCharacteristicLink"/>.
/// </param>
/// <param name="features">
/// The features ids of subsequences to extract.
/// </param>
/// <param name="parentSequenceId">
/// The parent sequence id.
/// </param>
/// <param name="filters">
/// Textual search filters for subsequences products.
/// </param>
/// <returns>
/// The <see cref="T:SubsequenceData[]"/> .
/// </returns>
public static SubsequenceData[] CalculateSubsequencesCharacteristics(
short[] characteristicIds,
Feature[] features,
long parentSequenceId,
string[] filters = null)
{
Dictionary <long, Chain> sequences;
long[] subsequenceIds;
SubsequenceData[] subsequenceData;
Dictionary <long, Dictionary <short, double> > characteristics;
var calculators = new IFullCalculator[characteristicIds.Length];
var links = new Link[characteristicIds.Length];
var newCharacteristics = new List <CharacteristicValue>();
// creating local context to avoid memory overflow due to possibly big cache of characteristics
using (var db = new LibiadaWebEntities())
{
var subsequenceExtractor = new SubsequenceExtractor(db);
Subsequence[] subsequences = filters == null?
subsequenceExtractor.GetSubsequences(parentSequenceId, features) :
subsequenceExtractor.GetSubsequences(parentSequenceId, features, filters);
subsequenceData = subsequences.Select(s => new SubsequenceData(s)).ToArray();
// converting to libiada sequences
subsequenceIds = subsequences.Select(s => s.Id).ToArray();
characteristics = db.CharacteristicValue
.Where(c => characteristicIds.Contains(c.CharacteristicLinkId) && subsequenceIds.Contains(c.SequenceId))
.ToArray()
.GroupBy(c => c.SequenceId)
.ToDictionary(c => c.Key, c => c.ToDictionary(ct => ct.CharacteristicLinkId, ct => ct.Value));
if (characteristics.Count == subsequences.Length && characteristics.All(c => c.Value.Count == characteristicIds.Length))
{
sequences = new Dictionary <long, Chain>();
}
else
{
sequences = subsequenceExtractor.GetSubsequencesSequences(subsequences);
}
}
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
for (int k = 0; k < characteristicIds.Length; k++)
{
short characteristicLinkId = characteristicIds[k];
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
calculators[k] = FullCalculatorsFactory.CreateCalculator(characteristic);
links[k] = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
}
// cycle through subsequences
for (int i = 0; i < subsequenceIds.Length; i++)
{
characteristics.TryGetValue(subsequenceIds[i], out Dictionary <short, double> sequenceDbCharacteristics);
sequenceDbCharacteristics = sequenceDbCharacteristics ?? new Dictionary <short, double>();
var values = new double[calculators.Length];
// cycle through characteristics and notations
for (int j = 0; j < calculators.Length; j++)
{
short characteristicLinkId = characteristicIds[j];
if (!sequenceDbCharacteristics.TryGetValue(characteristicLinkId, out values[j]))
{
values[j] = calculators[j].Calculate(sequences[subsequenceIds[i]], links[j]);
var currentCharacteristic = new CharacteristicValue
{
SequenceId = subsequenceIds[i],
CharacteristicLinkId = characteristicLinkId,
Value = values[j]
};
newCharacteristics.Add(currentCharacteristic);
}
}
subsequenceData[i].CharacteristicsValues = values;
}
using (var db = new LibiadaWebEntities())
{
// trying to save calculated characteristics to database
var characteristicRepository = new CharacteristicRepository(db);
characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics);
}
return(subsequenceData);
}
/// <summary>
/// Calculates subsequences characteristics.
/// </summary>
/// <param name="characteristicTypeLinkIds">
/// The characteristic type link ids.
/// </param>
/// <param name="featureIds">
/// The features ids.
/// </param>
/// <param name="parentSequenceId">
/// The parent sequence id.
/// </param>
/// <param name="calculators">
/// The calculators.
/// </param>
/// <param name="links">
/// The links.
/// </param>
/// <param name="attributeValues">
/// Nonredundant array of all attributes.
/// </param>
/// <param name="filters">
/// Textual search filters for subsequences products.
/// </param>
/// <returns>
/// The <see cref="T:SubsequenceData[]"/>.
/// </returns>
public static SubsequenceData[] CalculateSubsequencesCharacteristics(
int[] characteristicTypeLinkIds,
int[] featureIds,
long parentSequenceId,
IFullCalculator[] calculators,
Link[] links,
List<AttributeValue> attributeValues,
string[] filters = null)
{
// creating local context to avoid memory overflow due to possibly big cache of characteristics
using (var context = new LibiadaWebEntities())
{
var subsequenceExtractor = new SubsequenceExtractor(context);
var sequenceAttributeRepository = new SequenceAttributeRepository(context);
var attributeRepository = new AttributeRepository();
var newCharacteristics = new List<Characteristic>();
// extracting data from database
var dbSubsequences = filters == null ? subsequenceExtractor.GetSubsequences(parentSequenceId, featureIds) : subsequenceExtractor.GetSubsequences(parentSequenceId, featureIds, filters);
var subsequenceIds = dbSubsequences.Select(s => s.Id).ToArray();
var dbSubsequencesAttributes = sequenceAttributeRepository.GetAttributes(subsequenceIds);
var dbCharacteristics = context.Characteristic.Where(c => characteristicTypeLinkIds.Contains(c.CharacteristicTypeLinkId) && subsequenceIds.Contains(c.SequenceId))
.ToArray()
.GroupBy(c => c.SequenceId)
.ToDictionary(c => c.Key, c => c.ToDictionary(ct => ct.CharacteristicTypeLinkId, ct => ct.Value));
// converting to libiada sequences
var sequences = subsequenceExtractor.ExtractChains(dbSubsequences, parentSequenceId);
var subsequenceData = new SubsequenceData[sequences.Length];
// cycle through subsequences
for (int i = 0; i < sequences.Length; i++)
{
var values = new double[characteristicTypeLinkIds.Length];
Dictionary<int, double> sequenceDbCharacteristics;
if (!dbCharacteristics.TryGetValue(dbSubsequences[i].Id, out sequenceDbCharacteristics))
{
sequenceDbCharacteristics = new Dictionary<int, double>();
}
// cycle through characteristics and notations
for (int j = 0; j < characteristicTypeLinkIds.Length; j++)
{
int characteristicTypeLinkId = characteristicTypeLinkIds[j];
if (!sequenceDbCharacteristics.TryGetValue(characteristicTypeLinkId, out values[j]))
{
values[j] = calculators[j].Calculate(sequences[i], links[j]);
var currentCharacteristic = new Characteristic
{
SequenceId = dbSubsequences[i].Id,
CharacteristicTypeLinkId = characteristicTypeLinkId,
Value = values[j]
};
newCharacteristics.Add(currentCharacteristic);
}
}
AttributeValue[] attributes;
if (!dbSubsequencesAttributes.TryGetValue(dbSubsequences[i].Id, out attributes))
{
attributes = new AttributeValue[0];
}
var attributeIndexes = new int[attributes.Length];
for (int j = 0; j < attributes.Length; j++)
{
if (!attributeValues.Contains(attributes[j]))
{
attributeValues.Add(attributes[j]);
}
attributeIndexes[j] = attributeValues.IndexOf(attributes[j]);
}
subsequenceData[i] = new SubsequenceData(dbSubsequences[i], values, attributeIndexes);
}
// trying to save calculated characteristics to database
var characteristicRepository = new CharacteristicRepository(context);
characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics);
return subsequenceData;
}
}
