public ActionResult Index(
long[] matterIds,
short[] characteristicLinkIds,
Notation[] notations,
Language?[] languages,
Translator?[] translators,
PauseTreatment?[] pauseTreatments,
bool?[] sequentialTransfers,
ImageOrderExtractor?[] trajectories,
bool rotate,
bool complementary,
uint?rotationLength)
{
return(CreateTask(() =>
{
Dictionary <long, string> mattersNames;
long[][] sequenceIds;
using (var db = new LibiadaWebEntities())
{
var commonSequenceRepository = new CommonSequenceRepository(db);
sequenceIds = commonSequenceRepository.GetSequenceIds(matterIds,
notations,
languages,
translators,
pauseTreatments,
sequentialTransfers,
trajectories);
mattersNames = Cache.GetInstance().Matters.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id, m => m.Name);
}
double[][] characteristics;
if (!rotate && !complementary)
{
characteristics = SequencesCharacteristicsCalculator.Calculate(sequenceIds, characteristicLinkIds);
}
else
{
characteristics = SequencesCharacteristicsCalculator.Calculate(sequenceIds, characteristicLinkIds, rotate, complementary, rotationLength);
}
var sequencesCharacteristics = new SequenceCharacteristics[matterIds.Length];
for (int i = 0; i < matterIds.Length; i++)
{
sequencesCharacteristics[i] = new SequenceCharacteristics
{
MatterName = mattersNames[matterIds[i]],
Characteristics = characteristics[i]
};
}
var characteristicNames = new string[characteristicLinkIds.Length];
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
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 result = new Dictionary <string, object>
{
{ "characteristics", sequencesCharacteristics },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
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[] matterIds,
short[] characteristicLinkIds,
Notation[] notations,
Language?[] languages,
Translator?[] translators,
PauseTreatment?[] pauseTreatments,
bool?[] sequentialTransfers,
ImageOrderExtractor?[] trajectories,
int clustersCount,
ClusterizationType clusterizationType,
double equipotencyWeight = 1,
double normalizedDistanceWeight = 1,
double distanceWeight = 1,
double bandwidth = 0,
int maximumClusters = 2)
{
return(CreateTask(() =>
{
Dictionary <long, string> mattersNames;
Dictionary <long, string> matters = Cache.GetInstance()
.Matters
.Where(m => matterIds.Contains(m.Id))
.ToDictionary(m => m.Id, m => m.Name);
long[][] sequenceIds;
using (var db = new LibiadaWebEntities())
{
var commonSequenceRepository = new CommonSequenceRepository(db);
sequenceIds = commonSequenceRepository.GetSequenceIds(matterIds,
notations,
languages,
translators,
pauseTreatments,
sequentialTransfers,
trajectories);
mattersNames = db.Matter.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id, m => m.Name);
}
double[][] characteristics;
characteristics = SequencesCharacteristicsCalculator.Calculate(sequenceIds, characteristicLinkIds);
var clusterizationParams = new Dictionary <string, double>
{
{ "clustersCount", clustersCount },
{ "equipotencyWeight", equipotencyWeight },
{ "normalizedDistanceWeight", normalizedDistanceWeight },
{ "distanceWeight", distanceWeight },
{ "bandwidth", bandwidth },
{ "maximumClusters", maximumClusters }
};
IClusterizator clusterizator = ClusterizatorsFactory.CreateClusterizator(clusterizationType, clusterizationParams);
int[] clusterizationResult = clusterizator.Cluster(clustersCount, characteristics);
var mattersCharacteristics = new object[matterIds.Length];
for (int i = 0; i < clusterizationResult.Length; i++)
{
mattersCharacteristics[i] = new
{
MatterName = mattersNames[matterIds[i]],
cluster = clusterizationResult[i] + 1,
Characteristics = characteristics[i]
};
}
var characteristicNames = new string[characteristicLinkIds.Length];
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
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 result = new Dictionary <string, object>
{
{ "characteristicNames", characteristicNames },
{ "characteristics", mattersCharacteristics },
{ "characteristicsList", characteristicsList },
{ "clustersCount", clusterizationResult.Distinct().Count() }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
