/// <summary>
/// Initializes a new instance of the <see cref="SequencesAlignmentController"/> class.
/// </summary>
public SequencesAlignmentController()
: base("Sequences alignment")
{
db = new LibiadaWebEntities();
subsequenceExtractor = new SubsequenceExtractor(db);
characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db);
featureRepository = new FeatureRepository(db);
}
/// <summary>
/// Initializes a new instance of the <see cref="ViewDataHelper"/> class.
/// </summary>
/// <param name="db">
/// The db.
/// </param>
public ViewDataHelper(LibiadaWebEntities db)
{
this.db = db;
matterRepository = new MatterRepository(db);
notationRepository = new NotationRepository(db);
featureRepository = new FeatureRepository(db);
characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db);
remoteDbRepository = new RemoteDbRepository(db);
}
public ActionResult Index(long[] matterIds, int characteristicTypeLinkId, int[] characteristicTypeLinkIds, int[] featureIds)
{
return Action(() =>
{
var matterNames = new string[matterIds.Length];
var remoteIds = new string[matterIds.Length];
var subsequencesCharacteristicsNames = new string[characteristicTypeLinkIds.Length];
var calculators = new IFullCalculator[characteristicTypeLinkIds.Length];
var links = new Link[characteristicTypeLinkIds.Length];
var subsequencesCharacteristicsList = new SelectListItem[characteristicTypeLinkIds.Length];
var attributeValues = new List<AttributeValue>();
IEnumerable<SelectListItem> featuresSelectList;
Chain[] chains;
long[] parentSequenceIds;
string sequenceCharacteristicName;
IFullCalculator calculator;
Link link;
using (var db = new LibiadaWebEntities())
{
var featureRepository = new FeatureRepository(db);
featuresSelectList = featureRepository.GetFeaturesById(featureIds).Select(f => new SelectListItem { Value = f.Id.ToString(), Text = f.Name, Selected = true });
var parentSequences = db.DnaSequence.Include(s => s.Matter)
.Where(s => s.NotationId == Aliases.Notation.Nucleotide && matterIds.Contains(s.MatterId))
.Select(s => new { s.Id, MatterName = s.Matter.Name, s.RemoteId })
.ToDictionary(s => s.Id);
parentSequenceIds = parentSequences.Keys.ToArray();
for (int n = 0; n < parentSequenceIds.Length; n++)
{
matterNames[n] = parentSequences[parentSequenceIds[n]].MatterName;
remoteIds[n] = parentSequences[parentSequenceIds[n]].RemoteId;
}
var commonSequenceRepository = new CommonSequenceRepository(db);
chains = commonSequenceRepository.GetNucleotideChains(matterIds);
var characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db);
sequenceCharacteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkId);
calculator = CalculatorsFactory.CreateFullCalculator(characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkId).ClassName);
link = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkId);
for (int k = 0; k < characteristicTypeLinkIds.Length; k++)
{
links[k] = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkIds[k]);
string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkIds[k]).ClassName;
calculators[k] = CalculatorsFactory.CreateFullCalculator(className);
subsequencesCharacteristicsNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkIds[k]);
subsequencesCharacteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = subsequencesCharacteristicsNames[k],
Selected = false
};
}
}
var characteristics = SequencesCharacteristicsCalculator.Calculate(chains, calculator, link, characteristicTypeLinkId);
var sequenceData = new SequenceData[parentSequenceIds.Length];
for (int i = 0; i < parentSequenceIds.Length; i++)
{
// all subsequence calculations
var subsequencesData = SubsequencesCharacteristicsCalculator.CalculateSubsequencesCharacteristics(
characteristicTypeLinkIds,
featureIds,
parentSequenceIds[i],
calculators,
links,
attributeValues);
sequenceData[i] = new SequenceData(matterIds[i], matterNames[i], remoteIds[i], characteristics[i], subsequencesData);
}
// sorting organisms by their characteristic
sequenceData = sequenceData.OrderBy(r => r.Characteristic).ToArray();
var resultData = new Dictionary<string, object>
{
{ "result", sequenceData },
{ "subsequencesCharacteristicsNames", subsequencesCharacteristicsNames },
{ "subsequencesCharacteristicsList", subsequencesCharacteristicsList },
{ "sequenceCharacteristicName", sequenceCharacteristicName },
{ "features", featuresSelectList.ToDictionary(f => f.Value) },
{ "attributes", EnumExtensions.ToArray<Attribute>().ToDictionary(a => (byte)a, a => a.GetDisplayValue()) },
{ "attributeValues", attributeValues.Select(sa => new { attribute = sa.AttributeId, value = sa.Value }) }
};
return new Dictionary<string, object>
{
{ "data", JsonConvert.SerializeObject(resultData) }
};
});
}
public ActionResult Index(
long[] matterIds,
int characteristicTypeLinkId,
int[] featureIds,
string maxPercentageDifference,
double characteristicValueFrom,
double characteristicValueTo)
{
return Action(() =>
{
Dictionary<int, string> features;
var attributeValues = new List<AttributeValue>();
var characteristics = new SubsequenceData[matterIds.Length][];
string characteristicName;
long[] parentSequenceIds;
var matterNames = new string[matterIds.Length];
IFullCalculator calculator;
Link link;
int mattersCount = matterIds.Length;
int[] subsequencesCount = new int[mattersCount];
using (var db = new LibiadaWebEntities())
{
var featureRepository = new FeatureRepository(db);
features = featureRepository.Features.ToDictionary(f => f.Id, f => f.Name);
var parentSequences = db.DnaSequence.Include(s => s.Matter)
.Where(s => s.NotationId == Aliases.Notation.Nucleotide && matterIds.Contains(s.MatterId))
.Select(s => new { s.Id, MatterName = s.Matter.Name })
.ToDictionary(s => s.Id);
parentSequenceIds = parentSequences.Keys.ToArray();
for (int n = 0; n < parentSequenceIds.Length; n++)
{
matterNames[n] = parentSequences[parentSequenceIds[n]].MatterName;
}
var characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db);
characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkId);
string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkId).ClassName;
calculator = CalculatorsFactory.CreateFullCalculator(className);
link = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkId);
}
// cycle through matters; first level of characteristics array
for (int i = 0; i < parentSequenceIds.Length; i++)
{
var subsequencesData = SubsequencesCharacteristicsCalculator.CalculateSubsequencesCharacteristics(
new[] { characteristicTypeLinkId },
featureIds,
parentSequenceIds[i],
new[] { calculator },
new[] { link },
attributeValues);
subsequencesCount[i] = subsequencesData.Length;
subsequencesData = subsequencesData.Where(c => (characteristicValueFrom == 0 && characteristicValueTo == 0)
|| (c.CharacteristicsValues[0] >= characteristicValueFrom && c.CharacteristicsValues[0] <= characteristicValueTo)).
OrderBy(c => c.CharacteristicsValues[0]).ToArray();
characteristics[i] = subsequencesData;
}
double decimalDifference = double.Parse(maxPercentageDifference, CultureInfo.InvariantCulture) / 100;
var similarities = new object[mattersCount, mattersCount];
var equalElements = new List<SubsequenceComparisonData>();
int comparisonNumber = 0;
for (int i = 0; i < characteristics.Length; i++)
{
for (int j = 0; j < characteristics.Length; j++)
{
comparisonNumber++;
double similarSequencesCharacteristicValueFirst = 0;
var similarSequencesCharacteristicValueSecond = new Dictionary<int, double>();
double similarFirstSequencesCharacteristicValue = 0;
double similarSecondSequencesCharacteristicValue = 0;
int secondArrayStartPosition = 0;
double differenceSum = 0;
int equalElementsCountFromFirst = 0;
var equalElementsCountFromSecond = new Dictionary<int, int>();
bool equalFound = false;
int equalPairsCount = 0;
for (int k = 0; k < characteristics[i].Length; k++)
{
double first = characteristics[i][k].CharacteristicsValues[0];
for (int l = secondArrayStartPosition; l < characteristics[j].Length; l++)
{
double second = characteristics[j][l].CharacteristicsValues[0];
double difference = calculateAverageDifference(first, second);
bool nextElementInSecondArrayIsEqual = false;
if (l < characteristics[j].Length - 1)
{
nextElementInSecondArrayIsEqual = calculateAverageDifference(second, characteristics[j][l + 1].CharacteristicsValues[0]) <= decimalDifference;
}
if (difference <= decimalDifference)
{
equalFound = true;
equalPairsCount++;
if (!equalElementsCountFromSecond.ContainsKey(l))
{
equalElementsCountFromSecond.Add(l, 1);
differenceSum += difference;
}
if (!similarSequencesCharacteristicValueSecond.ContainsKey(l))
{
similarSequencesCharacteristicValueSecond.Add(l, second);
}
if (i != j)
{
equalElements.Add(new SubsequenceComparisonData
{
Difference = difference,
FirstMatterId = i,
SecondMatterId = j,
FirstSubsequenceId = k,
SecondSubsequenceId = l,
});
}
similarFirstSequencesCharacteristicValue += first;
similarSecondSequencesCharacteristicValue += second;
if (!nextElementInSecondArrayIsEqual)
{
break;
}
}
else if (second < first)
{
secondArrayStartPosition++;
}
}
if (equalFound)
{
equalElementsCountFromFirst++;
similarSequencesCharacteristicValueFirst += first;
}
}
double differenceSecondFinal = equalElementsCountFromSecond.Sum(s => s.Value);
double differenceFinal = equalElementsCountFromFirst < differenceSecondFinal ? equalElementsCountFromFirst * 2d : differenceSecondFinal * 2d;
double formula1 = differenceFinal / (subsequencesCount[i] + subsequencesCount[j]);
double formula2 = 0;
if (equalPairsCount != 0 && formula1 != 0)
{
formula2 = (differenceSum / equalPairsCount) / formula1;
}
double similarSequencesCharacteristicValueSecondFinal = similarSequencesCharacteristicValueSecond.Sum(s => s.Value);
double similarSequencesCharacteristicValue = similarSequencesCharacteristicValueFirst < similarSequencesCharacteristicValueSecondFinal ?
similarSequencesCharacteristicValueFirst * 2d : similarSequencesCharacteristicValueSecondFinal * 2d;
double formula3 = similarSequencesCharacteristicValue * 100d / (characteristics[i].Sum(c => c.CharacteristicsValues[0]) + characteristics[j].Sum(c => c.CharacteristicsValues[0]));
similarities[i, j] = new
{
formula1 = Math.Round(formula1 * 100d, 3),
formula2 = Math.Round(formula2, 3),
formula3 = Math.Round(formula3, 3)
};
}
}
var result = new Dictionary<string, object>
{
{ "mattersNames", matterNames },
{ "characteristicName", characteristicName },
{ "similarities", similarities },
{ "characteristics", characteristics },
{ "equalElements", equalElements.OrderBy(e => e.Difference).ToList() },
{ "features", features },
{ "attributeValues", attributeValues.Select(sa => new { attribute = sa.AttributeId, value = sa.Value }) },
{ "attributes", EnumExtensions.ToArray<LibiadaWeb.Attribute>().ToDictionary(a => (byte)a, a => a.GetDisplayValue()) }
};
return new Dictionary<string, object>
{
{ "data", JsonConvert.SerializeObject(result) }
};
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SubsequenceImporter"/> class.
/// </summary>
/// <param name="features">
/// The features.
/// </param>
/// <param name="sequenceId">
/// The sequence id.
/// </param>
public SubsequenceImporter(List<FeatureItem> features, long sequenceId)
{
this.features = features;
this.sequenceId = sequenceId;
featureRepository = new FeatureRepository(db);
sequenceAttributeRepository = new SequenceAttributeRepository(db);
using (var commonSequenceRepository = new CommonSequenceRepository(db))
{
var parentSequence = commonSequenceRepository.ToLibiadaBaseChain(sequenceId);
parentLength = parentSequence.GetLength();
}
gene = featureRepository.GetFeatureById(Aliases.Feature.Gene).Type;
sourceLength = features[0].Location.LocationEnd;
positionsMap = new bool[parentLength];
allNonGenesLeafLocations = features.Where(f => f.Key != gene)
.Select(f => f.Location.GetLeafLocations())
.ToArray();
}
public ActionResult Index(long[] matterIds, int[] characteristicTypeLinkIds, int[] featureIds, string[] filters)
{
return Action(() =>
{
Dictionary<int, string> features;
var attributeValues = new List<AttributeValue>();
var characteristics = new Dictionary<string, SubsequenceData[]>(matterIds.Length);
var matterNames = new string[matterIds.Length];
var characteristicNames = new string[characteristicTypeLinkIds.Length];
long[] parentSequenceIds;
var calculators = new IFullCalculator[characteristicTypeLinkIds.Length];
var links = new LibiadaCore.Core.Link[characteristicTypeLinkIds.Length];
using (var db = new LibiadaWebEntities())
{
var featureRepository = new FeatureRepository(db);
features = featureRepository.Features.ToDictionary(f => f.Id, f => f.Name);
var parentSequences = db.DnaSequence.Include(s => s.Matter)
.Where(s => s.NotationId == Aliases.Notation.Nucleotide && matterIds.Contains(s.MatterId))
.Select(s => new { s.Id, MatterName = s.Matter.Name })
.ToDictionary(s => s.Id);
parentSequenceIds = parentSequences.Keys.ToArray();
for (int n = 0; n < parentSequenceIds.Length; n++)
{
matterNames[n] = parentSequences[parentSequenceIds[n]].MatterName;
}
var characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db);
for (int k = 0; k < characteristicTypeLinkIds.Length; k++)
{
var characteristicTypeLinkId = characteristicTypeLinkIds[k];
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkId);
string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkId).ClassName;
calculators[k] = CalculatorsFactory.CreateFullCalculator(className);
links[k] = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkId);
}
}
// cycle through matters; first level of characteristics array
for (int i = 0; i < parentSequenceIds.Length; i++)
{
// all subsequence calculations
var subsequencesData = SubsequencesCharacteristicsCalculator.CalculateSubsequencesCharacteristics(
characteristicTypeLinkIds,
featureIds,
parentSequenceIds[i],
calculators,
links,
attributeValues,
filters);
subsequencesData = subsequencesData.OrderByDescending(s => s.CharacteristicsValues[0]).ToArray();
characteristics[matterNames[i]] = subsequencesData;
}
return new Dictionary<string, object>
{
{ "characteristics", characteristics },
{ "matterNames", matterNames },
{ "characteristicNames", characteristicNames },
{ "features", features },
{ "attributes", EnumExtensions.ToArray<LibiadaWeb.Attribute>().ToDictionary(a => (byte)a, a => a.GetDisplayValue()) },
{ "attributeValues", attributeValues.Select(sa => new { attribute = (byte)sa.AttributeId, value = sa.Value }) }
};
});
}
