/// <summary>
/// Calculation method.
/// </summary>
/// <param name="chains">
/// The chains.
/// </param>
/// <param name="calculator">
/// The calculator.
/// </param>
/// <param name="link">
/// The link.
/// </param>
/// <param name="characteristicTypeLinkId">
/// The characteristic type link id.
/// </param>
/// <returns>
/// The <see cref="T:double[]"/>.
/// </returns>
public static double[] Calculate(Chain[] chains, IFullCalculator calculator, Link link, int characteristicTypeLinkId)
{
var newCharacteristics = new List<Characteristic>();
var characteristics = new double[chains.Length];
var sequenceIds = chains.Select(c => c.Id);
Dictionary<long, double> dbCharacteristics;
using (var db = new LibiadaWebEntities())
{
dbCharacteristics = db.Characteristic
.Where(c => characteristicTypeLinkId == c.CharacteristicTypeLinkId && sequenceIds.Contains(c.SequenceId))
.ToArray()
.GroupBy(c => c.SequenceId)
.ToDictionary(c => c.Key, c => c.Single().Value);
}
for (int i = 0; i < chains.Length; i++)
{
chains[i].FillIntervalManagers();
long sequenceId = chains[i].Id;
if (!dbCharacteristics.TryGetValue(sequenceId, out characteristics[i]))
{
characteristics[i] = calculator.Calculate(chains[i], link);
var currentCharacteristic = new Characteristic
{
SequenceId = sequenceId,
CharacteristicTypeLinkId = characteristicTypeLinkId,
Value = characteristics[i]
};
newCharacteristics.Add(currentCharacteristic);
}
}
// trying to save calculated characteristics to database
using (var db = new LibiadaWebEntities())
{
var characteristicRepository = new CharacteristicRepository(db);
characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics);
}
return characteristics;
}
/// <summary>
/// Calculation method.
/// </summary>
/// <param name="chains">
/// The chains.
/// </param>
/// <param name="calculators">
/// The calculators.
/// </param>
/// <param name="links">
/// The links.
/// </param>
/// <param name="characteristicTypeLinkIds">
/// The characteristic type link ids.
/// </param>
/// <returns>
/// The <see cref="T:double[][]"/>.
/// </returns>
public static double[][] Calculate(Chain[][] chains, IFullCalculator[] calculators, Link[] links, int[] characteristicTypeLinkIds)
{
var newCharacteristics = new List<Characteristic>();
var characteristics = new double[chains.Length][];
var sequenceIds = chains.SelectMany(c => c).Select(c => c.Id).Distinct();
Dictionary<long, Dictionary<int, double>> dbCharacteristics;
using (var db = new LibiadaWebEntities())
{
dbCharacteristics = db.Characteristic
.Where(c => characteristicTypeLinkIds.Contains(c.CharacteristicTypeLinkId) && sequenceIds.Contains(c.SequenceId))
.ToArray()
.GroupBy(c => c.SequenceId)
.ToDictionary(c => c.Key, c => c.ToDictionary(ct => ct.CharacteristicTypeLinkId, ct => ct.Value));
}
for (int i = 0; i < chains.Length; i++)
{
characteristics[i] = new double[calculators.Length];
for (int j = 0; j < calculators.Length; j++)
{
long sequenceId = chains[i][j].Id;
chains[i][j].FillIntervalManagers();
Dictionary<int, double> sequenceDbCharacteristics;
if (!dbCharacteristics.TryGetValue(sequenceId, out sequenceDbCharacteristics))
{
sequenceDbCharacteristics = new Dictionary<int, double>();
}
if (!sequenceDbCharacteristics.TryGetValue(characteristicTypeLinkIds[j], out characteristics[i][j]))
{
characteristics[i][j] = calculators[j].Calculate(chains[i][j], links[j]);
var currentCharacteristic = new Characteristic
{
SequenceId = sequenceId,
CharacteristicTypeLinkId = characteristicTypeLinkIds[j],
Value = characteristics[i][j]
};
newCharacteristics.Add(currentCharacteristic);
}
}
}
// trying to save calculated characteristics to database
using (var db = new LibiadaWebEntities())
{
var characteristicRepository = new CharacteristicRepository(db);
characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics);
}
return characteristics;
}
/// <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;
}
}
