Пример #1
0
        public void Question2(drugbanktype drugbank)
        {
            var path      = InitQuestion(2);
            var drugQuery = drugbank.drug
                            .Where(d => d.classification != null);

            drugQuery
            .SelectMany(d => d.targets
                        .Select(t => new DrugClassificationAndTargetSubtype(d.classification, d.drugbankid.First(id => id.primary).Value, t.id, "target")))
            .ToFile(path, "drug_classification_targets.tsv");

            drugQuery
            .SelectMany(d => d.transporters
                        .Select(t => new DrugClassificationAndTargetSubtype(d.classification, d.drugbankid.First(id => id.primary).Value, t.id, "transporter")))
            .ToFile(path, "drug_classification_transporters.tsv");

            drugQuery
            .SelectMany(d => d.enzymes
                        .Select(t => new DrugClassificationAndTargetSubtype(d.classification, d.drugbankid.First(id => id.primary).Value, t.id, "enzyme")))
            .ToFile(path, "drug_classification_enzymes.tsv");

            drugQuery
            .SelectMany(d => d.carriers
                        .Select(t => new DrugClassificationAndTargetSubtype(d.classification, d.drugbankid.First(id => id.primary).Value, t.id, "carrier")))
            .ToFile(path, "drug_classification_carriers.tsv");
        }
Пример #2
0
        public void Question7(drugbanktype drugbank)
        {
            var path = InitQuestion(7);

            var targetTargetLinks = new HashSet <TargetTargetLink>();
            TargetTargetLink link;

            foreach (var drug in drugbank.drug)
            {
                foreach (var target1 in drug.targets)
                {
                    foreach (var target2 in drug.targets)
                    {
                        if (target1 != target2)
                        {
                            link = new TargetTargetLink(target1.id, target2.id);
                            targetTargetLinks.TryGetValue(link, out TargetTargetLink existingLink);
                            link            = existingLink ?? link;
                            link.LinkValue += 1;
                            targetTargetLinks.Add(link);
                        }
                    }
                }
            }

            foreach (var targetTargetLink in targetTargetLinks)
            {
                targetTargetLink.LinkValue /= 2;
            }

            targetTargetLinks.ToFile(path, "target_target_link.tsv");
        }
Пример #3
0
        public void Question8(drugbanktype drugbank)
        {
            var path = InitQuestion(8);

            var drugTargetGoClassifier = drugbank.drug
                                         .SelectMany(d => d.targets
                                                     .Where(t => t.polypeptide != null)
                                                     .SelectMany(t => t.polypeptide
                                                                 .SelectMany(p => p.goclassifiers
                                                                             .Select(g => new DrugTargetGoClassifier(d, t, g))
                                                                             .Distinct())));

            drugTargetGoClassifier.ToFile(path, "drug_target_go_classifiers_with_dates.tsv");

            drugbank.drug
            .Where(d => d.targets.Length > 1)
            .SelectMany(d => d.targets
                        .Select(t => new DrugTarget(d.drugbankid.First(id => id.primary).Value, t.id)))
            .ToFile(path, "multitarget_drug_targets.tsv");

            drugbank.drug
            .Where(d => d.targets.Length == 1)
            .SelectMany(d => d.targets
                        .Select(t => new DrugTarget(d.drugbankid.First(id => id.primary).Value, t.id)))
            .ToFile(path, "singletarget_drug_targets.tsv");
        }
Пример #4
0
        public void Question4(drugbanktype drugbank)
        {
            var path = InitQuestion(4);

            drugbank.drug
            .SelectMany(d => d.targets
                        .Select(c => new DrugTargetGroup(d.drugbankid.First(id => id.primary).Value, c.id, d.groups.group)))
            .ToFile(path, "drug_targets_groups.tsv");
        }
Пример #5
0
        public void Question12(drugbanktype drugbank)
        {
            var path = InitQuestion(12);

            drugbank.drug
            .Where(d => d.prices != null)
            .SelectMany(d => d.prices
                        .Select(p => new DrugPrice(d, p)))
            .ToFile(path, "drug_prices.tsv");
        }
Пример #6
0
        public void Question9(drugbanktype drugbank)
        {
            var path = InitQuestion(9);

            var drugTargetPositions = drugbank.drug
                                      .SelectMany(d => d.targets
                                                  .Where(t => t.polypeptide != null)
                                                  .SelectMany(t => t.polypeptide
                                                              .Select(p => new DrugTargetPosition(d, t.id, p.cellularlocation))));

            drugTargetPositions.ToFile(path, "drug_target_positions.tsv");
        }
