/// <summary>
 /// Initializes a new instance of the <see cref="SequenceData"/> class.
 /// </summary>
 /// <param name="matterId">
 /// The matter id.
 /// </param>
 /// <param name="matterName">
 /// The matter name.
 /// </param>
 /// <param name="remoteId">
 /// Sequence web api id.
 /// </param>
 /// <param name="characteristic">
 /// The characteristic.
 /// </param>
 /// <param name="subsequencesData">
 /// The genes data.
 /// </param>
 public SequenceData(long matterId, string matterName, string remoteId, double characteristic, SubsequenceData[] subsequencesData)
 {
     MatterId = matterId;
     MatterName = matterName;
     RemoteId = remoteId;
     Characteristic = characteristic;
     SubsequencesData = subsequencesData;
 }
Example #2
0
        public ActionResult Index(
            long[] matterIds,
            short characteristicLinkId,
            short subsequencesCharacteristicLinkId,
            Feature[] features,
            string maxPercentageDifference,
            string[] filters)
        {
            return(CreateTask(() =>
            {
                double percentageDifference = double.Parse(maxPercentageDifference, CultureInfo.InvariantCulture) / 100;

                var attributeValuesCache = new AttributeValueCacheManager();
                var characteristics = new SubsequenceData[matterIds.Length][];

                long[] parentSequenceIds;
                var matterNames = new string[matterIds.Length];

                int mattersCount = matterIds.Length;
                Dictionary <string, object> characteristicsTypesData;

                using (var db = new LibiadaWebEntities())
                {
                    // Sequences characteristic
                    var geneticSequenceRepository = new GeneticSequenceRepository(db);
                    long[] chains = geneticSequenceRepository.GetNucleotideSequenceIds(matterIds);

                    // Sequences characteristic
                    matterIds = OrderMatterIds(matterIds, characteristicLinkId, chains);

                    // Subsequences characteristics
                    var parentSequences = db.DnaSequence.Include(s => s.Matter)
                                          .Where(s => s.Notation == Notation.Nucleotides && matterIds.Contains(s.MatterId))
                                          .Select(s => new { s.Id, s.MatterId, MatterName = s.Matter.Name })
                                          .ToDictionary(s => s.Id);

                    parentSequenceIds = parentSequences
                                        .OrderBy(ps => Array.IndexOf(matterIds, ps.Value.MatterId))
                                        .Select(ps => ps.Key)
                                        .ToArray();

                    for (int n = 0; n < parentSequenceIds.Length; n++)
                    {
                        matterNames[n] = parentSequences[parentSequenceIds[n]].MatterName;
                    }

                    var viewDataHelper = new ViewDataHelper(db);
                    characteristicsTypesData = viewDataHelper.GetCharacteristicsData(CharacteristicCategory.Full);
                }

                FullCharacteristicRepository fullCharacteristicRepository = FullCharacteristicRepository.Instance;
                string sequenceCharacteristicName = fullCharacteristicRepository.GetCharacteristicName(characteristicLinkId);
                string characteristicName = fullCharacteristicRepository.GetCharacteristicName(subsequencesCharacteristicLinkId);

                var characteristicValueSubsequences = new Dictionary <double, List <(int matterIndex, int subsequenceIndex)> >();

                // cycle through matters
                for (int i = 0; i < mattersCount; i++)
                {
                    SubsequenceData[] subsequencesData = CalculateSubsequencesCharacteristics(
                        new[] { subsequencesCharacteristicLinkId },
                        features,
                        parentSequenceIds[i],
                        filters);

                    characteristics[i] = subsequencesData;
                    attributeValuesCache.FillAttributeValues(subsequencesData);

                    for (int j = 0; j < subsequencesData.Length; j++)
                    {
                        double value = subsequencesData[j].CharacteristicsValues[0];
                        if (characteristicValueSubsequences.TryGetValue(value, out List <(int matterIndex, int subsequenceIndex)> matterAndSubsequenceIdsList))
                        {
                            matterAndSubsequenceIdsList.Add((i, j));
                        }