Пример #1
0
        public void TestWriteAccessDb(string path, int numberConsensus, int numberProteins, int numberEvidences)
        {
            var writer        = new AccessTargetDatabaseWriter();
            var options       = new Options();
            var database      = new TargetDatabase();
            var evidenceCount = 1;

            for (var i = 1; i <= numberConsensus; i++)
            {
                var target = new ConsensusTarget {
                    Id = i
                };

                for (var k = 1; k <= numberProteins; k++)
                {
                    var protein = new ProteinInformation
                    {
                        ProteinName   = "Access_Test" + k,
                        CleavageState = clsPeptideCleavageStateCalculator.ePeptideCleavageStateConstants.Full,
                        TerminusState =
                            clsPeptideCleavageStateCalculator.ePeptideTerminusStateConstants.ProteinNTerminus
                    };
                    protein.Consensus.Add(target);

                    for (var j = 1; j <= numberEvidences; j++)
                    {
                        var evidence = new Evidence
                        {
                            AnalysisId   = j,
                            Charge       = 1,
                            Id           = evidenceCount,
                            CleanPeptide = "MIKEDEGAN" + evidenceCount,
                            Sequence     = "BIGBIRD" + evidenceCount,
                            Mz           = 405,
                            Scan         = evidenceCount++,
                            PeptideInfo  = new TargetPeptideInfo()
                        };

                        evidence.AddProtein(protein);
                        target.AddEvidence(evidence);
                    }

                    target.AddProtein(protein);
                    target.CalculateStatistics();
                }
                target.TheoreticalMonoIsotopicMass = 100.0;
                target.AverageNet   = .6;
                target.PredictedNet = .7;

                database.ConsensusTargets.Add(target);
            }

            if (File.Exists(GetTestSuiteDataPath(path)))
            {
                File.Delete(GetTestSuiteDataPath(path));
            }


            writer.Write(database, options, GetTestSuiteDataPath(path));
        }
Пример #2
0
        /// <summary>
        /// Store Protein Info
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="result"></param>
        protected static void StoreProteinInfo(clsPHRPReader reader, Evidence result)
        {
            foreach (var p in reader.CurrentPSM.ProteinDetails)
            {
                var protein = new ProteinInformation
                {
                    ProteinName   = p.Value.ProteinName,
                    CleavageState = p.Value.CleavageState,
                    TerminusState = p.Value.TerminusState,
                    ResidueStart  = p.Value.ResidueStart,
                    ResidueEnd    = p.Value.ResidueEnd
                };

                result.Proteins.Add(protein);
            }
        }
Пример #3
0
        public void TestWriteDatabase(string path, int numberOfTargets, int numberOfEvidences)
        {
            var reader        = new SqLiteTargetDatabaseWriter();
            var options       = new Options();
            var database      = new TargetDatabase();
            var proteinCount  = 1;
            var evidenceCount = 1;

            for (var i = 1; i <= numberOfTargets; i++)
            {
                var target = new ConsensusTarget {
                    Id = i
                };

                var protein = new ProteinInformation
                {
                    ProteinName   = "SO_Test" + proteinCount++,
                    CleavageState = clsPeptideCleavageStateCalculator.ePeptideCleavageStateConstants.Full,
                    TerminusState = clsPeptideCleavageStateCalculator.ePeptideTerminusStateConstants.ProteinNTerminus,
                };
                protein.Consensus.Add(target);

                for (var j = 1; j <= numberOfEvidences; j++)
                {
                    var evidence = new Evidence
                    {
                        AnalysisId   = j,
                        Charge       = 1,
                        Id           = evidenceCount,
                        CleanPeptide = "MIKEDEGAN" + evidenceCount,
                        Sequence     = "BIGBIRD" + evidenceCount,
                        Mz           = 405,
                        Scan         = evidenceCount++,
                        PeptideInfo  = new TargetPeptideInfo()
                    };

                    evidence.AddProtein(protein);
                    target.AddEvidence(evidence);
                }
                target.AddProtein(protein);
                target.CalculateStatistics();
                database.ConsensusTargets.Add(target);
            }
            reader.Write(database, options, GetTestSuiteDataPath(path));
        }
