/// <summary>
/// Fills subsequences calculation data dictionary.
/// </summary>
/// <param name="minSelectedMatters">
/// The minimum Selected Matters.
/// </param>
/// <param name="maxSelectedMatters">
/// The maximum Selected Matters.
/// </param>
/// <param name="submitName">
/// The submit button name.
/// </param>
/// <returns>
/// The <see cref="Dictionary{String, Object}"/>.
/// </returns>
public Dictionary <string, object> FillSubsequencesViewData(int minSelectedMatters, int maxSelectedMatters, string submitName)
{
var sequenceIds = db.Subsequence.Select(s => s.SequenceId).Distinct();
var matterIds = db.DnaSequence.Where(c => sequenceIds.Contains(c.Id)).Select(c => c.MatterId).ToList();
Dictionary <string, object> data = GetMattersData(minSelectedMatters, maxSelectedMatters, m => matterIds.Contains(m.Id));
var geneticNotations = EnumExtensions.ToArray <Notation>().Where(n => n.GetNature() == Nature.Genetic);
var sequenceTypes = EnumExtensions.ToArray <SequenceType>().Where(st => st.GetNature() == Nature.Genetic);
var groups = EnumExtensions.ToArray <Group>().Where(g => g.GetNature() == Nature.Genetic);
var features = EnumExtensions.ToArray <Feature>().Where(f => f.GetNature() == Nature.Genetic).ToArray();
var selectedFeatures = features.Where(f => f != Feature.NonCodingSequence);
Dictionary <string, object> characteristicsData = GetCharacteristicsData(CharacteristicCategory.Full);
foreach ((string key, object value) in characteristicsData)
{
data.Add(key, value);
}
data.Add("submitName", submitName);
data.Add("notations", geneticNotations.ToSelectListWithNature());
data.Add("nature", ((byte)Nature.Genetic).ToString());
data.Add("features", features.ToSelectListWithNature(selectedFeatures));
data.Add("sequenceTypes", sequenceTypes.ToSelectListWithNature(true));
data.Add("groups", groups.ToSelectListWithNature(true));
return(data);
}
/// <summary>
/// Fills view data.
/// </summary>
/// <param name="minSelectedMatters">
/// The minimum selected matters.
/// </param>
/// <param name="maxSelectedMatters">
/// The maximum selected matters.
/// </param>
/// <returns>
/// The <see cref="Dictionary{String, Object}"/>.
/// </returns>
public Dictionary <string, object> FillViewData(int minSelectedMatters, int maxSelectedMatters)
{
Dictionary <string, object> data = GetMattersData(minSelectedMatters, maxSelectedMatters, m => true);
IEnumerable <SelectListItem> natures;
IEnumerable <SequenceType> sequenceTypes;
IEnumerable <Group> groups;
if (AccountHelper.IsAdmin())
{
natures = EnumHelper.GetSelectList(typeof(Nature));
sequenceTypes = EnumExtensions.ToArray <SequenceType>();
groups = EnumExtensions.ToArray <Group>();
}
else
{
natures = new[] { Nature.Genetic }.ToSelectList();
sequenceTypes = EnumExtensions.ToArray <SequenceType>().Where(st => st.GetNature() == Nature.Genetic);
groups = EnumExtensions.ToArray <Group>().Where(g => g.GetNature() == Nature.Genetic);
}
data.Add("natures", natures);
data.Add("sequenceTypes", sequenceTypes.ToSelectListWithNature(true));
data.Add("groups", groups.ToSelectListWithNature(true));
return(data);
}
/// <summary>
/// Fills matter creation data.
/// </summary>
/// <returns>
/// The <see cref="Dictionary{String, Object}"/>.
/// </returns>
public Dictionary <string, object> FillMatterCreationData()
{
IEnumerable <SelectListItem> natures;
IEnumerable <Notation> notations;
IEnumerable <RemoteDb> remoteDbs = EnumExtensions.ToArray <RemoteDb>();
IEnumerable <SequenceType> sequenceTypes = EnumExtensions.ToArray <SequenceType>();
IEnumerable <Group> groups = EnumExtensions.ToArray <Group>();
if (AccountHelper.IsAdmin())
{
natures = EnumHelper.GetSelectList(typeof(Nature));
notations = EnumExtensions.ToArray <Notation>();
}
else
{
natures = new[] { Nature.Genetic }.ToSelectList();
notations = new[] { Notation.Nucleotides };
remoteDbs = EnumExtensions.ToArray <RemoteDb>().Where(rd => rd.GetNature() == Nature.Genetic);
sequenceTypes = EnumExtensions.ToArray <SequenceType>().Where(st => st.GetNature() == Nature.Genetic);
groups = EnumExtensions.ToArray <Group>().Where(g => g.GetNature() == Nature.Genetic);
}
return(new Dictionary <string, object>
{
{ "matters", matterRepository.GetMatterSelectList() },
{ "natures", natures },
{ "notations", notations.ToSelectListWithNature() },
{ "remoteDbs", remoteDbs.ToSelectListWithNature() },
{ "sequenceTypes", sequenceTypes.ToSelectListWithNature() },
{ "groups", groups.ToSelectListWithNature() },
{ "languages", EnumHelper.GetSelectList(typeof(Language)) },
{ "translators", EnumHelper.GetSelectList(typeof(Translator)) }
});
}
/// <summary>
/// Fills view data.
/// </summary>
/// <param name="minSelectedMatters">
/// The minimum selected matters.
/// </param>
/// <param name="maxSelectedMatters">
/// The maximum selected matters.
/// </param>
/// <param name="filter">
/// The matters filter.
/// </param>
/// <param name="submitName">
/// The submit button name.
/// </param>
/// <returns>
/// The <see cref="Dictionary{String, Object}"/>.
/// </returns>
public Dictionary <string, object> FillViewData(int minSelectedMatters, int maxSelectedMatters, Func <Matter, bool> filter, string submitName)
{
Dictionary <string, object> data = GetMattersData(minSelectedMatters, maxSelectedMatters, filter);
IEnumerable <SelectListItem> natures;
IEnumerable <Notation> notations;
IEnumerable <SequenceType> sequenceTypes;
IEnumerable <Group> groups;
if (AccountHelper.IsAdmin())
{
natures = EnumHelper.GetSelectList(typeof(Nature));
notations = EnumExtensions.ToArray <Notation>();
sequenceTypes = EnumExtensions.ToArray <SequenceType>();
groups = EnumExtensions.ToArray <Group>();
}
else
{
natures = new[] { Nature.Genetic }.ToSelectList();
notations = new[] { Notation.Nucleotides };
sequenceTypes = EnumExtensions.ToArray <SequenceType>().Where(st => st.GetNature() == Nature.Genetic);
groups = EnumExtensions.ToArray <Group>().Where(g => g.GetNature() == Nature.Genetic);
}
data.Add("submitName", submitName);
data.Add("natures", natures);
data.Add("notations", notations.ToSelectListWithNature());
data.Add("languages", EnumHelper.GetSelectList(typeof(Language)));
data.Add("translators", EnumHelper.GetSelectList(typeof(Translator)));
data.Add("pauseTreatments", EnumHelper.GetSelectList(typeof(PauseTreatment)));
data.Add("sequenceTypes", sequenceTypes.ToSelectListWithNature(true));
data.Add("groups", groups.ToSelectListWithNature(true));
return(data);
}
private void TransformOrders()
{
// TODO: get rid of IndexOf here.
int[] ordersIds = Orders.Select(o => Orders.IndexOf(o)).ToArray();
TransformationsData = ordersIds.AsParallel().AsOrdered().Select(el => new OrderTransformationData
{
ResultTransformation = EnumExtensions.ToArray <OrderTransformation>().AsParallel().AsOrdered().Select(t => TransformOrder(t, el)).ToArray()
}).ToArray();
List <OrderTransformationData> resultData = ordersIds.AsParallel().AsOrdered().Select(el => new OrderTransformationData
{
ResultTransformation = TransformationsData[el].ResultTransformation,
UniqueFinalOrdersCount = CalculateUniqueOrdersCount(el)
}).ToList();
TransformationsData = resultData.ToArray();
}
private int CalculateUniqueOrdersCount(int id)
{
OrderTransformation[] transformationTypes = EnumExtensions.ToArray <OrderTransformation>();
bool completed = false;
var ordersForChecking = new List <int> {
id
};
var checkedOrders = new List <int> {
id
};
while (!completed)
{
var newOrders = new List <int>();
foreach (int order in ordersForChecking)
{
for (int i = 0; i < transformationTypes.Length; i++)
{
if (!checkedOrders.Contains(TransformationsData[order].ResultTransformation[i].OrderId))
{
checkedOrders.Add(TransformationsData[order].ResultTransformation[i].OrderId);
newOrders.Add(TransformationsData[order].ResultTransformation[i].OrderId);
}
}
}
if (newOrders.Count > 0)
{
ordersForChecking = newOrders;
}
else
{
completed = true;
}
}
return(checkedOrders.Count);
}
public ActionResult Index(long[] matterIds, short characteristicLinkId, short[] characteristicLinkIds, Feature[] features)
{
return(CreateTask(() =>
{
matterIds = matterIds.OrderBy(m => m).ToArray();
var matterNames = new string[matterIds.Length];
var remoteIds = new string[matterIds.Length];
var subsequencesCharacteristicsNames = new string[characteristicLinkIds.Length];
var subsequencesCharacteristicsList = new SelectListItem[characteristicLinkIds.Length];
var attributeValuesCache = new AttributeValueCacheManager();
long[] sequenceIds;
using (var db = new LibiadaWebEntities())
{
DnaSequence[] parentSequences = db.DnaSequence.Include(s => s.Matter)
.Where(s => s.Notation == Notation.Nucleotides && matterIds.Contains(s.MatterId))
.OrderBy(s => s.MatterId)
.ToArray();
for (int n = 0; n < parentSequences.Length; n++)
{
matterNames[n] = parentSequences[n].Matter.Name;
remoteIds[n] = parentSequences[n].RemoteId;
}
var geneticSequenceRepository = new GeneticSequenceRepository(db);
sequenceIds = geneticSequenceRepository.GetNucleotideSequenceIds(matterIds);
}
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
string sequenceCharacteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkId);
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
subsequencesCharacteristicsNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k]);
subsequencesCharacteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = subsequencesCharacteristicsNames[k],
Selected = false
};
}
double[] characteristics = SequencesCharacteristicsCalculator.Calculate(sequenceIds, characteristicLinkId);
var sequencesData = new SequenceData[matterIds.Length];
for (int i = 0; i < matterIds.Length; i++)
{
// all subsequence calculations
SubsequenceData[] subsequencesData = CalculateSubsequencesCharacteristics(
characteristicLinkIds,
features,
sequenceIds[i]);
attributeValuesCache.FillAttributeValues(subsequencesData);
sequencesData[i] = new SequenceData(matterIds[i], matterNames[i], remoteIds[i], characteristics[i], subsequencesData);
}
// sorting organisms by their characteristic
sequencesData = sequencesData.OrderBy(r => r.Characteristic).ToArray();
List <AttributeValue> allAttributeValues = attributeValuesCache.AllAttributeValues;
var result = new Dictionary <string, object>
{
{ "result", sequencesData },
{ "subsequencesCharacteristicsNames", subsequencesCharacteristicsNames },
{ "subsequencesCharacteristicsList", subsequencesCharacteristicsList },
{ "sequenceCharacteristicName", sequenceCharacteristicName },
{ "features", features.ToSelectList(features).ToDictionary(f => f.Value) },
{ "attributes", EnumExtensions.ToArray <Attribute>().ToDictionary(a => (byte)a, a => a.GetDisplayValue()) },
{ "attributeValues", allAttributeValues.Select(sa => new { attribute = sa.AttributeId, value = sa.Value }) }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(long matterId, OrderTransformation[] transformationsSequence, int iterationsCount)
{
return(CreateTask(() =>
{
var sequenceId = db.CommonSequence.Single(c => c.MatterId == matterId).Id;
var sequence = commonSequenceRepository.GetLibiadaChain(sequenceId);
for (int j = 0; j < iterationsCount; j++)
{
for (int i = 0; i < transformationsSequence.Length; i++)
{
sequence = transformationsSequence[i] == OrderTransformation.Dissimilar ? DissimilarChainFactory.Create(sequence)
: HighOrderFactory.Create(sequence, EnumExtensions.GetLink(transformationsSequence[i]));
}
}
var transformations = new Dictionary <int, string>();
for (int i = 0; i < transformationsSequence.Length; i++)
{
transformations.Add(i, transformationsSequence[i].GetDisplayValue());
}
var result = new Dictionary <string, object>
{
{ "chain", sequence.ToString(" ") },
{ "transformationsList", transformations },
{ "iterationsCount", iterationsCount }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(long matterId, OrderTransformation[] transformationsSequence, int iterationsCount)
{
return(CreateTask(() =>
{
var sequenceId = db.CommonSequence.Single(c => c.MatterId == matterId).Id;
var sequence = commonSequenceRepository.GetLibiadaChain(sequenceId);
int loopIteration = -1;
int lastIteration = -1;
var transformationsResult = new List <int[]>();
transformationsResult.Add(sequence.Building);
for (int j = 0; j < iterationsCount; j++)
{
for (int i = 0; i < transformationsSequence.Length; i++)
{
sequence = transformationsSequence[i] == OrderTransformation.Dissimilar ? DissimilarChainFactory.Create(sequence)
: HighOrderFactory.Create(sequence, EnumExtensions.GetLink(transformationsSequence[i]));
if (transformationsResult.Any(tr => tr.SequenceEqual(sequence.Building)))
{
loopIteration = transformationsResult.FindIndex(tr => tr.SequenceEqual(sequence.Building)) + 1;
lastIteration = j + 1;
goto exitLoops;
}
transformationsResult.Add(sequence.Building);
}
}
exitLoops:
var transformations = new Dictionary <int, string>();
for (int i = 0; i < transformationsSequence.Length; i++)
{
transformations.Add(i, transformationsSequence[i].GetDisplayValue());
}
var result = new Dictionary <string, object>
{
{ "chain", sequence },
{ "transformationsList", transformations },
{ "iterationsCount", iterationsCount },
{ "transformationsResult", transformationsResult },
{ "loopIteration", loopIteration },
{ "lastIteration", lastIteration }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(
OrderTransformation[] transformationsSequence,
int iterationsCount,
string[] customSequences,
bool localFile,
HttpPostedFileBase[] file)
{
return(CreateTask(() =>
{
int sequencesCount = localFile ? Request.Files.Count : customSequences.Length;
var sourceSequences = new string[sequencesCount];
var sequences = new Chain[sequencesCount];
var names = new string[sequencesCount];
for (int i = 0; i < sequencesCount; i++)
{
if (localFile)
{
var sequenceStream = FileHelper.GetFileStream(file[i]);
var fastaSequence = NcbiHelper.GetFastaSequence(sequenceStream);
sourceSequences[i] = fastaSequence.ConvertToString();
names[i] = fastaSequence.ID;
}
else
{
sourceSequences[i] = customSequences[i];
names[i] = $"Custom sequence {i + 1}. Length: {customSequences[i].Length}";
}
}
for (int k = 0; k < sequencesCount; k++)
{
sequences[k] = new Chain(sourceSequences[k]);
for (int j = 0; j < iterationsCount; j++)
{
for (int i = 0; i < transformationsSequence.Length; i++)
{
sequences[k] = transformationsSequence[i] == OrderTransformation.Dissimilar
? DissimilarChainFactory.Create(sequences[k])
: HighOrderFactory.Create(sequences[k], EnumExtensions.GetLink(transformationsSequence[i]));
}
}
}
var transformations = transformationsSequence.Select(ts => ts.GetDisplayValue());
var result = new Dictionary <string, object>
{
{ "names", names },
{ "sequences", sequences.Select((s, i) => new { name = names[i], value = s.ToString(" ") }).ToArray() },
{ "transformationsList", transformations },
{ "iterationsCount", iterationsCount }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(
OrderTransformation[] transformationsSequence,
int iterationsCount,
short[] characteristicLinkIds,
string[] customSequences,
bool localFile,
HttpPostedFileBase[] file)
{
return(CreateTask(() =>
{
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
int sequencesCount = localFile ? Request.Files.Count : customSequences.Length;
var sequences = new string[sequencesCount];
var sequencesNames = new string[sequencesCount];
for (int i = 0; i < sequencesCount; i++)
{
if (localFile)
{
Stream sequenceStream = FileHelper.GetFileStream(file[i]);
ISequence fastaSequence = NcbiHelper.GetFastaSequence(sequenceStream);
sequences[i] = fastaSequence.ConvertToString();
sequencesNames[i] = fastaSequence.ID;
}
else
{
sequences[i] = customSequences[i];
sequencesNames[i] = $"Custom sequence {i + 1}. Length: {customSequences[i].Length}";
}
}
var sequencesCharacteristics = new SequenceCharacteristics[sequences.Length];
for (int j = 0; j < sequences.Length; j++)
{
var characteristics = new double[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
var sequence = new Chain(sequences[j]);
for (int l = 0; l < iterationsCount; l++)
{
for (int w = 0; w < transformationsSequence.Length; w++)
{
sequence = transformationsSequence[w] == OrderTransformation.Dissimilar ? DissimilarChainFactory.Create(sequence)
: HighOrderFactory.Create(sequence, EnumExtensions.GetLink(transformationsSequence[w]));
}
}
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkIds[k]);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkIds[k]);
IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
characteristics[k] = calculator.Calculate(sequence, link);
}
sequencesCharacteristics[j] = new SequenceCharacteristics
{
MatterName = sequencesNames[j],
Characteristics = characteristics
};
}
string[] characteristicNames = characteristicLinkIds.Select(c => characteristicTypeLinkRepository.GetCharacteristicName(c)).ToArray();
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int i = 0; i < characteristicNames.Length; i++)
{
characteristicsList[i] = new SelectListItem
{
Value = i.ToString(),
Text = characteristicNames[i],
Selected = false
};
}
var transformations = new Dictionary <int, string>();
for (int i = 0; i < transformationsSequence.Length; i++)
{
transformations.Add(i, transformationsSequence[i].GetDisplayValue());
}
var result = new Dictionary <string, object>
{
{ "characteristics", sequencesCharacteristics },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList },
{ "transformationsList", transformations },
{ "iterationsCount", iterationsCount }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(
long[] matterIds,
OrderTransformation[] transformationsSequence,
int iterationsCount,
short[] characteristicLinkIds,
Notation[] notations,
Language[] languages,
Translator?[] translators,
PauseTreatment[] pauseTreatments,
bool[] sequentialTransfers)
{
return(CreateTask(() =>
{
var db = new LibiadaWebEntities();
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
var commonSequenceRepository = new CommonSequenceRepository(db);
var mattersCharacteristics = new object[matterIds.Length];
matterIds = matterIds.OrderBy(m => m).ToArray();
Dictionary <long, Matter> matters = db.Matter.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id);
for (int i = 0; i < matterIds.Length; i++)
{
long matterId = matterIds[i];
var characteristics = new double[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
Notation notation = notations[k];
long sequenceId;
switch (matters[matterId].Nature)
{
case Nature.Literature:
Language language = languages[k];
Translator translator = translators[k] ?? Translator.NoneOrManual;
sequenceId = db.LiteratureSequence.Single(l => l.MatterId == matterId &&
l.Notation == notation &&
l.Language == language &&
l.Translator == translator).Id;
break;
case Nature.Music:
PauseTreatment pauseTreatment = pauseTreatments[k];
bool sequentialTransfer = sequentialTransfers[k];
sequenceId = db.MusicSequence.Single(m => m.MatterId == matterId &&
m.Notation == notation &&
m.PauseTreatment == pauseTreatment &&
m.SequentialTransfer == sequentialTransfer).Id;
break;
default:
sequenceId = db.CommonSequence.Single(c => c.MatterId == matterId && c.Notation == notation).Id;
break;
}
Chain sequence = commonSequenceRepository.GetLibiadaChain(sequenceId);
for (int l = 0; l < iterationsCount; l++)
{
for (int j = 0; j < transformationsSequence.Length; j++)
{
sequence = transformationsSequence[j] == OrderTransformation.Dissimilar ? DissimilarChainFactory.Create(sequence)
: HighOrderFactory.Create(sequence, EnumExtensions.GetLink(transformationsSequence[j]));
}
}
int characteristicLinkId = characteristicLinkIds[k];
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
characteristics[k] = calculator.Calculate(sequence, link);
}
mattersCharacteristics[i] = new { matterName = matters[matterId].Name, characteristics };
}
var characteristicNames = new string[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k], notations[k]);
}
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int i = 0; i < characteristicNames.Length; i++)
{
characteristicsList[i] = new SelectListItem
{
Value = i.ToString(),
Text = characteristicNames[i],
Selected = false
};
}
var transformations = new Dictionary <int, string>();
for (int i = 0; i < transformationsSequence.Length; i++)
{
transformations.Add(i, transformationsSequence[i].GetDisplayValue());
}
var result = new Dictionary <string, object>
{
{ "characteristics", mattersCharacteristics },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList },
{ "transformationsList", transformations },
{ "iterationsCount", iterationsCount }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(
long[] matterIds,
OrderTransformation[] transformationsSequence,
int iterationsCount,
short[] characteristicLinkIds,
Notation[] notations,
Language?[] languages,
Translator?[] translators,
PauseTreatment?[] pauseTreatments,
bool?[] sequentialTransfers,
ImageOrderExtractor?[] trajectories)
{
return(CreateTask(() =>
{
Dictionary <long, string> mattersNames = Cache.GetInstance().Matters.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id, m => m.Name);
Chain[][] sequences = new Chain[matterIds.Length][];
using (var db = new LibiadaWebEntities())
{
var commonSequenceRepository = new CommonSequenceRepository(db);
long[][] sequenceIds = commonSequenceRepository.GetSequenceIds(matterIds,
notations,
languages,
translators,
pauseTreatments,
sequentialTransfers,
trajectories);
for (int i = 0; i < matterIds.Length; i++)
{
sequences[i] = new Chain[characteristicLinkIds.Length];
for (int j = 0; j < characteristicLinkIds.Length; j++)
{
sequences[i][j] = commonSequenceRepository.GetLibiadaChain(sequenceIds[i][j]);
}
}
}
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
var sequencesCharacteristics = new SequenceCharacteristics[matterIds.Length];
matterIds = matterIds.OrderBy(m => m).ToArray();
for (int i = 0; i < matterIds.Length; i++)
{
long matterId = matterIds[i];
var characteristics = new double[characteristicLinkIds.Length];
for (int j = 0; j < characteristicLinkIds.Length; j++)
{
Notation notation = notations[j];
Chain sequence = sequences[i][j];
for (int l = 0; l < iterationsCount; l++)
{
for (int k = 0; k < transformationsSequence.Length; k++)
{
sequence = transformationsSequence[k] == OrderTransformation.Dissimilar ? DissimilarChainFactory.Create(sequence)
: HighOrderFactory.Create(sequence, EnumExtensions.GetLink(transformationsSequence[k]));
}
}
int characteristicLinkId = characteristicLinkIds[j];
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
characteristics[j] = calculator.Calculate(sequence, link);
}
sequencesCharacteristics[i] = new SequenceCharacteristics
{
MatterName = mattersNames[matterId],
Characteristics = characteristics
};
}
var characteristicNames = new string[characteristicLinkIds.Length];
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k], notations[k]);
characteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = characteristicNames[k],
Selected = false
};
}
var transformations = transformationsSequence.Select(ts => ts.GetDisplayValue());
var result = new Dictionary <string, object>
{
{ "characteristics", sequencesCharacteristics },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList },
{ "transformationsList", transformations },
{ "iterationsCount", iterationsCount }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
