コード例 #1
0
 public override int GetHashCode()
 {
     unchecked
     {
         return((Mz.GetHashCode() * 397) ^ RetentionTime.GetHashCode());
     }
 }
コード例 #2
0
        /*
         * Determines if a peptide's retention time is in the past, future, or present
         * Returns PAST(-1) if the retention window has passed, PRESENT(0) if the
         * retention window is in the future, FUTURE(1) if the retention window is
         * active.
         */
        public String retentionTense(Peptide pep)
        {
            RetentionTime rt         = pep.getRetentionTime();
            bool          isObserved = !rt.IsPredicted();
            double        rtStart    = rt.getRetentionTimeStart();
            double        rtEnd      = rt.getRetentionTimeEnd();

            if (isObserved)
            {
                if (pep.isExcluded(currentTime))
                {
                    return(CURRENT_OBSERVED);
                }
                else
                {
                    return(PAST_OBSERVED);
                }
            }
            else if (pep.isExcluded(currentTime))
            {
                return(PRESENT);
            }
            else if (rtStart > currentTime)
            {
                return(FUTURE);
            }
            else if (rtEnd < currentTime)
            {
                return(PAST);
            }
            return(ERROR);
        }
コード例 #3
0
 public static string GetDoubleValueText(RetentionTime retentionTime)
 {
     if (retentionTime == null)
     {
         return("Null");
     }
     return(retentionTime.Minutes.ToString("F3"));
 }
コード例 #4
0
        public override int GetHashCode()
        {
            var hashCode = StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

            hashCode = (hashCode * 397) ^ RetentionTime.GetHashCode();
            hashCode = (hashCode * 397) ^ AggregationTime.GetHashCode();
            return(hashCode);
        }
コード例 #5
0
 protected internal override LibraryKeyProto ToLibraryKeyProto()
 {
     return(new LibraryKeyProto()
     {
         KeyType = LibraryKeyProto.Types.KeyType.PrecursorMz,
         PrecursorMz = Mz,
         RetentionTime = RetentionTime.GetValueOrDefault(),
     });
 }
コード例 #6
0
 public Peptide(String _sequence, double _mass, bool _fromFasta)
 {
     // peptideEvidence = _peptideEvidence;
     fromFasta      = _fromFasta;
     sequence       = _sequence;
     mass           = _mass;
     retentionTime  = new RetentionTime();
     parentProteins = new Dictionary <String, Protein>();
     scores         = new List <Double>();
     dCNs           = new List <Double>();
 }
コード例 #7
0
ファイル: Database.cs プロジェクト: lonelu/MealTimeMS
        /*
         * These are from the experiment and will be removed if you call reset on the
         * graph
         */
        public Peptide addPeptideFromIdentification(IDs id, double currentTime)
        {
            String           peptideSequence         = id.getPeptideSequence();
            double           peptideMass             = id.getPeptideMass();
            HashSet <String> parentProteinAccessions = id.getParentProteinAccessions();
            Peptide          pep;

            if (containsPeptide(peptideSequence))
            {
                return(getPeptide(peptideSequence));
            }
            else
            {
                // Adds the peptide from the identification into the database
                pep = new Peptide(peptideSequence, peptideMass, false);
                // these peptides will be removed if reset() is called
                SequenceToPeptide.Add(peptideSequence, pep);
                peptides.Add(pep);

                if (includeRetentionTime)
                {
                    // TODO right now this takes the current time as the peak retention time...
                    // should we run it through RTCalc so we can better estimate our RT alignment?
                    // 2019-04-29 No, do not. Observed times are better than predicted
                    // pep.setRetentionTime(RetentionTimeUtil.convertDoubleToRetentionTime(rt,
                    // retentionTimeWindow,
                    // retentionTimeWindow));
                    RetentionTime rt = new RetentionTime(currentTime + retentionTimeWindow, retentionTimeWindow,
                                                         retentionTimeWindow, false);
                    pep.setRetentionTime(rt);
                }
            }
            // update its parent proteins
            foreach (String acc in parentProteinAccessions)
            {
                Protein parentProtein = AccesstionToProtein[acc];
                if (parentProtein != null)
                {
                    pep.addProtein(parentProtein);
                }
                else if (acc.Contains(GlobalVar.DecoyPrefix))
                {
                    log.Info("WARNINGin Decoy parent protein for this peptide was not found!!");
                    log.Info(acc);
                }
                else
                {
                    log.Warn("WARNINGin Non-decoy parent protein for this peptide was not found!!");
                    log.Warn(acc);
                }
            }

            return(pep);
        }