Пример #4
0
        public TargetDatabase ReadDb(string path)
        {
            // Read in the data from the access database
            // put it into a text file (?)
            // Read the data from the text file into program
            var accApplication = new ACCESS.Application();

            var    pathPieces = path.Split('\\');
            string directory  = "";

            foreach (var piece in pathPieces)
            {
                if (piece.Contains("."))
                {
                    continue;
                }
                directory += piece;
                directory += "\\";
            }

            accApplication.OpenCurrentDatabase(path);
            accApplication.DoCmd.TransferText(TransferType: ACCESS.AcTextTransferType.acExportDelim,
                                              TableName: "AMT", FileName: directory + "outTempAMT.txt", HasFieldNames: true);
            accApplication.DoCmd.TransferText(TransferType: ACCESS.AcTextTransferType.acExportDelim,
                                              TableName: "AMT_Proteins", FileName: directory + "outTempAMT_Proteins.txt", HasFieldNames: true);
            accApplication.DoCmd.TransferText(TransferType: ACCESS.AcTextTransferType.acExportDelim,
                                              TableName: "AMT_to_Protein_Map", FileName: directory + "outTempAMT_to_Protein_Map.txt", HasFieldNames: true);
            accApplication.CloseCurrentDatabase();
            accApplication.Quit();

            // Put the data into its objects
            // AMT stuff going in Consensus targets
            // NET, MonoMass, Pred. Net, Peptide (Sequence with numeric mods), ID (can be crushed later)
            // OBSERVED <-- number of times this peptide was seen in the AMT
            // for <observed> times, add an evidence with the info? would make sense and would allow the stats calcs to be accurate
            // Prot stuff going into ProteinInfo
            // Prot name only thing important for MTDB, ID (can be crushed later)
            // AMT map
            // Link Consensus and Protein (ct[ct_id].protein.add(protein[prot_id]))

            var consensusTargets = new Dictionary <int, ConsensusTarget>();
            var proteins         = new Dictionary <int, ProteinInformation>();

            var ctReader   = new StreamReader(directory + "outTempAMT.txt");
            var protReader = new StreamReader(directory + "outTempAMT_Proteins.txt");
            var mapReader  = new StreamReader(directory + "outTempAMT_to_Protein_Map.txt");

            // Read the headers for the files
            ctReader.ReadLine();
            protReader.ReadLine();
            mapReader.ReadLine();

            // Read the first "Data" lines from the files
            var ctLine   = ctReader.ReadLine();
            var protLine = protReader.ReadLine();
            var mapLine  = mapReader.ReadLine();

            while (ctLine != null)
            {
                var pieces = ctLine.Split(',');

                var target = new ConsensusTarget
                {
                    Id = Convert.ToInt32(pieces[0]),
                    TheoreticalMonoIsotopicMass = Convert.ToDouble(pieces[1]),
                    AverageNet             = Convert.ToDouble(pieces[2]),
                    PredictedNet           = Convert.ToDouble(pieces[3]),
                    EncodedNumericSequence = pieces[6]
                };
                var totalEvidences = Convert.ToInt32(pieces[4]);
                var normScore      = Convert.ToDouble(pieces[5]);
                for (var evNum = 0; evNum < totalEvidences; evNum++)
                {
                    var evidence = new Evidence
                    {
                        ObservedNet = target.AverageNet,
                        ObservedMonoisotopicMass = target.TheoreticalMonoIsotopicMass,
                        PredictedNet             = target.PredictedNet,
                        NormalizedScore          = normScore,
                        SeqWithNumericMods       = target.EncodedNumericSequence,
                        Parent = target
                    };
                    target.Evidences.Add(evidence);
                }
                consensusTargets.Add(target.Id, target);
                ctLine = ctReader.ReadLine();
            }

            while (protLine != null)
            {
                var pieces = protLine.Split(',');

                var protein = new ProteinInformation
                {
                    ProteinName = pieces[1]
                };
                proteins.Add(Convert.ToInt32(pieces[0]), protein);
                protLine = protReader.ReadLine();
            }

            while (mapLine != null)
            {
                var pieces = mapLine.Split(',');

                consensusTargets[Convert.ToInt32(pieces[0])].AddProtein(proteins[Convert.ToInt32(pieces[1])]);
                mapLine = mapReader.ReadLine();
            }

            ctReader.Close();
            protReader.Close();
            mapReader.Close();

            File.Delete(directory + "outTempAMT.txt");
            File.Delete(directory + "outTempAMT_Proteins.txt");
            File.Delete(directory + "outTempAMT_to_Protein_Map.txt");

            var database = new TargetDatabase();

            foreach (var target in consensusTargets)
            {
                database.AddConsensusTarget(target.Value);
            }
            database.Proteins = proteins.Values.ToList();

            return(database);
        }