Пример #7
0
        public void Question6(drugbanktype drugbank)
        {
            var path = InitQuestion(6);

            var targets = drugbank.drug
                          .SelectMany(d => d.targets
                                      .Select(t => new DrugTarget(d.drugbankid.First(id => id.primary).Value, t.id)))
                          .GroupBy(dt => dt.TargetId)
                          .Select(group => new { targetId = group.Key, drugs = group.Select(g => g.DrugId) });

            var          drugDrugLinks = new HashSet <DrugDrugLink>();
            DrugDrugLink link;

            foreach (var target in targets)
            {
                foreach (var drug1 in target.drugs)
                {
                    foreach (var drug2 in target.drugs)
                    {
                        if (drug1 != drug2)
                        {
                            link = new DrugDrugLink(drug1, drug2);
                            drugDrugLinks.TryGetValue(link, out DrugDrugLink existingLink);
                            link            = existingLink ?? link;
                            link.LinkValue += 1;
                            drugDrugLinks.Add(link);
                        }
                    }
                }
            }

            foreach (var drugDrugLink in drugDrugLinks)
            {
                drugDrugLink.LinkValue /= 2;
            }

            drugDrugLinks.ToFile(path, "drug_drug_link.tsv");

            drugbank.drug
            .SelectMany(d => d.druginteractions
                        .Select(i => new DrugInterraction(d.drugbankid.First(id => id.primary).Value, i)))
            .ToFile(path, "drug_interactions.tsv");
        }
Пример #8
0
        public void Question3(drugbanktype drugbank)
        {
            var path = InitQuestion(3);

            drugbank.drug
            .SelectMany(d => d.carriers
                        .Select(c => new DrugTarget(d.drugbankid.First(id => id.primary).Value, c.id)))
            .ToFile(path, "drug_carriers.tsv");

            drugbank.drug
            .SelectMany(d => d.transporters
                        .Select(t => new DrugTarget(d.drugbankid.First(id => id.primary).Value, t.id)))
            .ToFile(path, "drug_transporters.tsv");

            drugbank.drug
            .SelectMany(d => d.enzymes
                        .Select(e => new DrugTarget(d.drugbankid.First(id => id.primary).Value, e.id)))
            .ToFile(path, "drug_enzymes.tsv");
        }
Пример #9
0
        public void Question1(drugbanktype drugbank)
        {
            var path = InitQuestion(1);

            var drugtargets = drugbank.drug
                              .SelectMany(d => d.targets
                                          .Select(t => new DrugTarget(d.drugbankid.First(id => id.primary).Value, t.id)));

            drugtargets.ToFile(path, "drug_targets.tsv");

            var drugTargetsCountQuery = drugbank.drug.Select(d => new { id = d.drugbankid.First(id => id.primary).Value, targetsCount = d.targets.Count() });
            var maxTargets            = drugTargetsCountQuery.Max(d => d.targetsCount);
            var minTargets            = drugTargetsCountQuery.Min(d => d.targetsCount);

            var drugsWithTargets = drugTargetsCountQuery.Where(d => d.targetsCount == maxTargets);

            File.WriteAllLines(Path.Combine(path, "drugs_with_max_targets_count.tsv"), drugsWithTargets.Select(d => d.id).Prepend($"max targets, {maxTargets}"));

            drugsWithTargets = drugTargetsCountQuery.Where(d => d.targetsCount == minTargets);
            File.WriteAllLines(Path.Combine(path, "drugs_with_min_targets_count.tsv"), drugsWithTargets.Select(d => d.id).Prepend($"min targets, {minTargets}"));

            File.WriteAllText(Path.Combine(path, "mean_targets_count.tsv"), drugTargetsCountQuery.Select(d => d.targetsCount).Average().ToString());
        }
Пример #10
0
        public void Question10(drugbanktype drugbank)
        {
            var path = InitQuestion(10);

            Console.WriteLine("Enter modifications tsv file path...");

            var modsFile = Console.ReadLine();

            var mods = File.ReadAllLines(modsFile).Select(l => new Modifications(l));

            var targetModifications = drugbank.drug
                                      .SelectMany(d => d.targets
                                                  .Where(t => t.polypeptide != null)
                                                  .SelectMany(t => t.polypeptide
                                                              .Select(p => new TargetModifications(t.id, p.id, p.goclassifiers))));

            targetModifications = targetModifications.Join(mods,
                                                           t => t.UniprotId,
                                                           m => m.UniprotId,
                                                           (t, m) => new TargetModifications(t, m));

            targetModifications
            .ToFile(path, "target_mods.tsv");
        }