コード例 #8
0
        public void observedPeptide(Peptide pep, double time, double rt_window)
        {
            // set a new RT
            RetentionTime newRT = new RetentionTime(time + rt_window, rt_window, rt_window, false);

            // excludes it for 2*rt_window time
            pep.setRetentionTime(newRT);

            //addPeptide(pep); //personally i dont think this line is necessary, since the peptide would have already be added in
            //MachineLearningGuidedExclusion EvaluateIdentification()
            //Note that in the last line when re-setting the retention time of the peptide, isPredicted will be set to false
        }
コード例 #9
0
        public override string ToString()
        {
            var precursor = Mz.ToString(@"0.000", CultureInfo.CurrentCulture);

            if (!RetentionTime.HasValue)
            {
                return(precursor);
            }
            var rt = RetentionTime.GetValueOrDefault().ToString(@"0.00", CultureInfo.CurrentCulture);

            return(string.Format(@"{0} ({1})", precursor, rt));
        }
コード例 #10
0
 private string RetentionToString(RetentionTime time)
 {
     if (time.Initial)
     {
         return("{Initial Time}");
     }
     else
     {
         String result = String.Format(CultureInfo.InvariantCulture, "{0:F3} min", time.Minutes);
         return(result);
     }
 }
コード例 #11
0
        /// <summary>
        /// Generates a hash code.
        /// </summary>
        /// <returns>Hash code based on stored data.</returns>
        public override int GetHashCode()
        {
            var hashCode =
                PrecursorMz.GetHashCode() ^
                PrecursorChargeState.GetHashCode() ^
                Scan.GetHashCode() ^
                Id.GetHashCode() ^
                GroupId.GetHashCode() ^
                TotalIonCurrent.GetHashCode() ^
                RetentionTime.GetHashCode();

            return(hashCode);
        }
コード例 #12
0
ファイル: DbSpectrum.cs プロジェクト: tomas-pluskal/pwiz
 public override int GetHashCode()
 {
     unchecked
     {
         var result = base.GetHashCode();
         result = (result * 397) ^ ResultsFile.GetHashCode();
         result = (result * 397) ^ PrecursorMz.GetHashCode();
         result = (result * 397) ^ MatchedPrecursorMz.GetHashCode();
         result = (result * 397) ^ RetentionTime.GetHashCode();
         result = (result * 397) ^ MzBytes.GetHashCode();
         result = (result * 397) ^ IntensityBytes.GetHashCode();
         return(result);
     }
 }
コード例 #13
0
 public override int GetHashCode()
 {
     unchecked
     {
         var result = base.GetHashCode();
         result = (result * 397) ^ ResultsFile.GetHashCode();
         result = (result * 397) ^ PrecursorMz.GetHashCode();
         result = (result * 397) ^ MatchedPrecursorMz.GetHashCode();
         result = (result * 397) ^ (DocumentPeptide == null ? 0 : DocumentPeptide.GetHashCode());
         result = (result * 397) ^ DocumentPrecursorCharge.GetHashCode();
         result = (result * 397) ^ RetentionTime.GetHashCode();
         result = (result * 397) ^ MzBytes.GetHashCode();
         result = (result * 397) ^ IntensityBytes.GetHashCode();
         return(result);
     }
 }