Пример #5
0
        /// <summary>
        /// Map the results of a MZIdentML read to MSGF+
        /// </summary>
        /// <param name="results">Object to populate with the results of the Mapping</param>
        /// <param name="path">Path to MZIdentML file</param>
        private void MapToMsgf(List <MsgfPlusResult> results, string path)
        {
            var filter = new MsgfPlusTargetFilter(ReaderOptions);

            var cleavageStateCalculator = new clsPeptideCleavageStateCalculator();

            var i     = 0;
            var total = m_specItems.Count;

            // Go through each Spectrum ID and map it to an MSGF+ result
            foreach (var item in m_specItems)
            {
                i++;
                if (i % 500 == 0)
                {
                    UpdateProgress((100 * ((float)i / total)));
                }
                // Skip this PSM if it doesn't pass the import filters
                // Note that qValue is basically FDR
                double qValue = item.Value.QValue;

                double specProb = item.Value.SpecEv;

                if (filter.ShouldFilter(qValue, specProb))
                {
                    continue;
                }

                if (item.Value.PepEvidence.Count == 0)
                {
                    continue;
                }

                var evidence = item.Value.PepEvidence[0];

                var result = new MsgfPlusResult
                {
                    AnalysisId               = i,
                    Charge                   = Convert.ToInt16(item.Value.Charge),
                    CleanPeptide             = item.Value.Peptide.Sequence,
                    SeqWithNumericMods       = null,
                    MonoisotopicMass         = clsPeptideMassCalculator.ConvoluteMass(item.Value.CalMz, item.Value.Charge, 0),
                    ObservedMonoisotopicMass = clsPeptideMassCalculator.ConvoluteMass(item.Value.ExperimentalMz, item.Value.Charge, 0),
                    MultiProteinCount        = Convert.ToInt16(item.Value.PepEvCount),
                    Scan              = item.Value.ScanNum,
                    Sequence          = evidence.Pre + "." + item.Value.Peptide.Sequence + "." + evidence.Post,
                    Mz                = 0,
                    SpecProb          = specProb,
                    DelM              = 0,
                    ModificationCount = Convert.ToInt16(item.Value.Peptide.Mods.Count)
                };

                // Populate some mass related items
                result.DelM    = result.ObservedMonoisotopicMass - result.MonoisotopicMass;
                result.DelMPpm = clsPeptideMassCalculator.MassToPPM(result.DelM, result.ObservedMonoisotopicMass);
                // We could compute m/z:
                //     Mz = clsPeptideMassCalculator.ConvoluteMass(result.ObservedMonoisotopicMass, 0, result.Charge);
                // But it's stored in the mzid file, so we'll use that
                result.Mz = item.Value.ExperimentalMz;

                StoreDatasetInfo(result, path);

                result.DataSet.Tool = LcmsIdentificationTool.MZIdentML;

                // Populate items specific to the MSGF+ results (stored as mzid)

                result.Reference = evidence.DbSeq.Accession;

                var eCleavageState = cleavageStateCalculator.ComputeCleavageState(item.Value.Peptide.Sequence, evidence.Pre, evidence.Post);
                result.NumTrypticEnds = clsPeptideCleavageStateCalculator.CleavageStateToShort(eCleavageState);

                result.DeNovoScore    = item.Value.DeNovoScore;
                result.MsgfScore      = item.Value.RawScore;
                result.SpecEValue     = item.Value.SpecEv;
                result.RankSpecEValue = item.Value.Rank;

                result.EValue            = item.Value.EValue;
                result.QValue            = qValue;
                result.DiscriminantValue = qValue;
                result.PepQValue         = item.Value.PepQValue;

                result.IsotopeError = item.Value.IsoError;

                if (result.ModificationCount > 0)
                {
                    var j = 0;

                    var numModSeq  = evidence.Pre + ".";
                    var encodedSeq = numModSeq;
                    foreach (var mod in item.Value.Peptide.Mods)
                    {
                        var ptm = new PostTranslationalModification
                        {
                            Location = mod.Key,
                            Mass     = mod.Value.Mass,
                            Formula  = UniModData.ModList[mod.Value.Tag].Formula.ToString(),
                            Name     = UniModData.ModList[mod.Value.Tag].Title
                        };
                        result.Ptms.Add(ptm);

                        for (; j < ptm.Location; j++)
                        {
                            numModSeq  = numModSeq + item.Value.Peptide.Sequence[j];
                            encodedSeq = encodedSeq + item.Value.Peptide.Sequence[j];
                        }

                        numModSeq += (ptm.Mass > 0) ? "+" : "-";
                        numModSeq  = numModSeq + ptm.Mass;

                        encodedSeq += "[" + ((ptm.Mass > 0)? "+":"-") + ptm.Formula + "]";
                    }
                    for (; j < item.Value.Peptide.Sequence.Length; j++)
                    {
                        numModSeq   = numModSeq + item.Value.Peptide.Sequence[j];
                        encodedSeq += item.Value.Peptide.Sequence[j];
                    }
                    numModSeq   = numModSeq + "." + evidence.Post;
                    encodedSeq += "." + evidence.Post;
                    result.SeqWithNumericMods        = numModSeq;
                    result.EncodedNonNumericSequence = encodedSeq;
                }
                else
                {
                    result.SeqWithNumericMods        = result.Sequence;
                    result.EncodedNonNumericSequence = result.Sequence;
                }

                result.PeptideInfo = new TargetPeptideInfo
                {
                    Peptide                = result.Sequence,
                    CleanPeptide           = result.CleanPeptide,
                    PeptideWithNumericMods = result.SeqWithNumericMods
                };


                result.SeqInfoMonoisotopicMass = result.MonoisotopicMass;
                result.ModificationDescription = null;

                foreach (var thing in item.Value.PepEvidence)
                {
                    var protein = new ProteinInformation
                    {
                        ProteinName  = thing.DbSeq.Accession,
                        ResidueStart = thing.Start,
                        ResidueEnd   = thing.End
                    };
                    ComputeTerminusState(evidence, result.NumTrypticEnds, protein);
                    result.Proteins.Add(protein);
                }

                if (result.ModificationCount > 0)
                {
                    foreach (var mod in item.Value.Peptide.Mods)
                    {
                        // TODO: Confirm that this is valid math (MEM thinks it may not be)
                        result.SeqInfoMonoisotopicMass += mod.Value.Mass;

                        result.ModificationDescription += mod.Value.Tag + ":" + mod.Key + "  ";
                    }
                }

                results.Add(result);
            }
        }
