Esempio n. 1
0
        public List <ProteinDto> ExtractProteins(double mw, SearchParametersDto parameters)
        {
            var query = GetQuery(mw, parameters);

            var connectionString = GetConnectionString(parameters.ProtDb);
            List <SerializedProteinDataDto> prot;

            using (var connection = new SqlConnection(connectionString))
            {
                prot = connection.Query <SerializedProteinDataDto>(query).ToList();
            }

            var proteins = new List <ProteinDto>();

            foreach (var proteinInfo in prot)
            {
                var insilico = new InsilicoObjectDto()
                {
                    InsilicoMassLeft  = proteinInfo.Insilico.Split(',').Select(double.Parse).ToList(),
                    InsilicoMassRight = proteinInfo.Insilico.Split(',').Select(double.Parse).ToList()
                };

                var protein = new ProteinDto()
                {
                    Header          = proteinInfo.ID,
                    InsilicoDetails = insilico,
                    Mw       = proteinInfo.MW,
                    Sequence = proteinInfo.Seq
                };

                proteins.Add(protein);
            }
            return(proteins);
        }
Esempio n. 2
0
        private double ComputeVariableModificationsScore(ProteinDto protein, List <ProteinDto> shortlisted, List <double> peakList, SearchParametersDto parameters)
        {
            var filteredSitesA = new List <PostTranslationModificationsSiteDto>();

            EvaulateModificationSites(protein.Sequence, filteredSitesA, parameters.PtmCodeVar, parameters.PtmTolerance); // filtered sites is currently empty
            var sortedList = filteredSitesA.OrderBy(o => o.Score).ToList();

            var combos      = new List <string>();
            var siteIndices = new List <int>();

            for (var j = 1; j <= Constants.MaximumVariableModifications; j++)
            {
                foreach (var comb in Combinations(j, sortedList.Count))
                {
                    var dummy = string.Empty;
                    foreach (var t in comb)
                    {
                        dummy += t.ToString();
                        siteIndices.Add(t); // separates indices
                    }
                    combos.Add(dummy);
                    siteIndices.Add(777);
                }
            }

            if (sortedList.Count > 0)
            {
                GenerateModifiedProteins(filteredSitesA, siteIndices, protein, shortlisted, peakList, parameters);
            }

            return(0);
        }
        //STEP 2: Generate theoretical fragments of each protein
        private static void MakeAdjustment(ProteinDto prot, double rightOffset, double leftOffset, List <double> specialList, double s, List <double> specialDependecy)
        {
            for (var seqIndex = 0; seqIndex < prot.Sequence.Length - 1; seqIndex++)                                              //for Fragment
            {
                prot.InsilicoDetails.InsilicoMassLeft[seqIndex]  = prot.InsilicoDetails.InsilicoMassLeft[seqIndex] + leftOffset; // ;
                prot.InsilicoDetails.InsilicoMassRight[seqIndex] = prot.InsilicoDetails.InsilicoMassRight[seqIndex] + rightOffset;


                specialList.Add(specialDependecy[seqIndex] + s);
            }
        }
Esempio n. 4
0
        private double[] GetModifiedIonsArray(ProteinDto protein)
        {
            var modifiedIonsArray = protein.InsilicoDetails.InsilicoMassLeftAo.ToArray();

            modifiedIonsArray.AddRange(protein.InsilicoDetails.InsilicoMassLeftAstar);
            modifiedIonsArray.AddRange(protein.InsilicoDetails.InsilicoMassLeftBo);
            modifiedIonsArray.AddRange(protein.InsilicoDetails.InsilicoMassLeftBstar);
            modifiedIonsArray.AddRange(protein.InsilicoDetails.InsilicoMassRightYo);
            modifiedIonsArray.AddRange(protein.InsilicoDetails.InsilicoMassRightYstar);
            modifiedIonsArray.AddRange(protein.InsilicoDetails.InsilicoMassRightZo);
            modifiedIonsArray.AddRange(protein.InsilicoDetails.InsilicoMassRightZoo);
            return(modifiedIonsArray);
        }