コード例 #14
0
ファイル: NoExclusion.cs プロジェクト: lonelu/MealTimeMS
        protected void evaluateIdentification(IDs id)
        {
            log.Debug("NoExclusion. Scores added, but nothing added to the exclusion list");

            // check if the peptide is identified or not
            if (id == null)
            {
                performanceEvaluator.countMS2UnidentifiedAnalyzed();
                return;
            }

            Peptide pep = getPeptideFromIdentification(id);             // if it was going to be null, it already returned
            // is fragmented

            // add decoy or non-existent protein connections
            // database.addProteinFromIdentification(pep, id.getParentProteinAccessions());

            Double xCorr = id.getXCorr();
            Double dCN   = id.getDeltaCN();

            pep.addScore(xCorr, 0.0, dCN);
            performanceEvaluator.evaluateAnalysis(exclusionList, pep);



            RetentionTime rt = pep.getRetentionTime();

            if (!rtCalcPredictedRT.Keys.Contains(pep.getSequence()))
            {
                rtCalcPredictedRT.Add(pep.getSequence(), rt.getRetentionTimePeak());
            }

            ObservedPeptideRtTrackerObject observedPep = new ObservedPeptideRtTrackerObject(pep.getSequence(), id.getScanTime(), id.getXCorr(),
                                                                                            rt.getRetentionTimePeak(), rt.getRetentionTimeStart() + GlobalVar.retentionTimeWindowSize,
                                                                                            RetentionTime.getRetentionTimeOffset(), rtCalcPredictedRT[pep.getSequence()], (rt.IsPredicted() ? 1 : 0));



            if ((xCorr > 2.5))
            {
                // calibrates our retention time alignment if the observed time is different
                // from the predicted only if it passes this threshold
                calibrateRetentionTime(pep);
            }
            observedPep.offset = RetentionTime.getRetentionTimeOffset();
            peptideIDRT.Add(observedPep);
        }
コード例 #15
0
ファイル: Pump.cs プロジェクト: IhorRudych/Chromelion-Driver
        private void OnDevicePreflightEnd(PreflightEventArgs args)
        {
            Log.WriteLine(Id, "ProgramTime.Minutes = " + args.RunContext.ProgramTime.Minutes.ToString());

            // Check everything
            foreach (IProgramStep step in args.RunContext.ProgramSteps)
            {
                IRampStep rampStep = step as IRampStep;
                if (rampStep == null)
                {
                    continue;
                }

                m_IsRamped = true;
                RetentionTime        duration   = rampStep.Duration;
                IDoublePropertyValue startValue = rampStep.StartValue as IDoublePropertyValue;
                IDoublePropertyValue endValue   = rampStep.EndValue as IDoublePropertyValue;
            }
        }
コード例 #16
0
        //actual experiment hooked up to the mass spec
        public static void RunRealTimeExperiment()
        {
            PreExperimentSetUp();
            Console.WriteLine("Running real time experiment");

            double startTime = getCurrentTime();

            GlobalVar.ppmTolerance            = 5.0 / 1000000.0;
            GlobalVar.retentionTimeWindowSize = 1.0;
            GlobalVar.AccordThreshold         = 0.5;

            Console.WriteLine("Creating exclusion profile");
            ExclusionProfile exclusionProfile = new MachineLearningGuidedExclusion(InputFileOrganizer.AccordNet_LogisticRegressionClassifier_WeightAndInterceptSavedFile, database, GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize);
            String           experimentName   = GlobalVar.experimentName + String.Format("_MLGE:ppmTol_{0}_rtWin_{1}_prThr_{2}", GlobalVar.ppmTolerance, GlobalVar.retentionTimeWindowSize, GlobalVar.AccordThreshold);
            Experiment       experiment       = new Experiment(exclusionProfile, experimentName, 1, ExclusionProfileEnum.MACHINE_LEARNING_GUIDED_EXCLUSION_PROFILE, startTime);


            new DataReceiver().DoJob(exclusionProfile);

            double analysisTime = getCurrentTime() - startTime;

            try
            {
                WriteUnusedSpectra(experiment);
                WriteScanArrivalProcessedTime(DataProcessor.scanArrivalAndProcessedTimeList);
                WriteScanArrivalProcessedTime(DataProcessor.spectraNotAdded);
                WriteUsedSpectra(experiment);
                WriterClass.writeln("ExclusionList size: " + exclusionProfile.getExclusionList().getExclusionList().Count);
                WriterClass.writeln("Number of exclusion: " + exclusionProfile.getUnusedSpectra().Count);
                WriterClass.writeln("Final rtoffset: " + RetentionTime.getRetentionTimeOffset());
            }
            catch (Exception e)
            {
                Console.WriteLine("Writing exception catched at end of experiment");
            }
            finally
            {
                WriterClass.CloseWriter();
            }
            exclusionProfile.reset();
            reset();
        }