Пример #6
0
        private void ComputeTerminusState(PeptideEvidence evidence, short numTrypticEnds, ProteinInformation protein)
        {
            if (evidence.Pre[0] == '-')
            {
                if (evidence.Post[0] == '-')
                {
                    protein.TerminusState =
                        clsPeptideCleavageStateCalculator.ePeptideTerminusStateConstants.ProteinNandCCTerminus;
                    protein.CleavageState = clsPeptideCleavageStateCalculator.ePeptideCleavageStateConstants.Full;
                }
                else
                {
                    protein.TerminusState = clsPeptideCleavageStateCalculator.ePeptideTerminusStateConstants.ProteinNTerminus;
                }
            }
            else if (evidence.Post[0] == '-')
            {
                protein.TerminusState = clsPeptideCleavageStateCalculator.ePeptideTerminusStateConstants.ProteinCTerminus;
            }
            else
            {
                protein.TerminusState = clsPeptideCleavageStateCalculator.ePeptideTerminusStateConstants.None;
            }

            switch (numTrypticEnds)
            {
            case 0:
                protein.CleavageState = clsPeptideCleavageStateCalculator.ePeptideCleavageStateConstants.NonSpecific;
                break;

            case 1:
                protein.CleavageState =
                    clsPeptideCleavageStateCalculator.ePeptideCleavageStateConstants.Partial;
                break;

            case 2:
                protein.CleavageState = clsPeptideCleavageStateCalculator.ePeptideCleavageStateConstants.Full;
                break;
            }
        }
Пример #7
0
 public ProteinTreeNodeViewModel(ProteinInformation protein, TreeNodeViewModel parent)
     : base(String.Format("{0} ({1} peptides)", protein.ProteinName, protein.Consensus.Count), true, parent)
 {
     m_proteinInformation = protein;
 }
