private void SetNewStatusValue(StartupConfigurationMode configMode, SolutionInfoViewModel localSlnInfo, AnalysisStatus newStatus) { switch (configMode) { case StartupConfigurationMode.PvsVs2010: RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2010 = newStatus); break; case StartupConfigurationMode.PvsVs2012: RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2012 = newStatus); break; case StartupConfigurationMode.PvsVs2013: RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2013 = newStatus); break; case StartupConfigurationMode.PvsVs2015: RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2015 = newStatus); break; default: throw new InvalidOperationException( string.Format("Unsupported Visual Studio version: {0}", configMode)); } }
public override int GetHashCode() { int hash = 1; if (ContinuousAnalysis != 0) { hash ^= ContinuousAnalysis.GetHashCode(); } if (AnalysisStatus != 0) { hash ^= AnalysisStatus.GetHashCode(); } if (analysisStatusError_ != null) { hash ^= AnalysisStatusError.GetHashCode(); } if (Cpe.Length != 0) { hash ^= Cpe.GetHashCode(); } if (lastScanTime_ != null) { hash ^= LastScanTime.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
private void Execute(StartupConfigurationMode startupConfigurationMode, AnalysisStatus properInitialStatus, SolutionInfoViewModel solutionInfo, string currentTestingDir) { var testSolutionInfo = solutionInfo.TestSolutionInfo; var initialStatus = Utils.GetLaunchStatus(startupConfigurationMode, solutionInfo); if (initialStatus == AnalysisStatus.None) { throw new InvalidOperationException("Unable to determine the analysis status"); } if (initialStatus != properInitialStatus) { return; } var logFileName = Utils.GetLogFileName(currentTestingDir, testSolutionInfo); var analysisManager = new AnalysisManager( solutionInfo, startupConfigurationMode, initialStatus, logFileName, _currentHtmlLog); lock (_syncAnalysisManagers) { AnalysisManagers.Add(analysisManager); } analysisManager.Run(); OnCurrentAnalysisDone( new CurrentAnalysisDoneEventArgs(Interlocked.Increment(ref _totalFinishedCount))); }
private void UpdateStatus(AnalysisStatus status, int percentComplete) { if (status == AnalysisStatus.NetFailed && MessageBox.Show("The server is not responding. Retry?", "Error Contacting Server", MessageBoxButtons.YesNo) == DialogResult.Yes) { EF.ljArchive.Plugins.Core.RIDAnalysis.RetryServer(); } else if (status == AnalysisStatus.NetFailed) { pgb.Value = 0; lblProgress.Text = "Failed."; } else if (status == AnalysisStatus.Success) { UpdateTreeView(); lblProgress.Text = "Done."; if (EF.ljArchive.Plugins.Core.RIDAnalysis.Averages.Length > 1) { cmbBaseline.Enabled = true; } cmbBaseline.SelectedIndex = 0; cmbPresets.Enabled = true; cmbPresets.SelectedIndex = 0; tabControl.TabPages.Add(tpSummary); tabControl.TabPages.Add(tpOverTime); tabControl.TabPages.Add(tpHTMLCode); tabControl.SelectedIndex = 1; } pgb.Value = percentComplete; }
private void InitializeNotSupportedVersions() { if (_testSolutionInfo.StartupMode == StartupConfigurationMode.All) { return; } switch (_testSolutionInfo.StartupMode) { case StartupConfigurationMode.PvsVs2010: _launchStatusOnPvsVs2012 = _launchStatusOnPvsVs2013 = _launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotSupported; break; case StartupConfigurationMode.PvsVs2012: _launchStatusOnPvsVs2010 = _launchStatusOnPvsVs2013 = _launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotSupported; break; case StartupConfigurationMode.PvsVs2013: _launchStatusOnPvsVs2010 = _launchStatusOnPvsVs2012 = _launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotSupported; break; case StartupConfigurationMode.PvsVs2015: _launchStatusOnPvsVs2010 = _launchStatusOnPvsVs2012 = _launchStatusOnPvsVs2013 = AnalysisStatus.VsVersionNotSupported; break; } }
/// <summary> /// Нужно ли создавать конфигурацию для запуска под конкретную версию /// </summary> /// <param name="testSolutionInfos">VS-решения</param> /// <param name="vsVersion">Версия VS</param> /// <param name="properInitialStatus">Статус, под которым нужно звапускать анализ</param> /// <returns>true, если есть хотя бы один проект для запуска под конкретную версию, false - в противном случае</returns> public static bool NeedToRun(IEnumerable <SolutionInfoViewModel> testSolutionInfos, StartupConfigurationMode vsVersion, AnalysisStatus properInitialStatus) { var needToRun = false; switch (vsVersion) { case StartupConfigurationMode.PvsVs2010: needToRun = testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2010 == properInitialStatus); break; case StartupConfigurationMode.PvsVs2012: needToRun = testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2012 == properInitialStatus); break; case StartupConfigurationMode.PvsVs2013: needToRun = testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2013 == properInitialStatus); break; case StartupConfigurationMode.PvsVs2015: needToRun = testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2015 == properInitialStatus); break; } return(needToRun); }
public override Dictionary <string, object> DumpBasicEventData() { var rv = new Dictionary <string, object>(base.DumpBasicEventData()); rv.Add("Analysis Status", AnalysisStatus.ToString()); rv.Add("Calories From Carbs", CaloriesFromCarbs.ToString()); rv.Add("Calories From Fat", CaloriesFromFat.ToString()); rv.Add("StressBalance", StressBalance.ToString()); rv.Add("Maximal VO2", MaximalVO2.ToString()); rv.Add("Training Effect", TrainingEffect.ToString()); rv.Add("Recovery Time (sec)", RecoveryTime.ToString()); rv.Add("Paused Time", PausedTime.ToString()); rv.Add("Heart Rate at Finish", HeartRate.AtFinish); rv.Add("Recovery Heart Rate after 1 Minute", HeartRate.RecoveryHeartRate1Minute); rv.Add("Recovery Heart Rate after 2 Minutes", HeartRate.RecoveryHeartRate1Minute); rv.Add("Heart Rate Zone - Under", HeartRate.Zones.Under); rv.Add("Heart Rate Zone - Aerobic", HeartRate.Zones.Aerobic); rv.Add("Heart Rate Zone - Anaerobic", HeartRate.Zones.Anaerobic); rv.Add("Heart Rate Zone - FitnessZone", HeartRate.Zones.FitnessZone); rv.Add("Heart Rate Zone - RedLine", HeartRate.Zones.RedLine); rv.Add("Heart Rate Zone - Over", HeartRate.Zones.Over); return(rv); }
public override int GetHashCode() { int hash = 1; if (ContinuousAnalysis != global::Grafeas.V1.DiscoveryOccurrence.Types.ContinuousAnalysis.Unspecified) { hash ^= ContinuousAnalysis.GetHashCode(); } if (AnalysisStatus != global::Grafeas.V1.DiscoveryOccurrence.Types.AnalysisStatus.Unspecified) { hash ^= AnalysisStatus.GetHashCode(); } if (analysisStatusError_ != null) { hash ^= AnalysisStatusError.GetHashCode(); } if (Cpe.Length != 0) { hash ^= Cpe.GetHashCode(); } if (lastScanTime_ != null) { hash ^= LastScanTime.GetHashCode(); } if (archiveTime_ != null) { hash ^= ArchiveTime.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
internal void SetContinuation(Continuation continueBehavior) { Assert.IsNotNull(continueBehavior); this.continuation = continueBehavior; if (this.continuation.Equals(Continuation.Done)) { this.currentStatus = AnalysisStatus.Completed; return; } switch (this.continuation.ContinuationType) { case ContinuationType.WaitForTime: Assert.IsTrue(this.continuation.SuspendTimeout.HasValue, "Suspend Timeout should have value"); this.currentStatus = AnalysisStatus.Suspended; this.nextActivationTime = DateTime.UtcNow.Add(this.continuation.SuspendTimeout.Value); break; case ContinuationType.WaitForFabricEvent: this.currentStatus = AnalysisStatus.Suspended; break; case ContinuationType.WaitForInterest: this.currentStatus = AnalysisStatus.Suspended; break; default: throw new NotSupportedException(string.Format( CultureInfo.InvariantCulture, "Continuation Type: {0} is Unsupported", this.continuation.ContinuationType)); } }
private void SetInstalledConfiguration() { if (InstallationInfo.IsInstalledPvsStudio) { _launchStatusOnPvsVs2010 = InstallationInfo.IsInstalledVs2010 ? AnalysisStatus.NotStarted : AnalysisStatus.VsVersionNotInstalled; _launchStatusOnPvsVs2012 = InstallationInfo.IsInstalledVs2012 ? AnalysisStatus.NotStarted : AnalysisStatus.VsVersionNotInstalled; _launchStatusOnPvsVs2013 = InstallationInfo.IsInstalledVs2013 ? AnalysisStatus.NotStarted : AnalysisStatus.VsVersionNotInstalled; _launchStatusOnPvsVs2015 = InstallationInfo.IsInstalledVs2015 ? AnalysisStatus.NotStarted : AnalysisStatus.VsVersionNotInstalled; } else { _launchStatusOnPvsVs2010 = _launchStatusOnPvsVs2012 = _launchStatusOnPvsVs2013 = _launchStatusOnPvsVs2015 = AnalysisStatus.PluginNotInstalled; } }
private void theInkCanvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e) { var stroke = GetCombinedStore(this.theInkCanvas.Strokes); InkAnalyzer theInkAnalyzer = new InkAnalyzer(); //theInkAnalyzer.AddStrokes(this.theInkCanvas.Strokes, 0x0804); //theInkAnalyzer.SetStrokesType(this.theInkCanvas.Strokes, StrokeType.Writing); theInkAnalyzer.AddStroke(stroke, 0x0804); theInkAnalyzer.SetStrokeType(stroke, StrokeType.Writing); AnalysisStatus status = theInkAnalyzer.Analyze(); if (status.Successful) { List <StrokeWord> slist = new List <StrokeWord>(); //textBox1.Text = theInkAnalyzer.GetRecognizedString(); for (int i = 0; i < theInkAnalyzer.GetAlternates().Count; i++) { StrokeWord sw = new StrokeWord(); sw.StrokeName = theInkAnalyzer.GetAlternates()[i].RecognizedString; slist.Add(sw); } this.StrokeWordList = new List <StrokeWord>(); this.StrokeWordList = slist; } else { MessageBox.Show("识别失败"); } }
public DocumentData() { FilePath = string.Empty; FileName = string.Empty; IsChecked = true; AnalysisStatusInstance = AnalysisStatus.NotStarted; }
/// <summary> /// Mark analysis as finished. /// </summary> /// <remarks> /// Only NotStarted -> Queued or Suspended -> Queued are supported transitions. /// </remarks> internal void MarkQueued() { Assert.IsTrue( this.currentStatus == AnalysisStatus.NotStarted || this.currentStatus == AnalysisStatus.Suspended, () => string.Format(CultureInfo.InvariantCulture, "Current Status {0} -> Queued Not valid", this.currentStatus)); this.currentStatus = AnalysisStatus.Queued; }
/// <summary> /// Получение описания для статуса прохождения анализа /// </summary> /// <param name="analysisStatus">Статус прохождения анализа</param> /// <returns>Описание для статуса прохождения анализа</returns> public static string GetAnalysisStatusDescription(this AnalysisStatus analysisStatus) { return (analysisStatus.GetType() .GetField(analysisStatus.ToString()) .GetCustomAttributes(typeof(AnalysisStatusDescriptionAttribute), false) .Cast <AnalysisStatusDescriptionAttribute>() .First().AnalysisStatusDescription); }
/// <summary> /// Конструктор менеджера для тестового анализа /// </summary> /// <param name="slnInfoVm">Тестируемое решение</param> /// <param name="startupConfigurationMode">Версия Visual Studion, для которой нужно запустить решение</param> /// <param name="status">Начальный статус анализа</param> /// <param name="logFileName">Файл лога с результатами работы анализатора</param> /// <param name="htmlLog">Html-лог</param> public AnalysisManager(SolutionInfoViewModel slnInfoVm, StartupConfigurationMode startupConfigurationMode, AnalysisStatus status, string logFileName, string htmlLog) { SolutionInfo = slnInfoVm; StartupMode = startupConfigurationMode; _logFileName = logFileName; _snapshotFilename = string.Format("{0}{1}", _logFileName, SnapshotExt); _currentStatus = status; _htmlLog = htmlLog; }
/// <summary> /// Конструктор аргументов события анализа /// </summary> /// <param name="newStatus">Новый статус анализа</param> /// <param name="solutionInfoViewModel">Информация о VS-решении</param> /// <param name="startupMode">Конфигурация запуска</param> /// <param name="crashReason">Возможная причина сбоя</param> /// <param name="devenvExitCode">Код завершения devenv.exe</param> public TestAnalysisEventArgs(AnalysisStatus newStatus, SolutionInfoViewModel solutionInfoViewModel, StartupConfigurationMode startupMode, CrashReason crashReason = default(CrashReason), int devenvExitCode = default(int)) { NewStatus = newStatus; SolutionInfo = solutionInfoViewModel; StartupMode = startupMode; CrashReason = crashReason; DevenvExitCode = devenvExitCode; }
internal void MarkFailed() { Assert.IsTrue( this.currentStatus == AnalysisStatus.InProgress, () => string.Format(CultureInfo.InvariantCulture, "Transition From Current Status: {0} -> Failed Not valid", this.currentStatus)); this.currentStatus = AnalysisStatus.Failed; this.analysisEndTime = DateTime.UtcNow.ToUniversalTime(); }
/// <summary> /// Находится ли статус анализа в запущенном, но еще незавершенном состоянии /// </summary> /// <param name="status">Статус</param> /// <param name="resetFail">Нужно ли сбрасывать статус аварийного завершения</param> /// <returns>true, если статус анализа находится в запущенном, но еще незавершенном состоянии, false - в противном случае</returns> public static bool IsInActiveStatus(this AnalysisStatus status, bool resetFail = false) { var actives = new List <AnalysisStatus>(ActiveStatuses.Length + 1); actives.AddRange(ActiveStatuses); if (resetFail) { actives.Add(AnalysisStatus.PluginCrashed); } return(actives.Any(activeStatus => activeStatus == status)); }
public TrackInfo(string fileName, int trackNum) { songName = fileName.Substring(0, fileName.LastIndexOf('.')); this.trackNum = trackNum; measures = new List <Measure>(); score = new List <Note>(); representatives = new Dictionary <int, KeyValuePair <int, MelodicContour> >(); clusterOutputs = new Dictionary <int, string>(); clusterIDs = new List <int>(); repeatedMelodicContourSequences = new List <KeyValuePair <int, List <int> > >(); status = AnalysisStatus.Wait; }
/// <summary> /// Create an instance of <see cref="AnalysisSchedulingInformation"/> /// </summary> /// <param name="maxAnalysisAttempts"></param> public AnalysisSchedulingInformation(uint maxAnalysisAttempts = DefaultAnalysisAttempts) { if (maxAnalysisAttempts <= 0 || maxAnalysisAttempts > MaxAnalysisAttempts) { throw new ArgumentOutOfRangeException( "maxAnalysisAttempts", string.Format(CultureInfo.InvariantCulture, "Maximum Analysis attempt count is : '{0}'", MaxAnalysisAttempts)); } this.maxAttempts = maxAnalysisAttempts; this.instanceAnalysisAttemptedCount = 0; this.currentStatus = AnalysisStatus.NotStarted; this.continuation = null; }
/// <summary> /// Mark status as started /// </summary> /// <remarks> /// Only NotStarted -> Started or Queued -> Started are supported. /// TODO:: Fix Suspended??? /// </remarks> internal void MarkStarted() { Assert.IsFalse(this.IsOutOfAttempts(), "Already out of Attempts. Can't be transitioned to started"); Assert.IsTrue( this.currentStatus == AnalysisStatus.NotStarted || this.currentStatus == AnalysisStatus.Queued || this.currentStatus == AnalysisStatus.Suspended, string.Format(CultureInfo.InvariantCulture, "Transition From Current Status: {0} -> Started Not valid", this.currentStatus)); this.currentStatus = AnalysisStatus.InProgress; if (this.currentStatus == AnalysisStatus.NotStarted) { this.analysisStartTime = DateTime.UtcNow.ToUniversalTime(); } }
private static Tuple <StartupConfigurationMode, SolutionInfoViewModel>[] FilterSolutions( IEnumerable <Tuple <StartupConfigurationMode, SolutionInfoViewModel> > selectedSolutions, AnalysisStatus filterStatus) { var filtered = new List <Tuple <StartupConfigurationMode, SolutionInfoViewModel> >(); foreach (var solution in selectedSolutions) { var configMode = solution.Item1; var vm = solution.Item2; switch (configMode) { case StartupConfigurationMode.PvsVs2010: if (vm.LaunchStatusOnPvsVs2010 == filterStatus) { filtered.Add(solution); } break; case StartupConfigurationMode.PvsVs2012: if (vm.LaunchStatusOnPvsVs2012 == filterStatus) { filtered.Add(solution); } break; case StartupConfigurationMode.PvsVs2013: if (vm.LaunchStatusOnPvsVs2013 == filterStatus) { filtered.Add(solution); } break; case StartupConfigurationMode.PvsVs2015: if (vm.LaunchStatusOnPvsVs2015 == filterStatus) { filtered.Add(solution); } break; } } return(filtered.ToArray()); }
static public bool IsChar(this Stroq stroke, string charset) { System.Windows.Ink.InkAnalyzer ia = new InkAnalyzer(); ia.AddStroke(stroke.BackingStroke); //AnalysisHintNode node = ia.CreateAnalysisHint(); //node.Factoid = "IS_ONECHAR"; //node.CoerceToFactoid = true; //node.Location.MakeInfinite(); AnalysisStatus astat = ia.Analyze(); string reco = ia.GetRecognizedString(); Console.WriteLine("Recognized:<" + reco + ">"); if (astat.Successful && reco != "Other") { return(charset.Contains(reco[0])); } return(false); }
void theInkAnalyzer_ResultsUpdated(object sender, System.Windows.Ink.ResultsUpdatedEventArgs e) { AnalysisStatus status = e.Status; if (status.Successful) { string resultStr = this.theInkAnalyzer.GetRecognizedString(); List <string> resultStrArray = resultStr.Split(' ').ToList(); if (resultStrArray.Count > 0) { Application.Current.Dispatcher.BeginInvoke((Action)(() => { AnalyzResult(resultStrArray); })); } } }
/// <summary> /// Запуск анализатора для всех наборов /// </summary> /// <returns>Менеджеры для анализа</returns> public void RunAll(AnalysisStatus properInitialStatus = AnalysisStatus.NotStarted) { _startTestingTime = DateTime.Now; _totalFinishedCount = 0; var slnsByVersionMap = Utils.GroupSolutionsByVersion(SlnInfoVms); var startupConfigurationModes = slnsByVersionMap.Keys.ToArray(); Array.Sort(startupConfigurationModes, (version1, version2) => (int)version1 - (int)version2); foreach (var startupConfigurationMode in startupConfigurationModes) { var testSolutionInfos = slnsByVersionMap[startupConfigurationMode]; if (testSolutionInfos != null && testSolutionInfos.Count > 0) { RunAllByVersion(testSolutionInfos, startupConfigurationMode, properInitialStatus); } } _finishTestingTime = DateTime.Now; }
private void AddTextToReceiveBox(byte[] frame) { if (frame[0] == 0x02) { string dataOutPut = ""; for (int i = 7; i < frameIdx - 2; i++) { dataOutPut += (char)frame[i]; } dataOutPut += '\n'; Dispatcher.BeginInvoke((Action)(() => ReceivedTextBox.Text += dataOutPut)); SendACK(); } analysisStatus = AnalysisStatus.BEGIN; }
/// <summary> /// Установка свойств решения для запуска /// </summary> /// <param name="startupConfigurationMode">Конфигурация запуска</param> /// <param name="slnInfo">Модель решения</param> /// <param name="pendingStatus">Статус планирования к запуску</param> /// <param name="currentTotalCount">Счетчик решений, запланированных к запуску</param> public static void EstablishLaunchStatus(StartupConfigurationMode startupConfigurationMode, SolutionInfoViewModel slnInfo, AnalysisStatus pendingStatus, ref int currentTotalCount) { switch (startupConfigurationMode) { case StartupConfigurationMode.PvsVs2010: var pvsVs2010Stat = slnInfo.LaunchStatusOnPvsVs2010; if (!pvsVs2010Stat.IsInDisablingStatus()) { slnInfo.LaunchStatusOnPvsVs2010 = pendingStatus; currentTotalCount++; } break; case StartupConfigurationMode.PvsVs2012: var pvsVs2012Stat = slnInfo.LaunchStatusOnPvsVs2012; if (!pvsVs2012Stat.IsInDisablingStatus()) { slnInfo.LaunchStatusOnPvsVs2012 = pendingStatus; currentTotalCount++; } break; case StartupConfigurationMode.PvsVs2013: var pvsVs2013Stat = slnInfo.LaunchStatusOnPvsVs2013; if (!pvsVs2013Stat.IsInDisablingStatus()) { slnInfo.LaunchStatusOnPvsVs2013 = pendingStatus; currentTotalCount++; } break; case StartupConfigurationMode.PvsVs2015: var pvsVs2015Stat = slnInfo.LaunchStatusOnPvsVs2015; if (!pvsVs2015Stat.IsInDisablingStatus()) { slnInfo.LaunchStatusOnPvsVs2015 = pendingStatus; currentTotalCount++; } break; } }
private void ResetNotSupportedForNotInstalled() { if (_launchStatusOnPvsVs2010 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2010) { _launchStatusOnPvsVs2010 = AnalysisStatus.VsVersionNotInstalled; } if (_launchStatusOnPvsVs2012 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2012) { _launchStatusOnPvsVs2012 = AnalysisStatus.VsVersionNotInstalled; } if (_launchStatusOnPvsVs2013 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2013) { _launchStatusOnPvsVs2013 = AnalysisStatus.VsVersionNotInstalled; } if (_launchStatusOnPvsVs2015 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2015) { _launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotInstalled; } }
public MyInkAnalyzer(StrokeCollection strokeCollection) { if (strokeCollection.Count > 0) { _strokeCollection = strokeCollection; analyze = new InkAnalyzer(); //2052:简体中文 1033:英语 analyze.AddStrokes(strokeCollection, GlobalValues.InkAnalyzerLanguageId); //analyze.BackgroundAnalyze(); AnalysisStatus status = analyze.Analyze(); if (status.Successful) { analyzeResults = analyze.GetRecognizedString(); } else { analyzeResults = "Recognition Failed"; } analyze.RemoveStrokes(_strokeCollection); } }
/// <summary> /// Update status. /// </summary> public void UpdateStatus() { foreach (Job m in m_jobs) { m.Update(); } AnalysisStatus status = AnalysisStatus.Finished; int count = 0; foreach (Job m in m_jobs) { if (m.Status != JobStatus.RUNNING && m.Status != JobStatus.QUEUED) count++; if (m.Status == JobStatus.RUNNING || (m_isRunning && (m.Status == JobStatus.QUEUED || m.Status == JobStatus.NONE))) { status = AnalysisStatus.Running; break; } if (status != AnalysisStatus.Running && (!m_isRunning && m.Status == JobStatus.QUEUED)) { status = AnalysisStatus.Waiting; break; } if (m.Status == JobStatus.STOPPED) { status = AnalysisStatus.Stopped; } else if (m.Status == JobStatus.ERROR && status == AnalysisStatus.Finished) { status = AnalysisStatus.Error; } } if (count != m_jobs.Count) { // m_status = AnalysisStatus.Running; } else if (m_isRunning == true) { m_isRunning = false; if (m_analysis != null && m_isAllRun) m_analysis.NotifyAnalysisFinished(); } if (m_isGroupError) status = AnalysisStatus.WarnFinished; m_status = status; }
/// Initializes a new instance of the <see cref="CrossSectionWorkflowResult"/> class. /// Constructor for no isomer result. public CrossSectionWorkflowResult( string datasetPath, IImsTarget target, AnalysisStatus analysisStatus, AssociationHypothesisInfo associationHypothesisInfo, PeakScores averageObservedPeakStatistics, double averageVoltageGroupStability, string analysisDirectory, string dateTime) : this(datasetPath, target, analysisStatus, associationHypothesisInfo, new List<IdentifiedIsomerInfo>(), averageObservedPeakStatistics, averageVoltageGroupStability, analysisDirectory, dateTime) { }
/// <summary> /// Initializes a new instance of the <see cref="CrossSectionWorkflowResult"/> class. /// Multiple isomer result constructor /// </summary> /// <param name="datasetName"> /// The dataset name. /// </param> /// <param name="target"> /// The target. /// </param> /// <param name="analysisStatus"> /// The analysis status. /// </param> /// <param name="associationHypothesisInfo"> /// The analysis scores holder. /// </param> /// <param name="isomerResults"> /// The isomer results. /// </param> /// <param name="averageObservedPeakStatistics"></param> /// <param name="averageVoltageGroupStability"></param> /// <param name="datasetPath"></param> /// <param name="analysisDirectory"></param> /// <param name="dateTime"></param> public CrossSectionWorkflowResult( string datasetPath, IImsTarget target, AnalysisStatus analysisStatus, AssociationHypothesisInfo associationHypothesisInfo, IList<IdentifiedIsomerInfo> isomerResults, PeakScores averageObservedPeakStatistics, double averageVoltageGroupStability, string analysisDirectory, string dateTime) { this.Target = target; this.AnalysisStatus = analysisStatus; this.AssociationHypothesisInfo = associationHypothesisInfo; this.isomerResults = isomerResults; this.AverageObservedPeakStatistics = averageObservedPeakStatistics; this.AverageVoltageGroupStability = averageVoltageGroupStability; this.AnalysisDirectory = analysisDirectory; this.DateTime = dateTime; this.DatasetPath = datasetPath; this.DatasetName = Path.GetFileNameWithoutExtension(datasetPath); this.DateTime = dateTime; }
internal void SetAnalysisStatus(AnalysisStatus status) { this.currentStatus = status; }
/// <summary> /// Initializes a new instance of the <see cref="LibraryMatchResult"/> class. /// </summary> /// <param name="peak"> /// The peak. /// </param> /// <param name="conlusion"> /// The conlusion. /// </param> /// <param name="distance"> /// The distance. /// </param> public LibraryMatchResult(StandardImsPeak peak, AnalysisStatus conlusion, DriftTimeFeatureDistance distance) { this.AnalysisStatus = conlusion; this.ImsFeature = peak; this.distance = distance; }
/// <summary> /// Initializes a new instance of the <see cref="IdentifiedIsomerInfo"/> class. /// </summary> /// <param name="numberOfFeaturePointsUsed"> /// The number of feature points used. /// </param> /// <param name="mzInDalton"></param> /// <param name="rSquared"> /// The r squred. /// </param> /// <param name="mobility"> /// The mobility. /// </param> /// <param name="crossSectionalArea"> /// The cross sectional area. /// </param> /// <param name="averageVoltageGroupStabilityScore"> /// The average voltage group stability score. /// </param> /// <param name="arrivalTimeSnapShots"> /// The arrival time snap shots. /// </param> /// <param name="viperCompatibleMass"> /// The viper Compatible Mass. /// </param> /// <param name="analysisStatus"></param> /// <param name="peakScores"></param> /// <param name="target"></param> public IdentifiedIsomerInfo( int numberOfFeaturePointsUsed, double mzInDalton, double rSquared, double mobility, double crossSectionalArea, double averageVoltageGroupStabilityScore, IEnumerable<ArrivalTimeSnapShot> arrivalTimeSnapShots, double viperCompatibleMass, AnalysisStatus analysisStatus, PeakScores peakScores, IImsTarget target, double t0, double bestMzInPpm) { this.NumberOfFeaturePointsUsed = numberOfFeaturePointsUsed; this.RSquared = rSquared; this.Mobility = mobility; this.CrossSectionalArea = crossSectionalArea; this.AverageVoltageGroupStabilityScore = averageVoltageGroupStabilityScore; this.ArrivalTimeSnapShots = arrivalTimeSnapShots; this.ViperCompatibleMass = viperCompatibleMass; this.AnalysisStatus = analysisStatus; this.PeakScores = peakScores; this.T0 = t0; this.MzInDalton = mzInDalton; this.MzInPpm = Metrics.DaltonToPpm(mzInDalton - target.MassWithAdduct, target.MassWithAdduct); this.RelativeMzInPpm = Math.Abs(MzInPpm - bestMzInPpm); }
/// <summary> /// The is conclusive. /// </summary> /// <param name="status"> /// The status. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private static bool IsConclusive(AnalysisStatus status) { if (status == AnalysisStatus.Positive || status == AnalysisStatus.Negative) { return true; } return false; }