コード例 #17
0
ファイル: Pump.cs プロジェクト: IhorRudych/Chromelion-Driver
        private void OnTransferPreflightToRun(PreflightEventArgs args)
        {
            // We use the IProgramStep interface to walk the list of events in the instrument method.
            // In a real driver we would need to build some kind of time table and send it to the hardware.
            // In this example we create a list instead and write it to the audit trail.
            // Note that the property is not updated, as this would be done asynchronously during the run.

            StringBuilder sb = new StringBuilder("Table of timed events:\n");

            foreach (IProgramStep step in args.RunContext.ProgramSteps)
            {
                IRampStep rampStep = step as IRampStep;

                if (rampStep != null)
                {
                    RetentionTime        duration   = rampStep.Duration;
                    IDoublePropertyValue startValue = rampStep.StartValue as IDoublePropertyValue;
                    IDoublePropertyValue endValue   = rampStep.EndValue as IDoublePropertyValue;

                    sb.Append("Retention ");
                    sb.Append(step.Retention.Minutes.ToString("F3"));
                    sb.Append(": ");
                    sb.Append(startValue.Property.Owner.Name);
                    sb.Append(".");
                    sb.Append(startValue.Property.Name);
                    sb.Append("=");
                    sb.Append(startValue.Value.Value.ToString("F3"));
                    sb.Append(", ");
                    sb.Append(endValue.Property.Owner.Name);
                    sb.Append(".");
                    sb.Append(endValue.Property.Name);
                    sb.Append("=");
                    sb.Append(endValue.Value.Value.ToString("F3"));
                    sb.Append(", Duration=");
                    sb.Append(duration.Minutes.ToString("F3"));
                    sb.Append("\n");
                }
            }

            m_Device.AuditMessage(AuditLevel.Message, sb.ToString());
        }
コード例 #18
0
        /*
         * Computes the difference between the predicted retention time and when we
         * actually observed this peptide. This difference is then used to calibrate the
         * retention time using the RetentionTimeCalibrator class by calculating a
         * retention time offset. This offset will shift all retention time windows by
         * this value.
         */
        protected void calibrateRetentionTime(Peptide pep)             //called when we observe a peptide that passes the xcorr threshold
        {
            bool isPredictedRT = pep.getRetentionTime().IsPredicted(); //       if isPredictedRT is true, then that means this is the first time you observed it

            //      if false, then you already have observed it and would have already
            // readjusted the offset, so no need to to it again.
            //      isPredictedRT is false means that you have observed it before, excluded it, but then
            //it shows up again
            if (isPredictedRT)
            {
                // only calibrate RT prediction if it was a predicted peptide...
                // peptides which were observed should not affect RT prediction calibration
                double predictedRT       = pep.getRetentionTime().getRetentionTimePeak();
                double rtPredictionError = currentTime - predictedRT;
                double newOffset         = RetentionTimeUtil.computeRTOffset(rtPredictionError, currentTime);
                RetentionTime.setRetentionTimeOffset(newOffset);
                performanceEvaluator.countPeptideCalibration();
            }
            //changes the status of the peptide from isPredicted = true to false, because now you have observed it
            exclusionList.observedPeptide(pep, currentTime, database.getRetentionTimeWindow());
        }
コード例 #19
0
 public override int GetHashCode()
 {
     unchecked
     {
         int result = base.GetHashCode();
         result = (result * 397) ^ (MassError.HasValue ? MassError.Value.GetHashCode() : 0);
         result = (result * 397) ^ RetentionTime.GetHashCode();
         result = (result * 397) ^ StartRetentionTime.GetHashCode();
         result = (result * 397) ^ EndRetentionTime.GetHashCode();
         result = (result * 397) ^ Area.GetHashCode();
         result = (result * 397) ^ BackgroundArea.GetHashCode();
         result = (result * 397) ^ Height.GetHashCode();
         result = (result * 397) ^ Fwhm.GetHashCode();
         result = (result * 397) ^ IsFwhmDegenerate.GetHashCode();
         result = (result * 397) ^ Identified.GetHashCode();
         result = (result * 397) ^ (IsTruncated.HasValue ? IsTruncated.Value.GetHashCode() : 0);
         result = (result * 397) ^ Rank;
         result = (result * 397) ^ Ratios.GetHashCodeDeep();
         result = (result * 397) ^ OptimizationStep.GetHashCode();
         result = (result * 397) ^ Annotations.GetHashCode();
         result = (result * 397) ^ UserSet.GetHashCode();
         return(result);
     }
 }