Пример #8
0
        private void RetrieveDataFromTextFiles(string directory)
        {
            using (var reader = new StreamReader(directory + "tempModInfo.txt"))
            {
                reader.ReadLine();
                var row = reader.ReadLine();
                while (!string.IsNullOrEmpty(row))
                {
                    var rowPieces = row.Split(m_separator);
                    m_modTagsToModMass.Add(rowPieces[0],
                                           new Tuple <double, string>(Convert.ToDouble(rowPieces[1]), rowPieces[2]));
                    row = reader.ReadLine();
                }
            }

            var ptmId     = 1;
            var targetId  = 1;
            var ctToPtmId = 1;

            using (var reader = new StreamReader(directory + "tempMassTags.txt"))
            {
                reader.ReadLine();
                var row = reader.ReadLine();
                while (!string.IsNullOrEmpty(row))
                {
                    var rowPieces = row.Split(m_separator);
                    var target    = new ConsensusTarget();
                    target.Id = targetId++;
                    var quote          = "";
                    var unescapedPiece = rowPieces[14].Replace("\"\"", quote);
                    var sequence       = rowPieces[1];
                    if (unescapedPiece != "")
                    {
                        var unquotedPiece = unescapedPiece.Substring(1, rowPieces[14].Length - 2);
                        var mods          = unquotedPiece.Split(',');
                        foreach (var mod in mods)
                        {
                            var modPieces = mod.Split(':');
                            var modMass   = m_modTagsToModMass[modPieces[0]].Item1;
                            var ptm       = new PostTranslationalModification();
                            ptm.Name = modPieces[0];
                            if (!m_ptmDictionary.ContainsKey(ptm.Name))
                            {
                                ptm.Mass    = modMass;
                                ptm.Id      = ptmId++;
                                ptm.Formula = m_modTagsToModMass[modPieces[0]].Item2;
                                m_ptmDictionary.Add(ptm.Name, ptm);
                            }
                            target.Ptms.Add(m_ptmDictionary[ptm.Name]);
                            ptm.Location = Convert.ToInt32(modPieces[1]);

                            var ctToPtm = new ConsensusPtmPair
                            {
                                ConsensusId = target.Id,
                                PtmId       = m_ptmDictionary[ptm.Name].Id,
                                Location    = ptm.Location,
                                Id          = ctToPtmId++
                            };

                            m_consensusTargetToPtmDict[ctToPtm.Id] = ctToPtm;
                        }
                        target.ModificationDescription = unquotedPiece;
                    }
                    var fullSequence = sequence;
                    var backPtms     = target.Ptms.OrderByDescending(x => x.Location);
                    foreach (var ptm in backPtms)
                    {
                        if (ptm.Location == rowPieces[1].Length)
                        {
                            rowPieces[1] += ptm.Mass.ToString();
                        }
                        else
                        {
                            rowPieces[1] = fullSequence.Insert(ptm.Location, ptm.Mass.ToString());
                        }
                    }
                    target.EncodedNumericSequence = rowPieces[1];
                    target.Sequence = fullSequence;
                    target.TheoreticalMonoIsotopicMass = Convert.ToDouble(rowPieces[2]);
                    target.MultiProteinCount           = Convert.ToInt16(rowPieces[4]);
                    target.ModificationCount           = Convert.ToInt16(rowPieces[13]);

                    m_idToMassTagDict.Add(Convert.ToInt32(rowPieces[0]), row);
                    m_idToConensusTargetDict.Add(Convert.ToInt32(rowPieces[0]), target);

                    row = reader.ReadLine();
                }
            }

            using (var reader = new StreamReader(directory + "tempMassTagsNet.txt"))
            {
                reader.ReadLine();
                var row = reader.ReadLine();
                while (!string.IsNullOrEmpty(row))
                {
                    var rowPieces = row.Split(m_separator);

                    var id = Convert.ToInt32(rowPieces[0]);
                    m_idToConensusTargetDict[id].PredictedNet = Convert.ToDouble(rowPieces[7]);
                    m_idToConensusTargetDict[id].StdevNet     = Convert.ToDouble(rowPieces[5]);
                    m_idToConensusTargetDict[id].AverageNet   = Convert.ToDouble(rowPieces[3]);

                    row = reader.ReadLine();
                }
            }

            var proteinId = 1;

            using (var reader = new StreamReader(directory + "tempProteins.txt"))
            {
                reader.ReadLine();
                var row = reader.ReadLine();
                while (!string.IsNullOrEmpty(row))
                {
                    var rowPieces     = row.Split(m_separator);
                    var unquotedPiece = rowPieces[1].Substring(1, rowPieces[1].Length - 2);
                    var prot          = new ProteinInformation {
                        Id = proteinId++, ProteinName = unquotedPiece
                    };

                    m_idToProteinDict[Convert.ToInt32(rowPieces[0])] = prot;

                    row = reader.ReadLine();
                }
            }

            var cppId = 1;

            using (var reader = new StreamReader(directory + "tempMassTagToProteins.txt"))
            {
                reader.ReadLine();
                var row = reader.ReadLine();
                while (!string.IsNullOrEmpty(row))
                {
                    var rowPieces = row.Split(m_separator);
                    var mt_id     = Convert.ToInt32(rowPieces[0]);
                    var prot_id   = Convert.ToInt32(rowPieces[2]);
                    var ctToProt  = new ConsensusProteinPair();
                    ctToProt.CleavageState = Convert.ToInt16(rowPieces[3]);
                    ctToProt.ResidueStart  = Convert.ToInt32(rowPieces[6]);
                    ctToProt.ResidueEnd    = Convert.ToInt32(rowPieces[7]);
                    ctToProt.TerminusState = Convert.ToInt16(rowPieces[9]);
                    ctToProt.ConsensusId   = m_idToConensusTargetDict[mt_id].Id;
                    ctToProt.ProteinId     = m_idToProteinDict[prot_id].Id;
                    m_ctToProtDict[cppId]  = ctToProt;
                    cppId++;

                    row = reader.ReadLine();
                }
            }

            var totalCharges = 0;
            var evId         = 1;

            using (var reader = new StreamReader(directory + "tempPeptides.txt"))
            {
                reader.ReadLine();
                var row = reader.ReadLine();
                while (!string.IsNullOrEmpty(row))
                {
                    var rowPieces = row.Split(m_separator);
                    var id        = Convert.ToInt32(rowPieces[0]);
                    if (!m_idToChargeAndPeptide.ContainsKey(id))
                    {
                        m_idToChargeAndPeptide[id] = new Tuple <string, List <short> >(rowPieces[1], new List <short>());
                        m_idToChargeAndPeptide[id].Item2.Add(Convert.ToInt16(rowPieces[2]));
                        m_idToConensusTargetDict[id].Sequence = rowPieces[1][0] + "." +
                                                                m_idToConensusTargetDict[id].Sequence + "." +
                                                                rowPieces[1][rowPieces[1].Length - 1];
                        m_idToConensusTargetDict[id].CleanSequence = m_idToConensusTargetDict[id].Sequence;
                        m_idToConensusTargetDict[id].Charges.Add(Convert.ToInt16(rowPieces[2]));
                        totalCharges++;
                    }
                    if (!m_idToChargeAndPeptide[id].Item2.Contains(Convert.ToInt16(rowPieces[2])))
                    {
                        m_idToChargeAndPeptide[id].Item2.Add(Convert.ToInt16(rowPieces[2]));
                        m_idToConensusTargetDict[id].Charges.Add(Convert.ToInt16(rowPieces[2]));
                        totalCharges++;
                    }

                    var ctId = m_idToConensusTargetDict[id].Id;
                    var ev   = new Evidence();
                    ev.Id          = evId++;
                    ev.Charge      = Convert.ToInt16(rowPieces[2]);
                    ev.Sequence    = m_idToConensusTargetDict[id].CleanSequence;
                    ev.Scan        = Convert.ToInt32(rowPieces[3]);
                    ev.DelMPpm     = Convert.ToDouble(rowPieces[4]);
                    ev.ObservedNet = Convert.ToDouble(rowPieces[5]);
                    ev.ObservedMonoisotopicMass = Convert.ToDouble(rowPieces[6]);
                    ev.Mz       = ev.ObservedMonoisotopicMass / ev.Charge;
                    ev.NetShift = 0;
                    ev.DelM     = ev.DelMPpm / 1000000;
                    ev.Parent   = m_idToConensusTargetDict[id];

                    m_evidenceDict[evId] = ev;
                    if (!m_ctToEvidenceMap.ContainsKey(ctId))
                    {
                        m_ctToEvidenceMap[ctId] = new List <int>();
                    }
                    m_ctToEvidenceMap[ctId].Add(evId);

                    row = reader.ReadLine();
                }
            }
        }