Esempio n. 5
0
        private double ComputeFixedModificationScore(ProteinDto parentPro, List <ProteinDto> modifiedProteins, List <double> peakList, SearchParametersDto parameters)
        {
            var filteredSites = new List <PostTranslationModificationsSiteDto>();

            EvaulateModificationSites(parentPro.Sequence, filteredSites, parameters.PtmCodeFix);
            filteredSites = filteredSites.OrderBy(o => o.Score).ToList();

            var siteIndices = Enumerable.Range(0, filteredSites.Count).ToList();

            siteIndices.Add(777);

            if (filteredSites.Count > 0)
            {
                GenerateModifiedProteins(filteredSites, siteIndices, parentPro, modifiedProteins, peakList, parameters);
            }
            return(0);
        }
Esempio n. 6
0
        private void GenerateModifiedProteins(List <PostTranslationModificationsSiteDto> filteredSites, List <int> combos,
                                              ProteinDto parent, List <ProteinDto> shortProt, List <double> peakList, SearchParametersDto parameters)
        {
            var    dummyMw       = parent.Mw; // MW of the original sequence
            double dummyPtmScore = 0;         // ptm score of the unmodified sequence

            var sitesInfo = new List <PostTranslationModificationsSiteDto>();

            foreach (var i in combos)
            {
                if (i != 777)
                {
                    dummyMw += filteredSites.ElementAt(i).ModWeight;
                    // accumulates the mod weight of all the sites in the current combination
                    dummyPtmScore += filteredSites.ElementAt(i).Score; //accumlates the ptm score
                    sitesInfo.Add(filteredSites.ElementAt(i));
                }
                else if (i == 777)
                {
                    var temProtein = new ProteinDto()
                    {
                        Mw              = dummyMw,
                        PtmScore        = dummyPtmScore,
                        Sequence        = parent.Sequence,
                        Header          = parent.Header,
                        PstScore        = parent.PstScore,
                        InsilicoScore   = parent.InsilicoScore,
                        MwScore         = parent.MwScore,
                        Score           = parent.Score,
                        InsilicoDetails = parent.InsilicoDetails,
                        PtmParticulars  = sitesInfo
                    };

                    InsilicoFragmentationPtmCpu.insilico_fragmentation(temProtein, parameters.InsilicoFragType, parameters.HandleIons);

                    // _insilicoFilter.ComputeInsilicoScore(new List<ProteinDto>{temProtein}, peakList, parameters.HopThreshhold);
                    //temProtein.set_score(parameters.MwSweight, parameters.PstSweight, parameters.InsilicoSweight);
                    shortProt.Add(temProtein);

                    dummyMw       = parent.Mw;
                    dummyPtmScore = 0;
                    sitesInfo     = new List <PostTranslationModificationsSiteDto>();
                }
            }
        }
 public static void  insilico_fragmentation(ProteinDto prot, string clevageType, string ions)
 {
     Frag1(prot, clevageType, ions);
 }
        private static void Frag1(ProteinDto prot, string clevageType, string handleIon)
        {
            const double proton     = 1.00727647;
            const double h          = 1.007825035;
            const double c          = 12.0000;
            const double o          = 15.99491463;
            const double n          = 14.003074;
            const double oh         = o + h;
            const double co         = c + o;
            const double nh         = n + h;
            const double nh3        = n + h + h + h;
            const double h2O        = h + h + o;
            var          strprotein = prot.Sequence.ToUpper();
            var          prtlength  = strprotein.Length;                 //Gives length of Protein

            for (var seqIndex = 0; seqIndex < prtlength - 1; seqIndex++) //for Fragment
            {
                if (prot.PtmParticulars == null)
                {
                    continue;
                }
                if (prot.PtmParticulars.Count == 0)
                {
                    continue;
                }
                foreach (var ptmSite in prot.PtmParticulars)
                {
                    if (seqIndex >= ptmSite.Index)
                    {
                        prot.InsilicoDetails.InsilicoMassLeft[seqIndex] =
                            prot.InsilicoDetails.InsilicoMassLeft[seqIndex] + ptmSite.ModWeight;
                    }
                    else
                    {
                        prot.InsilicoDetails.InsilicoMassRight[seqIndex] =
                            prot.InsilicoDetails.InsilicoMassRight[seqIndex] + ptmSite.ModWeight;
                    }
                }
            }

            for (var seqIndex = 0; seqIndex < prtlength - 1; seqIndex++) //for Fragment
            {
                switch (clevageType)
                {
                case "CID":     //WHY CID in caps and in small letters(cid)???
                case "cid":
                case "bird":
                case "BIRD":
                case "imd":
                case "IMD":
                case "HCD":
                case "hcd":
                case "SID":
                case "sid":
                    prot.InsilicoDetails.InsilicoMassLeft[seqIndex]  = prot.InsilicoDetails.InsilicoMassLeft[seqIndex] + proton;
                    prot.InsilicoDetails.InsilicoMassRight[seqIndex] = prot.InsilicoDetails.InsilicoMassRight[seqIndex] + oh + 2 * h;
                    switch (handleIon)
                    {
                    case "bo":
                        prot.InsilicoDetails.InsilicoMassLeftBo.Add(prot.InsilicoDetails.InsilicoMassLeft[seqIndex] - h2O);
                        break;

                    case "bstar":
                        prot.InsilicoDetails.InsilicoMassLeftBstar.Add(prot.InsilicoDetails.InsilicoMassLeft[seqIndex] - nh3);
                        break;

                    case "ystar":
                        prot.InsilicoDetails.InsilicoMassRightYstar.Add(prot.InsilicoDetails.InsilicoMassRight[seqIndex] - nh3);
                        break;

                    case "yo":
                        prot.InsilicoDetails.InsilicoMassRightYo.Add(prot.InsilicoDetails.InsilicoMassRight[seqIndex] - h2O);
                        break;
                    }
                    break;

                case "ECD":
                case "ecd":
                case "ETD":
                case "etd":
                    prot.InsilicoDetails.InsilicoMassLeft[seqIndex]  = prot.InsilicoDetails.InsilicoMassLeft[seqIndex] + proton + n + 3 * h;
                    prot.InsilicoDetails.InsilicoMassRight[seqIndex] = prot.InsilicoDetails.InsilicoMassRight[seqIndex] + oh - nh;
                    switch (handleIon)
                    {
                    case "zd":
                        prot.InsilicoDetails.InsilicoMassRightZo.Add(prot.InsilicoDetails.InsilicoMassRight[seqIndex] + proton);
                        break;

                    case "zdd":
                        prot.InsilicoDetails.InsilicoMassRightZoo.Add(prot.InsilicoDetails.InsilicoMassRight[seqIndex] + 2 * proton);
                        break;
                    }
                    break;

                case "EDD":
                case "edd":
                case "NETD":
                case "netd":
                    prot.InsilicoDetails.InsilicoMassLeft[seqIndex]  = prot.InsilicoDetails.InsilicoMassLeft[seqIndex] + proton - co;
                    prot.InsilicoDetails.InsilicoMassRight[seqIndex] = prot.InsilicoDetails.InsilicoMassRight[seqIndex] + oh + co;
                    switch (handleIon)
                    {
                    case "ao":
                        prot.InsilicoDetails.InsilicoMassLeftAo.Add(prot.InsilicoDetails.InsilicoMassLeft[seqIndex] - h2O);
                        break;

                    case "astar":
                        prot.InsilicoDetails.InsilicoMassLeftAstar.Add(prot.InsilicoDetails.InsilicoMassLeft[seqIndex] - nh3);
                        break;
                    }
                    break;
                }
            }
        }
        private void adjustProteinForFragmentTypeAndSpecialIons(ProteinDto prot, string clevageType, string handleIon)
        {
            var strprotein = prot.Sequence.ToUpper();
            var prtlength  = strprotein.Length; //Gives length of Protein


            if (prot.PtmParticulars != null && prot.PtmParticulars.Count != 0)
            {
                for (var seqIndex = 0; seqIndex < prtlength - 1; seqIndex++) //for Fragment
                {
                    foreach (var ptmSite in prot.PtmParticulars)
                    {
                        if (seqIndex >= ptmSite.Index)
                        {
                            prot.InsilicoDetails.InsilicoMassLeft[seqIndex] =
                                prot.InsilicoDetails.InsilicoMassLeft[seqIndex] + ptmSite.ModWeight;
                        }
                        else
                        {
                            prot.InsilicoDetails.InsilicoMassRight[seqIndex] =
                                prot.InsilicoDetails.InsilicoMassRight[seqIndex] + ptmSite.ModWeight;
                        }
                    }
                }
            }

            string[] IndividualHandleIonArray = handleIon.Split(',');  // We got string of handle ions with comma separated. So, converting it into (string array) with separated ion

            for (int HandleIonIteration = 0; HandleIonIteration < IndividualHandleIonArray.Length; HandleIonIteration++)
            {
                string IndividualHandleIon = IndividualHandleIonArray[HandleIonIteration];

                for (var seqIndex = 0; seqIndex < prtlength - 1; seqIndex++) //for Fragment
                {
                    switch (clevageType.ToUpper())
                    {
                    case CleavageTypes.CID:
                    case CleavageTypes.BIRD:
                    case CleavageTypes.IMD:
                    case CleavageTypes.HCD:
                    case CleavageTypes.SID:



                        switch (IndividualHandleIon)    //(handleIon)
                        {
                        case SpecialIons.BO:
                            MakeAdjustment(prot, MassAdjustment.OH + 2 * MassAdjustment.H, MassAdjustment.Proton, prot.InsilicoDetails.InsilicoMassLeftBo, -MassAdjustment.H2O, prot.InsilicoDetails.InsilicoMassLeft);
                            break;

                        case SpecialIons.BSTAR:
                            MakeAdjustment(prot, MassAdjustment.OH + 2 * MassAdjustment.H, MassAdjustment.Proton, prot.InsilicoDetails.InsilicoMassLeftBstar, -MassAdjustment.NH3, prot.InsilicoDetails.InsilicoMassLeft);
                            break;

                        case SpecialIons.YSTAR:
                            MakeAdjustment(prot, MassAdjustment.OH + 2 * MassAdjustment.H, MassAdjustment.Proton, prot.InsilicoDetails.InsilicoMassRightYstar, -MassAdjustment.NH3, prot.InsilicoDetails.InsilicoMassRight);
                            break;

                        case SpecialIons.YO:
                            MakeAdjustment(prot, MassAdjustment.OH + 2 * MassAdjustment.H, MassAdjustment.Proton, prot.InsilicoDetails.InsilicoMassRightYo, -MassAdjustment.H2O, prot.InsilicoDetails.InsilicoMassRight);
                            break;
                        }


                        break;

                    case CleavageTypes.ECD:

                    case CleavageTypes.ETD:

                        switch (IndividualHandleIon)    //(handleIon)
                        {
                        case SpecialIons.ZD:
                            MakeAdjustment(prot, MassAdjustment.OH - MassAdjustment.NH, MassAdjustment.Proton + MassAdjustment.N + 3 * MassAdjustment.H, prot.InsilicoDetails.InsilicoMassRightZo, MassAdjustment.Proton, prot.InsilicoDetails.InsilicoMassRight);
                            break;

                        case SpecialIons.ZDD:
                            MakeAdjustment(prot, MassAdjustment.OH - MassAdjustment.NH, MassAdjustment.Proton + MassAdjustment.N + 3 * MassAdjustment.H, prot.InsilicoDetails.InsilicoMassRightYo, 2 * MassAdjustment.Proton, prot.InsilicoDetails.InsilicoMassRight);
                            break;
                        }
                        break;

                    case CleavageTypes.EDD:

                    case CleavageTypes.NETD:


                        switch (IndividualHandleIon)    //(handleIon)
                        {
                        case SpecialIons.AO:
                            MakeAdjustment(prot, MassAdjustment.OH + MassAdjustment.CO, MassAdjustment.Proton - MassAdjustment.CO, prot.InsilicoDetails.InsilicoMassLeftAo, -MassAdjustment.H2O, prot.InsilicoDetails.InsilicoMassLeft);
                            break;

                        case SpecialIons.ASTAR:
                            MakeAdjustment(prot, MassAdjustment.OH + MassAdjustment.CO, MassAdjustment.Proton - MassAdjustment.CO, prot.InsilicoDetails.InsilicoMassLeftAstar, -MassAdjustment.NH3, prot.InsilicoDetails.InsilicoMassLeft);
                            break;
                        }
                        break;
                    }
                }
            }
        }
Esempio n. 10
0
        private SearchResult GetSearchResultModel(string queryTd, int fileId, string headerTag, ProteinDto protein, Guid resId)
        {
            var searchResult = new SearchResult
            {
                QueryId       = queryTd,
                Sequence      = protein.Sequence,
                FileId        = fileId.ToString(),
                Header        = headerTag,
                InsilicoScore = protein.InsilicoScore,
                Mw            = protein.Mw,
                MwScore       = protein.MwScore,
                PstScore      = protein.PstScore,
                PtmScore      = protein.PtmScore,
                ResultId      = resId.ToString(),
                Score         = protein.Score
            };

            return(searchResult);
        }