public SparseMatrix GenerateSparseMatrix() { SparseMatrix sm = new SparseMatrix(); List <int> dims = new List <int> { 1, 2 }; foreach (AlignmentResult ar in Alignments) { int label = -1; if (!ar.ProtIDs.Exists(a => a.StartsWith("Reverse"))) { label = 1; } string cleanedSequence = PatternTools.pTools.CleanPeptide(ar.DeNovoRegistries[0].PtmSequence, true); List <double> values = new List <double> { ar.SimilarityScore / (double)cleanedSequence.Length, ar.DeNovoRegistries.Max(a => a.DeNovoScore) }; sparseMatrixRow smr = new sparseMatrixRow(label, dims, values); smr.FileName = ar.DeNovoRegistries[0].PtmSequence; sm.addRow(smr); } return(sm); }
//------------------------------------------------- public double [] Consensus() { List <int> aDimVector = MyInputVectors[0].Dims; double[] consensus = new double[aDimVector.Count]; foreach (sparseMatrixRow smr in MyInputVectors) { //We should make a clone sparseMatrixRow cv = new sparseMatrixRow(0); foreach (double v in smr.Values) { cv.Values.Add(v); } cv.ConvertToUnitVector(); for (int i = 0; i < cv.Values.Count; i++) { consensus[i] += cv.Values[i]; } } for (int i = 0; i < consensus.Length; i++) { consensus[i] /= (double)MyInputVectors.Count; } return(consensus); }
public KeyValuePair <SparseMatrixIndexParserV2, SparseMatrix> GenerateIndexAndSparseMatrix() { StringBuilder sb = new StringBuilder(); //Get a list of all proteins identified in all packages List <string> fastaIDs = (from pckg in MyResultPackages from fst in pckg.MyPackage.MyFasta select fst.SequenceIdentifier).Distinct().ToList(); SparseMatrixIndexParserV2 smi = new SparseMatrixIndexParserV2(); foreach (string fastaID in fastaIDs) { List <FastaItem> fi = (from pckg in MyResultPackages from fst in pckg.MyPackage.MyFasta where fst.SequenceIdentifier.Equals(fastaID) select fst).ToList(); smi.Add(fastaID, fi[0].Description); } SparseMatrix sm = new SparseMatrix(); foreach (DirectoryClassDescription myDir in MyDirectoryDescriptionDictionary) { sm.ClassDescriptionDictionary.Add(myDir.ClassLabel, myDir.Description); } foreach (ThePackage rp in MyResultPackages) { sparseMatrixRow smr = new sparseMatrixRow(rp.MyClassLabel); smr.FileName = rp.MyFileInfo.FullName; List <int> dims = new List <int>(); List <double> values = new List <double>(); for (int i = 0; i < smi.TheIndexes.Count; i++) { int count = rp.MyPackage.Alignments.FindAll(a => a.ProtIDs.Contains(smi.TheIndexes[i].Name)).Count; if (count > 0) { dims.Add(i + 1); values.Add(count); } } smr.Dims = dims; smr.Values = values; sm.addRow(smr); } return(new KeyValuePair <SparseMatrixIndexParserV2, SparseMatrix>(smi, sm)); }
public SparseMatrix Converge(int iterations, double outlierPenalty) { List <double> stressValues = new List <double>(iterations); double minStress = double.MaxValue; List <OrganismData> theResult = new List <OrganismData>(); if (outlierPenalty != 0) { CalculateWheights(); } else { ResetWheights(); } for (int i = 0; i < iterations; i++) { double stress = SpringConverge(outlierPenalty); stressValues.Add(stress); if (stress < minStress) { minStress = stress; theResult = PatternTools.ObjectCopier.Clone(Matrix.Positions); } Randomize(); } SparseMatrix resultMatrix = new SparseMatrix(); resultMatrix.ClassDescriptionDictionary = originalSparseMatrix.ClassDescriptionDictionary; foreach (OrganismData o in theResult) { sparseMatrixRow smr = new sparseMatrixRow(o.Label, new List <int>() { 1, 2 }, new List <double>() { o.PosX, o.PosY }); smr.FileName = o.Name; resultMatrix.addRow(smr); } return(resultMatrix); }
internal void CalculateWheights() { List <int> labels = originalSparseMatrix.ExtractLabels(); foreach (int label in labels) { List <sparseMatrixRow> rows = originalSparseMatrix.theMatrixInRows.FindAll(a => a.Lable == label); sparseMatrixRow centroid = centroids.Find(a => a.Lable == label); rows.Sort((a, b) => pTools.DotProduct(b.Values, centroid.Values).CompareTo(pTools.DotProduct(a.Values, centroid.Values))); for (int i = 0; i < rows.Count; i++) { OrganismData o = matrix.Positions.Find(a => a.Name.Equals(rows[i].FileName)); o.Weight = 1 / (double)(1 + i); } } }
/// <summary> /// Returns the sum of the euclidian stress /// </summary> /// <param name="sn"></param> /// <returns></returns> public double EStress(SpectralNode sn) { double eSumm = 0; List <double> consensus = sn.Consensus().ToList(); foreach (sparseMatrixRow r in sn.MyInputVectors) { sparseMatrixRow cv = new sparseMatrixRow(0); foreach (double v in r.Values) { cv.Values.Add(v); } cv.ConvertToUnitVector(); eSumm += PatternTools.pTools.EuclidianDistance(consensus, cv.Values); } return(eSumm); }
private static SparseMatrix TransposeMatrixForClustering(SparseMatrix myMatrix) { //We need to shatter the matrix--------------------- SparseMatrix myShatteredMatrix = new SparseMatrix(); List <int> classes = myMatrix.ExtractLabels(); List <int> dims = myMatrix.allDims(); //We also need to now how many input vectors per class Dictionary <int, int> classNoInputVector = new Dictionary <int, int>(); foreach (int c in classes) { classNoInputVector.Add(c, 0); } foreach (var row in myMatrix.theMatrixInRows) { classNoInputVector[row.Lable]++; } //Now we are ready to shater the matrix. Foreach class we need to construct the averaged input vector foreach (int c in classes) { sparseMatrixRow newRow = new sparseMatrixRow(c); foreach (int dim in dims) { List <double> dimValues = myMatrix.ExtractDimValues(dim, c, false); double sum = 0; for (int i = 0; i < dimValues.Count; i++) { sum += dimValues[i]; } newRow.Dims.Add(dim); newRow.Values.Add(sum / classNoInputVector[c]); } myShatteredMatrix.addRow(newRow); } //Done Shattering------------------------------------------------- //Begin transposing the matrix SparseMatrix transposedMatrix = new SparseMatrix(); for (int i = 0; i < dims.Count; i++) { List <double> values = myShatteredMatrix.ExtractDimValues(dims[i], 0, true); sparseMatrixRow r = new sparseMatrixRow(dims[i], classes, values); transposedMatrix.addRow(r); } //Done transposing the matrix. The final transposed matrix will be such that the //lable of each row reflects the proteins index. //Before //0 1:11 2:2.6 3:11 //1 1:6 2:12 3:0 // //After transposing //1 0:11 1:6 //2 0:2.6 1:12 //3 0:11 1:0 return(transposedMatrix); }
private void buttonPlotCluster_Click(object sender, EventArgs e) { List <int> aDimVector = resultsClusterAnalysis[(int)dataGridViewCluster.Rows[0].Cells[1].Value].MyInputVectors[0].Dims; double[] consensus = new double[aDimVector.Count]; double conCounter = 0; plotDataTable = new DataTable(); plotDataTable.Columns.Add("ID"); plotDataTable.Columns.Add("Description"); DataColumn dc = new DataColumn("Euclidian"); //dc.DataType = System.Type.GetType("System.Double"); plotDataTable.Columns.Add(dc); for (int i = 0; i < aDimVector.Count; i++) { DataColumn column = new DataColumn(); column.DataType = typeof(double); plotDataTable.Columns.Add(aDimVector[i].ToString()); } dataGridViewPlotData.AutoGenerateColumns = true; dataGridViewPlotData.DataSource = plotDataTable; for (int r = 0; r < dataGridViewCluster.Rows.Count; r++) { if ((bool)dataGridViewCluster.Rows[r].Cells[0].Value) { //Lets Construct a line for each element in the node foreach (sparseMatrixRow inputVector in resultsClusterAnalysis[(int)dataGridViewCluster.Rows[r].Cells[1].Value].MyInputVectors) { conCounter++; //We should make a clone sparseMatrixRow cv = new sparseMatrixRow(0); foreach (double v in inputVector.Values) { cv.Values.Add(v); } cv.ConvertToUnitVector(); for (int i = 0; i < cv.Values.Count; i++) { consensus[i] += cv.Values[i]; } DataRow row = plotDataTable.NewRow(); row["ID"] = plp.MyIndex.GetName(inputVector.Lable); row["Description"] = plp.MyIndex.GetDescription(inputVector.Lable); for (int i = 0; i < inputVector.Dims.Count; i++) { row[inputVector.Dims[i].ToString()] = cv.Values[i]; } plotDataTable.Rows.Add(row); } } } UpdateEuclidian(); Plot(); }
public void AddRow(sparseMatrixRow r) { matrix.addRow(r); }
public void Plot(List <TermScoreCalculator.TermScoreAnalysis> terms, PatternLabProject plp, int fontSize) { PlotModel MyModel = new PlotModel(); MyModel.Title = "Identification distribution along selected GO Terms"; var categoryAxis1 = new CategoryAxis(); categoryAxis1.Position = AxisPosition.Left; categoryAxis1.FontSize = fontSize; MyModel.Axes.Add(categoryAxis1); var linearAxis1 = new LinearAxis(); linearAxis1.Position = AxisPosition.Bottom; linearAxis1.FontSize = fontSize; MyModel.Axes.Add(linearAxis1); if (plp == null) { var barSeries1 = new BarSeries(); MyModel.Series.Add(barSeries1); foreach (var tsa in terms) { categoryAxis1.Labels.Add(tsa.TermName); barSeries1.Items.Add(new BarItem(tsa.ProteinIDs.Keys.Count, -1)); } } else { SparseMatrix sm = plp.MySparseMatrix.ShatterMatrixSum(); List <int> labels = sm.ExtractLabels(); Dictionary <int, BarSeries> barDict = new Dictionary <int, BarSeries>(); foreach (KeyValuePair <int, string> kvp in sm.ClassDescriptionDictionary) { BarSeries bs = new BarSeries(); bs.Title = kvp.Value; barDict.Add(kvp.Key, bs); MyModel.Series.Add(bs); } foreach (var tsa in terms) { int globalProtCounter = 0; Dictionary <int, BarItem> tmpDict = new Dictionary <int, BarItem>(); foreach (int l in labels) { sparseMatrixRow theRow = sm.theMatrixInRows.Find(a => a.Lable == l); int protCounter = 0; foreach (string p in tsa.ProteinIDs.Keys) { //Search for proteins in this class string cleanID = PatternTools.pTools.CleanPeptide(p, true); int index = plp.MyIndex.TheIndexes.FindIndex(a => a.Name.Equals(cleanID)); if (index > -1) { double value = theRow.Values[index]; if (value > 0) { protCounter++; globalProtCounter++; } else { Debug.Assert(true, "Protein not found"); } } } //We need to use this as a work around as there are some terms that get 0 prots. tmpDict.Add(l, new BarItem(protCounter, -1)); } if (globalProtCounter > 0) { categoryAxis1.Labels.Add(tsa.TermName); foreach (KeyValuePair <int, BarItem> kvp in tmpDict) { barDict[kvp.Key].Items.Add(kvp.Value); } } } } MyPlot.Model = MyModel; }
public SpectralNode(PatternTools.sparseMatrixRow v1) { myClusterRepresentation = PatternTools.pTools.MergeTwoInputVectors(v1, 1, v1, 1, false);; MyInputVectors.Add(v1); }
public MDS2(SparseMatrix sm) { //Construct a distance matrix StringBuilder distanceMatrix = new StringBuilder(); foreach (sparseMatrixRow sr in sm.theMatrixInRows) { distanceMatrix.Append("," + sr.FileName); } distanceMatrix.Append("\n"); Dictionary <string, int> fileLabelDictionary = new Dictionary <string, int>(); for (int i = 0; i < sm.theMatrixInRows.Count; i++) { distanceMatrix.Append(sm.theMatrixInRows[i].FileName); if (fileLabelDictionary.ContainsKey(sm.theMatrixInRows[i].FileName)) { throw new Exception("The file " + sm.theMatrixInRows[i].FileName + " is found in more than one directory."); } fileLabelDictionary.Add(sm.theMatrixInRows[i].FileName, sm.theMatrixInRows[i].Lable); for (int j = 0; j < sm.theMatrixInRows.Count; j++) { double p = PatternTools.pTools.DotProduct(sm.theMatrixInRows[i].Values, sm.theMatrixInRows[j].Values); distanceMatrix.Append("," + Math.Round(p, 3) * 100); } distanceMatrix.Append("\n"); } //---------------------------------------------------- MatrixData md = new MatrixData(distanceMatrix.ToString(), fileLabelDictionary); matrix = md; Randomize(); originalSparseMatrix = sm; //Calculate centroids List <int> labels = sm.ExtractLabels(); centroids = new List <sparseMatrixRow>(labels.Count); foreach (int l in labels) { sparseMatrixRow centroid = new sparseMatrixRow(l); List <sparseMatrixRow> rows = sm.theMatrixInRows.FindAll(a => a.Lable == l); centroid.Dims = rows[0].Dims; double[] e5 = new double[rows[0].Dims.Count]; centroid.Values = e5.ToList(); double sum = 0; for (int i = 0; i < centroid.Dims.Count; i++) { for (int j = 0; j < rows.Count; j++) { sum += rows[j].Values[i]; } centroid.Values[i] = sum / (double)rows.Count; } centroids.Add(centroid); } }
private void buttonGo_Click(object sender, EventArgs e) { //Verify write permission to directory if (!Directory.Exists(textBoxOutputDirectory.Text)) { MessageBox.Show("Please specify a valid output directory"); return; } if (!Regex.IsMatch(textBoxIsobaricMasses.Text, "[0-9]+ [0-9]+")) { MessageBox.Show("Please fill out the masses of the isobaric tags."); return; } if (!PatternTools.pTools.HasWriteAccessToFolder(textBoxOutputDirectory.Text)) { MessageBox.Show("Please specify a valid output directory"); return; } //Obtain class labels if (textBoxClassLabels.Text.Length == 0) { MessageBox.Show("Please input the class labels (eg., for iTRAQ 1,2,3,4"); return; } List <int> labels = Regex.Split(textBoxClassLabels.Text, " ").Select(a => int.Parse(a)).ToList(); //Obtain the isobaric masses string[] im = Regex.Split(textBoxIsobaricMasses.Text, " "); List <double> isobaricMasses = im.Select(a => double.Parse(a)).ToList(); if (labels.Count != isobaricMasses.Count) { MessageBox.Show("Please make sure that the class labels and isobaric masses match"); return; } buttonGo.Text = "Working..."; this.Update(); richTextBoxLog.Clear(); //-------------------------------------------- //Get signal from all signalAllNormalizationDictionary = new Dictionary <string, double[]>(); //if (false) FileInfo fi = new FileInfo(textBoxitraqSEPro.Text); bool extractSignal = false; ResultPackage rp = null; if (checkBoxNormalizationChannelSignal.Checked) { //We should get the MS infor and merge it the the sepro package if (fi.Extension.Equals(".sepr")) { rp = ResultPackage.Load(textBoxitraqSEPro.Text); extractSignal = true; } List <FileInfo> rawFiles = fi.Directory.GetFiles("*.RAW").ToList(); foreach (FileInfo rawFile in rawFiles) { Console.WriteLine("Extracting data for " + rawFile.Name); PatternTools.RawReader.RawReaderParams rParams = new PatternTools.RawReader.RawReaderParams(); rParams.ExtractMS1 = false; rParams.ExtractMS2 = true; rParams.ExtractMS3 = false; PatternTools.RawReader.Reader reader = new PatternTools.RawReader.Reader(rParams); List <MSLight> theMS2 = reader.GetSpectra(rawFile.FullName, new List <int>(), false); theMS2.RemoveAll(a => a.Ions == null); double [] totalSignal = new double[isobaricMasses.Count]; List <SQTScan> theScans = null; //Update the sepro result package with the signal if (extractSignal) { //Get all the scans from this file string rawName = rawFile.Name.Substring(0, rawFile.Name.Length - 4); theScans = rp.MyProteins.AllSQTScans.FindAll(a => a.FileName.Substring(0, a.FileName.Length - 4).Equals(rawName)); } foreach (MSLight ms in theMS2) { double[] thisQuantitation = GetIsobaricSignal(ms.Ions, isobaricMasses); if (extractSignal) { SQTScan scn = theScans.Find(a => a.ScanNumber == ms.ScanNumber); if (scn != null) { scn.MSLight = ms; scn.MSLight.Ions.RemoveAll(a => a.MZ > 400); } } for (int i = 0; i < thisQuantitation.Length; i++) { totalSignal[i] += thisQuantitation[i]; } } string theName = rawFile.Name.Substring(0, rawFile.Name.Length - 3); theName += "sqt"; signalAllNormalizationDictionary.Add(theName, totalSignal); } } Console.WriteLine("Loading SEPro File"); if (!File.Exists(textBoxitraqSEPro.Text)) { MessageBox.Show("Unable to find SEPro file"); return; } #region Load the spero or pepexplorer file theScansToAnalyze = new List <SQTScan>(); List <FastaItem> theFastaItems = new List <FastaItem>(); if (fi.Extension.Equals(".sepr")) { Console.WriteLine("Loading SEPro file"); if (!extractSignal) { rp = ResultPackage.Load(textBoxitraqSEPro.Text); } rp.MyProteins.AllSQTScans.RemoveAll(a => a.MSLight == null); theScansToAnalyze = rp.MyProteins.AllSQTScans; Console.WriteLine("Done reading SEPro result"); theFastaItems = rp.MyProteins.MyProteinList.Select(a => new FastaItem(a.Locus, a.Sequence, a.Description)).ToList(); } else if (fi.Extension.Equals(".mpex")) { Console.WriteLine("Loading PepExplorer file...."); PepExplorer2.Result2.ResultPckg2 result = PepExplorer2.Result2.ResultPckg2.DeserializeResultPackage(textBoxitraqSEPro.Text); theFastaItems = result.MyFasta; theScansToAnalyze = new List <SQTScan>(); foreach (PepExplorer2.Result2.AlignmentResult al in result.Alignments) { foreach (var dnr in al.DeNovoRegistries) { SQTScan sqt = new SQTScan(); sqt.ScanNumber = dnr.ScanNumber; sqt.FileName = dnr.FileName; sqt.PeptideSequence = dnr.PtmSequence; theScansToAnalyze.Add(sqt); } } //And now we need to retrieve the mass spectra. For this, the raw files should be inside the directory containing the mpex file List <string> rawFiles = theScansToAnalyze.Select(a => a.FileName).Distinct().ToList(); for (int i = 0; i < rawFiles.Count; i++) { rawFiles[i] = rawFiles[i].Remove(rawFiles[i].Length - 3, 3); rawFiles[i] = rawFiles[i] += "raw"; } foreach (string fn in rawFiles) { Console.WriteLine("Retrieving spectra for file: " + fn); ParserUltraLightRAW parser = new ParserUltraLightRAW(); string tmpFile = fn.Substring(0, fn.Length - 3); List <SQTScan> scansForThisFile = theScansToAnalyze.FindAll(a => Regex.IsMatch(tmpFile, a.FileName.Substring(0, a.FileName.Length - 3), RegexOptions.IgnoreCase)).ToList(); List <int> scnNumbers = scansForThisFile.Select(a => a.ScanNumber).ToList(); FileInfo theInputFile = new FileInfo(textBoxitraqSEPro.Text); List <MSUltraLight> theSpectra = parser.ParseFile(theInputFile.DirectoryName + "/" + fn, -1, 2, scnNumbers); foreach (SQTScan sqt in scansForThisFile) { MSUltraLight spec = theSpectra.Find(a => a.ScanNumber == sqt.ScanNumber); sqt.MSLight = new MSLight(); sqt.MSLight.MZ = spec.Ions.Select(a => (double)a.Item1).ToList(); sqt.MSLight.Intensity = spec.Ions.Select(a => (double)a.Item2).ToList(); } Console.WriteLine("\tDone processing this file."); } } else { throw new Exception("This file format is not supported."); } #endregion //Obtaining multiplexed spectra SEProQ.IsobaricQuant.YadaMultiplexCorrection.YMC ymc = null; if (textBoxCorrectedYadaDirectory.Text.Length > 0) { Console.WriteLine("Reading Yada results"); ymc = new IsobaricQuant.YadaMultiplexCorrection.YMC(new DirectoryInfo(textBoxCorrectedYadaDirectory.Text)); Console.WriteLine("Done loading Yada results"); } //Remove multiplexed spectra from sepro results if (textBoxCorrectedYadaDirectory.Text.Length > 0) { int removedCounter = 0; foreach (KeyValuePair <string, List <int> > kvp in ymc.fileNameScanNumberMultiplexDictionary) { Console.WriteLine("Removing multiplexed spectra for file :: " + kvp.Key); richTextBoxLog.AppendText("Removing multiplexed spectra for file :: " + kvp.Key + "\n"); string cleanName = kvp.Key.Substring(0, kvp.Key.Length - 4); cleanName += ".sqt"; foreach (int scnNo in kvp.Value) { int index = theScansToAnalyze.FindIndex(a => a.ScanNumber == scnNo && a.FileName.Equals(cleanName)); if (index >= 0) { Console.Write(theScansToAnalyze[index].ScanNumber + " "); richTextBoxLog.AppendText(theScansToAnalyze[index].ScanNumber + " "); removedCounter++; theScansToAnalyze.RemoveAt(index); } } Console.WriteLine("\n"); richTextBoxLog.AppendText("\n"); } Console.WriteLine("Done removing multiplexed spectra :: " + removedCounter); } PatternTools.CSML.Matrix correctionMatrix = new PatternTools.CSML.Matrix(); if (checkBoxApplyPurityCorrection.Checked) { List <List <double> > correctionData = GetPurityCorrectionsFromForm(); correctionMatrix = IsobaricQuant.IsobaricImpurityCorrection.GenerateInverseCorrectionMatrix(correctionData); } //-------------------------------------------------------------------------------------------------------------------- //Prepare normalization Dictionary signalIdentifiedNormalizationDictionary = new Dictionary <string, double[]>(); List <string> fileNames = theScansToAnalyze.Select(a => a.FileName).Distinct().ToList(); foreach (string fileName in fileNames) { signalIdentifiedNormalizationDictionary.Add(fileName, new double[isobaricMasses.Count]); } //------------------------------------- //If necessary, correct for impurity and feed global signal dictionary foreach (SQTScan scn in theScansToAnalyze) { double[] thisQuantitation = GetIsobaricSignal(scn.MSLight.Ions, isobaricMasses); double maxSignal = thisQuantitation.Max(); //We can only correct for signal for those that have quantitation values in all places if (checkBoxApplyPurityCorrection.Checked && (thisQuantitation.Count(a => a > maxSignal * (double)numericUpDownIonCountThreshold.Value) == isobaricMasses.Count)) { thisQuantitation = IsobaricQuant.IsobaricImpurityCorrection.CorrectForSignal(correctionMatrix, thisQuantitation).ToArray(); } if (checkBoxNormalizationChannelSignal.Checked) { for (int k = 0; k < thisQuantitation.Length; k++) { signalIdentifiedNormalizationDictionary[scn.FileName][k] += thisQuantitation[k]; } } scn.Quantitation = new List <List <double> >() { thisQuantitation.ToList() }; } //And now normalize ------------------- if (checkBoxNormalizationChannelSignal.Checked) { Console.WriteLine("Performing channel signal normalization for " + theScansToAnalyze.Count + " scans."); foreach (SQTScan scn2 in theScansToAnalyze) { for (int m = 0; m < isobaricMasses.Count; m++) { scn2.Quantitation[0][m] /= signalIdentifiedNormalizationDictionary[scn2.FileName][m]; } if (scn2.Quantitation[0].Contains(double.NaN)) { Console.WriteLine("Problems on signal of scan " + scn2.FileNameWithScanNumberAndChargeState); } } } comboBoxSelectFileForGraphs.Items.Clear(); foreach (string file in signalIdentifiedNormalizationDictionary.Keys.ToList()) { comboBoxSelectFileForGraphs.Items.Add(file); } tabControlMain.SelectedIndex = 1; if (radioButtonAnalysisPeptideReport.Checked) { //Peptide Analysis //Write Peptide Analysis StreamWriter sw = new StreamWriter(textBoxOutputDirectory.Text + "/" + "PeptideQuantitationReport.txt"); //Eliminate problematic quants int removed = theScansToAnalyze.RemoveAll(a => Object.ReferenceEquals(a.Quantitation, null)); Console.WriteLine("Problematic scans removed: " + removed); var pepDic = from scn in theScansToAnalyze group scn by scn.PeptideSequenceCleaned into groupedSequences select new { PeptideSequence = groupedSequences.Key, TheScans = groupedSequences.ToList() }; foreach (var pep in pepDic) { sw.WriteLine("Peptide:" + pep.PeptideSequence + "\tSpecCounts:" + pep.TheScans.Count); foreach (SQTScan sqt in pep.TheScans) { sw.WriteLine(sqt.FileNameWithScanNumberAndChargeState + "\t" + string.Join("\t", sqt.Quantitation[0])); } } //And now write the Fasta sw.WriteLine("#Fasta Items"); foreach (FastaItem fastaItem in theFastaItems) { sw.WriteLine(">" + fastaItem.SequenceIdentifier + " " + fastaItem.Description); sw.WriteLine(fastaItem.Sequence); } sw.Close(); } else { rp = ResultPackage.Load(textBoxitraqSEPro.Text); //Peptide Level if (true) { PatternTools.SparseMatrixIndexParserV2 ip = new SparseMatrixIndexParserV2(); List <int> allDims = new List <int>(); List <PeptideResult> peptides = rp.MyProteins.MyPeptideList; if (checkBoxOnlyUniquePeptides.Checked) { int removedPeptides = peptides.RemoveAll(a => a.MyMapableProteins.Count > 1); Console.WriteLine("Removing {0} peptides for not being unique.", removedPeptides); } for (int i = 0; i < peptides.Count; i++) { SparseMatrixIndexParserV2.Index index = new SparseMatrixIndexParserV2.Index(); index.Name = peptides[i].PeptideSequence; index.Description = string.Join(" ", peptides[i].MyMapableProteins); index.ID = i; ip.Add(index, true); allDims.Add(i); } SparseMatrix sm = new SparseMatrix(); List <int> dims = ip.allIDs(); for (int l = 0; l < labels.Count; l++) { if (labels[l] < 0) { continue; } sparseMatrixRow smr = new sparseMatrixRow(labels[l]); List <double> values = new List <double>(dims.Count); List <int> dimsWithValues = new List <int>(); foreach (int d in dims) { List <SQTScan> scns = peptides[d].MyScans.FindAll(a => !object.ReferenceEquals(a.Quantitation, null)); if (scns.Count > 0) { double signalSum = scns.FindAll(a => !double.IsNaN(a.Quantitation[0][l])).Sum(a => a.Quantitation[0][l]); values.Add(signalSum); dimsWithValues.Add(d); } } smr.Dims = dimsWithValues; smr.Values = values; smr.FileName = isobaricMasses[l].ToString(); sm.addRow(smr); } PatternLabProject plp = new PatternLabProject(sm, ip, "IsobaricQuant"); plp.Save(textBoxOutputDirectory.Text + "/MyPatternLabProjectPeptides.plp"); } //Protein Level if (true) { //Generate Index PatternTools.SparseMatrixIndexParserV2 ip = new SparseMatrixIndexParserV2(); List <MyProtein> theProteins = rp.MyProteins.MyProteinList; if (checkBoxOnlyUniquePeptides.Checked) { int removedProteins = theProteins.RemoveAll(a => !a.PeptideResults.Exists(b => b.NoMyMapableProteins == 1)); Console.WriteLine("{0} removed proteins for not having unique peptides", removedProteins); } for (int i = 0; i < theProteins.Count; i++) { SparseMatrixIndexParserV2.Index index = new SparseMatrixIndexParserV2.Index(); index.ID = i; index.Name = theProteins[i].Locus; index.Description = theProteins[i].Description; ip.Add(index, false); } //SparseMatrix SparseMatrix sm = new SparseMatrix(); List <int> dims = ip.allIDs(); for (int l = 0; l < labels.Count; l++) { if (labels[l] < 0) { continue; } if (!sm.ClassDescriptionDictionary.ContainsKey(labels[l])) { sm.ClassDescriptionDictionary.Add(labels[l], labels[l].ToString()); } sparseMatrixRow smr = new sparseMatrixRow(labels[l]); List <double> values = new List <double>(dims.Count); List <int> dimsToInclude = new List <int>(); foreach (int d in dims) { double signalSum = 0; List <PeptideResult> thePeptides = theProteins[d].PeptideResults; if (checkBoxOnlyUniquePeptides.Checked) { thePeptides.RemoveAll(a => a.MyMapableProteins.Count > 1); } foreach (PeptideResult pr in thePeptides) { List <SQTScan> scns = pr.MyScans.FindAll(a => !object.ReferenceEquals(a.Quantitation, null)); foreach (SQTScan sqt in scns) { if (!double.IsNaN(sqt.Quantitation[0][l]) && !double.IsInfinity(sqt.Quantitation[0][l])) { signalSum += sqt.Quantitation[0][l]; } } } if (signalSum > 0) { dimsToInclude.Add(d); values.Add(signalSum); } else { Console.WriteLine("No signal found for " + theProteins[d].Locus + " on marker " + l); } } smr.Dims = dims; smr.Values = values; smr.FileName = isobaricMasses[l].ToString(); sm.addRow(smr); } PatternLabProject plp = new PatternLabProject(sm, ip, "IsobaricQuant"); plp.Save(textBoxOutputDirectory.Text + "/MyPatternLabProjectProteins.plp"); } } comboBoxSelectFileForGraphs.Enabled = true; tabControlMain.SelectedIndex = 2; Console.WriteLine("Done"); buttonGo.Text = "Generate Report"; }
private void ButtonLoad_Click(object sender, RoutedEventArgs e) { OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "PatternLab project file (*.plp)|*.plp"; ofd.FileName = ""; if (ofd.ShowDialog() == true) { //- do the work ButtonLoad.Content = "Working"; this.UpdateLayout(); TextBoxLegend.Clear(); TextBoxPatternLabProjectFile.Text = ofd.FileName; PatternLabProject plp = new PatternLabProject(ofd.FileName); plp.MySparseMatrix.UnsparseTheMatrix(); foreach (sparseMatrixRow unitSparseMatrixRow in plp.MySparseMatrix.theMatrixInRows) { unitSparseMatrixRow.Values = PatternTools.pTools.UnitVector(unitSparseMatrixRow.Values); } //Do the clustering SparseMatrix smCLuster = new SparseMatrix(); if ((bool)RadioKernelPCA.IsChecked) { double[,] sm = plp.MySparseMatrix.ToDoubleArrayMatrix(); IKernel kernel = null; //"Gaussian", "Linear", "Power", "Quadratic", "Sigmoid", "Spline" if (ComboBoxKPCAKernels.SelectedValue.Equals("Gaussian")) { kernel = new Gaussian(); } else if (ComboBoxKPCAKernels.SelectedValue.Equals("Linear")) { kernel = new Linear(); } else if (ComboBoxKPCAKernels.SelectedValue.Equals("Power")) { kernel = new Power(2); } else if (ComboBoxKPCAKernels.SelectedValue.Equals("Quadratic")) { kernel = new Quadratic(); } else if (ComboBoxKPCAKernels.SelectedValue.Equals("Sigmoid")) { kernel = new Sigmoid(); } else { kernel = new Spline(); } // Creates the Kernel Principal Component Analysis of the given data var kpca = new KernelPrincipalComponentAnalysis(sm, kernel); // Compute the Kernel Principal Component Analysis kpca.Compute(); // Creates a projection of the information double[,] components = kpca.Transform(sm, 2); for (int j = 0; j < components.GetLength(0); j++) { int l = plp.MySparseMatrix.theMatrixInRows[j].Lable; sparseMatrixRow smr = new sparseMatrixRow(l, new List<int>() { 0, 1 }, new List<double>() { components[j, 0], components[j, 1] }); smr.FileName = plp.MySparseMatrix.theMatrixInRows[j].FileName; smCLuster.addRow(smr); } smCLuster.ClassDescriptionDictionary = plp.MySparseMatrix.ClassDescriptionDictionary; } else { MDS2 mds2 = new MDS2(plp.MySparseMatrix); smCLuster = mds2.Converge(250, (double)DoubleUpDownSpringOutlier.Value); } Plot(smCLuster); ButtonLoad.Content = "Browse"; } }
//-------------------------------- private List <ClassScoreDictionary> ClassificationEngine(sparseMatrixRow r) { return(ClassificationEngine(Unsparse(r))); }
private void MenuItemExporToPLP_Click(object sender, RoutedEventArgs e) { SaveFileDialog sfd = new SaveFileDialog(); sfd.DefaultExt = ".txt"; sfd.Filter = "PatternLab Project (*.plp)|*.plp"; Nullable <bool> result = sfd.ShowDialog(); // Get the selected file name and display in a TextBox if (result == true) { SparseMatrixIndexParserV2 smi = new SparseMatrixIndexParserV2(); int counter = 0; List <FastaItem> orderedKeys = new List <FastaItem>(); foreach (KeyValuePair <FastaItem, List <PepQuant> > kvp in protPepDict) { if (kvp.Value.Count > IntegerUpDown.Value) { counter++; SparseMatrixIndexParserV2.Index i = new SparseMatrixIndexParserV2.Index(); i.ID = counter; i.Name = kvp.Key.SequenceIdentifier; i.Description = kvp.Key.Description; smi.Add(i); orderedKeys.Add(kvp.Key); } } SparseMatrix sm = new SparseMatrix(); sm.ClassDescriptionDictionary = new Dictionary <int, string>(); List <int> labels = Regex.Split(TextBoxClassLabel.Text, " ").Select(a => int.Parse(a)).ToList(); //Generate the dictionary for (int i = 0; i < labels.Count; i++) { if (labels[i] < 0) { continue; } //Create the dictionary for the class sm.ClassDescriptionDictionary.Add(i, (i).ToString()); List <int> dims = new List <int>(); List <double> values = new List <double>(); for (int j = 0; j < orderedKeys.Count; j++) { FastaItem fi = orderedKeys[j]; List <PepQuant> thePepQuants = protPepDict[fi]; double theIntensitySum = 0; foreach (PepQuant pq in thePepQuants) { theIntensitySum += pq.MyQuants.Sum(a => a.MarkerIntensities[i]); } if (theIntensitySum > 0) { dims.Add(j + 1); values.Add(theIntensitySum); } } sparseMatrixRow smr = new sparseMatrixRow(i, dims, values); sm.theMatrixInRows.Add(smr); } PatternLabProject plp = new PatternLabProject(sm, smi, "Isobaric Quant Project"); plp.Save(sfd.FileName); MessageBox.Show("PLP file was saved"); Console.WriteLine("PLP file was saved."); } }
//Constructors ----------------------------------- public SpectralNode(PatternTools.sparseMatrixRow v1, PatternTools.sparseMatrixRow v2) { myInputVectors.Add(v1); myInputVectors.Add(v2); myClusterRepresentation = PatternTools.pTools.MergeTwoInputVectors(v1, 1, v2, 1, true); }