コード例 #20
0
        /// <summary>
        /// Serialize to a JSON object
        /// </summary>
        public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
        {
            if (includeStartObject)
            {
                writer.WriteStartObject();
            }
            ((fhirCsR4.Models.BackboneElement) this).SerializeJson(writer, options, false);

            if (IsDerived != null)
            {
                writer.WriteBoolean("isDerived", (bool)IsDerived !);
            }

            if (Type != null)
            {
                writer.WritePropertyName("type");
                Type.SerializeJson(writer, options);
            }

            if (!string.IsNullOrEmpty(Preference))
            {
                writer.WriteString("preference", (string)Preference !);
            }

            if (_Preference != null)
            {
                writer.WritePropertyName("_preference");
                _Preference.SerializeJson(writer, options);
            }

            if (Container != null)
            {
                writer.WritePropertyName("container");
                Container.SerializeJson(writer, options);
            }

            if (!string.IsNullOrEmpty(Requirement))
            {
                writer.WriteString("requirement", (string)Requirement !);
            }

            if (_Requirement != null)
            {
                writer.WritePropertyName("_requirement");
                _Requirement.SerializeJson(writer, options);
            }

            if (RetentionTime != null)
            {
                writer.WritePropertyName("retentionTime");
                RetentionTime.SerializeJson(writer, options);
            }

            if ((RejectionCriterion != null) && (RejectionCriterion.Count != 0))
            {
                writer.WritePropertyName("rejectionCriterion");
                writer.WriteStartArray();

                foreach (CodeableConcept valRejectionCriterion in RejectionCriterion)
                {
                    valRejectionCriterion.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if ((Handling != null) && (Handling.Count != 0))
            {
                writer.WritePropertyName("handling");
                writer.WriteStartArray();

                foreach (SpecimenDefinitionTypeTestedHandling valHandling in Handling)
                {
                    valHandling.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if (includeStartObject)
            {
                writer.WriteEndObject();
            }
        }
コード例 #21
0
 public void setRetentionTime(RetentionTime _retentionTime)
 {
     retentionTime = _retentionTime;
 }
コード例 #22
0
        //Called by DataProcessor, entry point to Alex's program
        public bool evaluate(Spectra spec)
        {
            currentTime = spec.getStartTime();
            updateExclusionList(spec);
            if (spec.getMSLevel() == 1)
            {
                log.Debug("Evaluating ms1 scan");
                processMS1(spec);
            }
            else if (spec.getMSLevel() == 2)
            {
                log.Debug("evaluating ms2 scan");
                if (spec.getIndex() % GlobalVar.ScansPerOutput == 0)
                {
#if SIMULATION
                    double progressPercent = spec.getIndex() / GlobalVar.ExperimentTotalScans * 100;
                    log.Info("Progress: {0:F2}% Processing ID: {1}\t ScanNum: {2} \t Excluded: {3}", progressPercent, spec.getIndex(), spec.getScanNum(),
                             excludedSpectra.Count);
#else
                    log.Info("Progress: {0}\t{1} excluded------------------------", spec.getIndex(), excludedSpectra.Count);
                    log.Info("ExclusionListSize: {0}\tRTOffset: {1}", exclusionList.getExclusionList().Count, RetentionTime.getRetentionTimeOffset());
#endif
                }

                return(processMS2(spec));
            }
            else
            {
                log.Debug("unrecognized msScan");
            }
            return(true);
        }
コード例 #23
0
 protected bool Equals(PrecursorLibraryKey other)
 {
     return(Mz.Equals(other.Mz) && RetentionTime.Equals(other.RetentionTime));
 }
コード例 #24
0
ファイル: Pump.cs プロジェクト: IhorRudych/Chromelion-Driver
        private void OnDeviceTransferPreflightToRun(PreflightEventArgs args)
        {
            Log.WriteLine(Id, "ProgramTime.Minutes = " + args.RunContext.ProgramTime.Minutes.ToString());

            m_IsRamped = false;

            // Iterate  through each IProgramStep from the instrument method
            bool isIsocratic = false;

            foreach (IProgramStep step in args.RunContext.ProgramSteps)
            {
                IPropertyAssignmentStep propertyAssignmentStep = step as IPropertyAssignmentStep;
                if (propertyAssignmentStep == null)
                {
                    continue;
                }

                if (propertyAssignmentStep.Property == m_FlowHandler.FlowNominalProperty)
                {
                    isIsocratic   = true;
                    FlowRequested = (propertyAssignmentStep.Value as IDoublePropertyValue).Value.GetValueOrDefault();
                }
                else if (propertyAssignmentStep.Property == m_FlowHandler.ComponentProperties[1])
                {
                    isIsocratic      = true;
                    m_EluentPercentB = (propertyAssignmentStep.Value as IDoublePropertyValue).Value.GetValueOrDefault();
                }
                else if (propertyAssignmentStep.Property == m_FlowHandler.ComponentProperties[2])
                {
                    isIsocratic      = true;
                    m_EluentPercentC = (propertyAssignmentStep.Value as IDoublePropertyValue).Value.GetValueOrDefault();
                }
                else if (propertyAssignmentStep.Property == m_FlowHandler.ComponentProperties[3])
                {
                    isIsocratic      = true;
                    m_EluentPercentD = (propertyAssignmentStep.Value as IDoublePropertyValue).Value.GetValueOrDefault();
                }
            }

            if (isIsocratic)
            {
                Log.WriteLine(Id, "Isocratic - FlowRequested = " + FlowRequested.ToString());
                UpdateEluents();
                FlowNominal = FlowRequested;
                if (IsSimulated)
                {
                    Flow = FlowRequested;
                }
                return;
            }

            // In a real driver we would need to build some kind of time table and send it to the hardware.
            // In this example we create a list instead and write it to the audit trail.
            // Note that the property is not updated, as this would be done asynchronously during the run.
            StringBuilder sb = new StringBuilder();

            sb.AppendLine("Table of timed events:");
            foreach (IProgramStep step in args.RunContext.ProgramSteps)
            {
                IRampStep rampStep = step as IRampStep;
                if (rampStep == null)
                {
                    continue;
                }

                m_IsRamped = true;
                RetentionTime        duration   = rampStep.Duration;
                IDoublePropertyValue startValue = rampStep.StartValue as IDoublePropertyValue;
                IDoublePropertyValue endValue   = rampStep.EndValue as IDoublePropertyValue;

                const string sprt = "\t";
                sb.Append("Retention " + step.Retention.Minutes.ToString("F3") + sprt);
                sb.Append(startValue.Property.Owner.Name + "." + startValue.Property.Name + " = " + startValue.Value.Value.ToString("F3") + ", ");
                sb.Append(endValue.Property.Owner.Name + "." + endValue.Property.Name + " = " + endValue.Value.Value.ToString("F3") + ", ");
                sb.AppendLine("Duration = " + duration.Minutes.ToString("F3"));
            }

            if (m_IsRamped)
            {
                string text = "Table of timed events:" + Environment.NewLine + sb.ToString();
                Log.WriteLine(Id, "Gradient - " + text);

                // SendTimeTableCommand
                if (args.RunContext.IsManual)
                {
                    // SendStartCommand();
                }
            }
            else
            {
                string text = "Table of timed events: None";
                Log.WriteLine(Id, "Gradient - " + text);
            }
        }
コード例 #25
0
 /// <summary>
 /// We use OnTransferPreflightToRun to find out the end time of the instrument method.
 /// Usually our run should end shortly after that time.
 /// </summary>
 /// <param name="args"></param>
 void m_MyCmDevice_OnTransferPreflightToRun(PreflightEventArgs args)
 {
     m_EndTime = args.RunContext.ProgramTime;
 }