From 689c1846d841ba1b927eaf4c697270afa06a7b1e Mon Sep 17 00:00:00 2001 From: Yuki Matsuzawa Date: Mon, 28 Sep 2026 18:33:42 +0900 Subject: [PATCH 1/2] Read on/off method-file keys in both directions Several ConfigParser arms assigned only one of "true"/"false" and returned true for either, so the other value was recorded as applied and ignored. "Keep original precursor isotopes: True" never took effect, because the property defaults to false. Route every boolean arm through a Flag helper that accepts both values case-insensitively and reports anything else as an unusable value. Co-Authored-By: Claude Opus 5.5 --- .../MsdialCoreTestApp/Parser/ConfigParser.cs | 109 ++++++++++-------- .../Parser/ConfigParserTests.cs | 82 +++++++++++++ 2 files changed, 142 insertions(+), 49 deletions(-) diff --git a/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs b/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs index 779d210a4..3c476c40d 100644 --- a/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs +++ b/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs @@ -164,6 +164,29 @@ private static MethodKeyOutcome Count(string text, Action assign) { return MethodKeyOutcome.UnusableValue; } + /// + /// Read an on/off parameter, accepting "true" and "false" in any letter case. + /// + /// + /// Several arms used to assign only one of the two values - + /// case "keep original precursor isotopes": if (valueLower == "false") param.X = false; return true; + /// - so the other value was reported as applied and silently ignored. That was harmless + /// only while the constructor default happened to equal the value the arm could not + /// assign; KeepOriginalPrecursorIsotopes defaults to false, so "True" never took effect. + /// Anything other than true or false ("yes", "1", "on") is refused rather than guessed + /// at, because ParameterBase writes these keys with bool.ToString() and any other spelling + /// came from somewhere that did not know the format. + /// + private static MethodKeyOutcome Flag(string text, Action assign) { + if (string.Equals(text, "true", StringComparison.OrdinalIgnoreCase)) { + return Assign(true, assign); + } + if (string.Equals(text, "false", StringComparison.OrdinalIgnoreCase)) { + return Assign(false, assign); + } + return MethodKeyOutcome.UnusableValue; + } + /// /// Try the second reader only when the first did not recognise the key. /// @@ -897,11 +920,9 @@ public static MethodKeyOutcome ReadGcmsSpecificParameter(MsdialGcmsParameter par case "retention index alignment tolerance": return Number(valueLower, v => param.RetentionIndexAlignmentTolerance = (float)v); case "replace quant mass by user defined value": - if (valueLower == "true") - param.IsReplaceQuantmassByUserDefinedValue = true; return true; + return Flag(valueLower, v => param.IsReplaceQuantmassByUserDefinedValue = v); case "is quant mass based on base peak mz": - if (valueLower == "true") - param.IsRepresentativeQuantMassBasedOnBasePeakMz = true; return true; + return Flag(valueLower, v => param.IsRepresentativeQuantMassBasedOnBasePeakMz = v); default: return false; } } @@ -916,9 +937,7 @@ public static MethodKeyOutcome ReadLcImMsSpecificParameter(MsdialLcImMsParameter case "drift time end": return Number(value, v => param.DriftTimeEnd = (float)v); case "accumulated rt ragne": return Number(value, v => param.AccumulatedRtRange = (float)v); case "accumulate ms2 spectra": - if (value == "true") - param.IsAccumulateMS2Spectra = true; - return true; + return Flag(value, v => param.IsAccumulateMS2Spectra = v); case "drift time alignment tolerance": return Number(value, v => param.DriftTimeAlignmentTolerance = (float)v); case "drift time alignment factor": return Number(value, v => param.DriftTimeAlignmentFactor = (float)v); case "ion mobility type": @@ -973,7 +992,7 @@ private static MethodKeyOutcome ReadMoleculerNetworkingParameter(MolecularSpectr if (value == "Bonanza" || value == "ModDot" || value == "Cosine" || value == "All") param.MsmsSimilarityCalc = (MsmsSimilarityCalc)Enum.Parse(typeof(MsmsSimilarityCalc), value, true); return true; case "mnisexportioncorrelation": - if (valueLower == "true" || valueLower == "false") param.MnIsExportIonCorrelation = bool.Parse(valueLower); return true; + return Flag(valueLower, v => param.MnIsExportIonCorrelation = v); default: return false; } } @@ -1074,13 +1093,9 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m // Private version case "is private version of tada": - if (valueLower == "true") - param.IsLabPrivateVersionTada = true; - return true; + return Flag(valueLower, v => param.IsLabPrivateVersionTada = v); case "is private version": - if (valueLower == "true") - param.IsLabPrivate = true; - return true; + return Flag(valueLower, v => param.IsLabPrivate = v); //Data correction case "retention time begin": return Number(valueLower, v => param.RetentionTimeBegin = (float)v); @@ -1129,8 +1144,8 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "amplitude cut off": return Number(valueLower, v => param.ChromDecBaseParam.AmplitudeCutoff = (float)v); case "relative amplitude cut off": return Number(valueLower, v => param.ChromDecBaseParam.RelativeAmplitudeCutoff = (float)v); case "keep isotope range": return Number(valueLower, v => param.KeptIsotopeRange = (float)v); - case "exclude after precursor": if (valueLower == "false") param.RemoveAfterPrecursor = false; return true; - case "keep original precursor isotopes": if (valueLower == "false") param.KeepOriginalPrecursorIsotopes = false; return true; + case "exclude after precursor": return Flag(valueLower, v => param.RemoveAfterPrecursor = v); + case "keep original precursor isotopes": return Flag(valueLower, v => param.KeepOriginalPrecursorIsotopes = v); case "target ce": return Number(valueLower, v => param.TargetCE = v); //Identification @@ -1165,15 +1180,14 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "total score cutoff for msp-based annotation": return Number(valueLower, v => param.MspSearchParam.TotalScoreCutoff = (float)v); case "ms1 tolerance for msp-based annotation": return Number(valueLower, v => param.MspSearchParam.Ms1Tolerance = (float)v); case "ms2 tolerance for msp-based annotation": return Number(valueLower, v => param.MspSearchParam.Ms2Tolerance = (float)v); - case "use retention information for msp-based annotation scoring": if (valueLower == "true" || valueLower == "false") param.MspSearchParam.IsUseTimeForAnnotationScoring = bool.Parse(valueLower); return true; - case "use retention information for msp-based annotation filtering": if (valueLower == "true" || valueLower == "false") param.MspSearchParam.IsUseTimeForAnnotationFiltering = bool.Parse(valueLower); return true; - case "use ccs for msp-based annotation scoring": if (valueLower == "true" || valueLower == "false") param.MspSearchParam.IsUseCcsForAnnotationScoring = bool.Parse(valueLower); return true; - case "use ccs for msp-based annotation filtering": if (valueLower == "true" || valueLower == "false") param.MspSearchParam.IsUseCcsForAnnotationFiltering = bool.Parse(valueLower); return true; - case "only report top hit for msp-based annotation": if (valueLower == "true" || valueLower == "false") param.OnlyReportTopHitInMspSearch = bool.Parse(valueLower); return true; + case "use retention information for msp-based annotation scoring": return Flag(valueLower, v => param.MspSearchParam.IsUseTimeForAnnotationScoring = v); + case "use retention information for msp-based annotation filtering": return Flag(valueLower, v => param.MspSearchParam.IsUseTimeForAnnotationFiltering = v); + case "use ccs for msp-based annotation scoring": return Flag(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationScoring = v); + case "use ccs for msp-based annotation filtering": return Flag(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationFiltering = v); + case "only report top hit for msp-based annotation": return Flag(valueLower, v => param.OnlyReportTopHitInMspSearch = v); case "execute annotation process only for alignment file": case "execute annotation process only for alignment file for msp-based annotation": - if (valueLower == "true" || valueLower == "false") param.IsIdentificationOnlyPerformedForAlignmentFile = bool.Parse(valueLower); - return true; + return Flag(valueLower, v => param.IsIdentificationOnlyPerformedForAlignmentFile = v); //Identification case "rt tolerance for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.RtTolerance = (float)v); @@ -1194,11 +1208,11 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "total score cutoff for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.TotalScoreCutoff = (float)v); case "ms1 tolerance for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.Ms1Tolerance = (float)v); case "ms2 tolerance for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.Ms2Tolerance = (float)v); - case "use retention information for lbm-based annotation scoring": if (valueLower == "true" || valueLower == "false") param.LbmSearchParam.IsUseTimeForAnnotationScoring = bool.Parse(valueLower); return true; - case "use retention information for lbm-based annotation filtering": if (valueLower == "true" || valueLower == "false") param.LbmSearchParam.IsUseTimeForAnnotationFiltering = bool.Parse(valueLower); return true; - case "use ccs for lbm-based annotation scoring": if (valueLower == "true" || valueLower == "false") param.LbmSearchParam.IsUseCcsForAnnotationScoring = bool.Parse(valueLower); return true; - case "use ccs for lbm-based annotation filtering": if (valueLower == "true" || valueLower == "false") param.MspSearchParam.IsUseCcsForAnnotationFiltering = bool.Parse(valueLower); return true; - case "execute annotation process only for alignment file for lbm-based annotation": if (valueLower == "true" || valueLower == "false") param.IsIdentificationOnlyPerformedForAlignmentFile = bool.Parse(valueLower); return true; + case "use retention information for lbm-based annotation scoring": return Flag(valueLower, v => param.LbmSearchParam.IsUseTimeForAnnotationScoring = v); + case "use retention information for lbm-based annotation filtering": return Flag(valueLower, v => param.LbmSearchParam.IsUseTimeForAnnotationFiltering = v); + case "use ccs for lbm-based annotation scoring": return Flag(valueLower, v => param.LbmSearchParam.IsUseCcsForAnnotationScoring = v); + case "use ccs for lbm-based annotation filtering": return Flag(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationFiltering = v); + case "execute annotation process only for alignment file for lbm-based annotation": return Flag(valueLower, v => param.IsIdentificationOnlyPerformedForAlignmentFile = v); //Post identification @@ -1207,11 +1221,11 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "ccs tolerance for text-based annotation": return Number(valueLower, v => param.TextDbSearchParam.CcsTolerance = (float)v); case "total score cutoff for text-based annotation": return Number(valueLower, v => param.TextDbSearchParam.TotalScoreCutoff = (float)v); case "accurate ms1 tolerance for text-based annotation": return Number(valueLower, v => param.TextDbSearchParam.Ms1Tolerance = (float)v); - case "use retention information for text-based annotation scoring": if (valueLower == "true" || valueLower == "false") param.TextDbSearchParam.IsUseTimeForAnnotationScoring = bool.Parse(valueLower); return true; - case "use retention information for text-based annotation filtering": if (valueLower == "true" || valueLower == "false") param.TextDbSearchParam.IsUseTimeForAnnotationFiltering = bool.Parse(valueLower); return true; - case "use ccs for text-based annotation scoring": if (valueLower == "true" || valueLower == "false") param.TextDbSearchParam.IsUseCcsForAnnotationScoring = bool.Parse(valueLower); return true; - case "use ccs for text-based annotation filtering": if (valueLower == "true" || valueLower == "false") param.TextDbSearchParam.IsUseCcsForAnnotationFiltering = bool.Parse(valueLower); return true; - case "only report top hit for text-based annotation": if (valueLower == "true" || valueLower == "false") param.OnlyReportTopHitInTextDBSearch = bool.Parse(valueLower); return true; + case "use retention information for text-based annotation scoring": return Flag(valueLower, v => param.TextDbSearchParam.IsUseTimeForAnnotationScoring = v); + case "use retention information for text-based annotation filtering": return Flag(valueLower, v => param.TextDbSearchParam.IsUseTimeForAnnotationFiltering = v); + case "use ccs for text-based annotation scoring": return Flag(valueLower, v => param.TextDbSearchParam.IsUseCcsForAnnotationScoring = v); + case "use ccs for text-based annotation filtering": return Flag(valueLower, v => param.TextDbSearchParam.IsUseCcsForAnnotationFiltering = v); + case "only report top hit for text-based annotation": return Flag(valueLower, v => param.OnlyReportTopHitInTextDBSearch = v); //Alignment parameters setting case "alignment reference file id": return Count(valueLower, v => param.AlignmentReferenceFileID = v); @@ -1221,13 +1235,13 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "spectrum similarity factor for alignment": return Number(valueLower, v => param.SpectrumSimilarityAlignmentFactor = (float)v); case "ms1 tolerance for alignment": return Number(valueLower, v => param.Ms1AlignmentTolerance = (float)v); case "ms1 factor for alignment": return Number(valueLower, v => param.Ms1AlignmentFactor = (float)v); - case "force insert peaks in gap filling": if (valueLower == "true" || valueLower == "false") param.IsForceInsertForGapFilling = bool.Parse(valueLower); return true; - case "together with alignment": if (valueLower == "true" || valueLower == "false") param.TogetherWithAlignment = bool.Parse(valueLower); return true; + case "force insert peaks in gap filling": return Flag(valueLower, v => param.IsForceInsertForGapFilling = v); + case "together with alignment": return Flag(valueLower, v => param.TogetherWithAlignment = v); //Filtering case "peak count filter": return Number(valueLower, v => param.PeakCountFilter = (float)v); case "n percent detected in one group": return Number(valueLower, v => param.NPercentDetectedInOneGroup = (float)v); - case "remove feature based on peak height fold-change": if (valueLower == "true" || valueLower == "false") param.IsRemoveFeatureBasedOnBlankPeakHeightFoldChange = bool.Parse(valueLower); return true; + case "remove feature based on peak height fold-change": return Flag(valueLower, v => param.IsRemoveFeatureBasedOnBlankPeakHeightFoldChange = v); case "blank filtering": if (valueLower.ToLower() == "samplemaxoverblankave") param.BlankFiltering = (BlankFiltering)Enum.Parse(typeof(BlankFiltering), valueLower, true); @@ -1238,14 +1252,14 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m param.FoldChangeForBlankFiltering = (float)v; }); case "sample average / blank average": return Number(valueLower, v => param.SampleAverageOverBlankAverage = (float)v); - case "keep reference matched metabolites": if (valueLower == "true" || valueLower == "false") param.IsKeepRefMatchedMetaboliteFeatures = bool.Parse(valueLower); return true; - case "keep suggested metabolites": if (valueLower == "true" || valueLower == "false") param.IsKeepSuggestedMetaboliteFeatures = bool.Parse(valueLower); return true; - case "keep removable features and assigned tag for checking": if (valueLower == "true" || valueLower == "false") param.IsKeepRemovableFeaturesAndAssignedTagForChecking = bool.Parse(valueLower); return true; - case "replace true zero values with 1/2 of minimum peak height over all samples": if (valueLower == "true" || valueLower == "false") param.IsReplaceTrueZeroValuesWithHalfOfMinimumPeakHeightOverAllSamples = bool.Parse(valueLower); return true; + case "keep reference matched metabolites": return Flag(valueLower, v => param.IsKeepRefMatchedMetaboliteFeatures = v); + case "keep suggested metabolites": return Flag(valueLower, v => param.IsKeepSuggestedMetaboliteFeatures = v); + case "keep removable features and assigned tag for checking": return Flag(valueLower, v => param.IsKeepRemovableFeaturesAndAssignedTagForChecking = v); + case "replace true zero values with 1/2 of minimum peak height over all samples": return Flag(valueLower, v => param.IsReplaceTrueZeroValuesWithHalfOfMinimumPeakHeightOverAllSamples = v); //Retentiontime correction - case "execute rt correction": if (valueLower == "true" || valueLower == "false") param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.ExcuteRtCorrection = bool.Parse(valueLower); return true; - case "rt correction with smoothing for rt diff": if (valueLower == "true" || valueLower == "false") param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.doSmoothing = bool.Parse(valueLower); return true; + case "execute rt correction": return Flag(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.ExcuteRtCorrection = v); + case "rt correction with smoothing for rt diff": return Flag(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.doSmoothing = v); case "user setting intercept": return Number(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.UserSettingIntercept = (float)v); case "rt diff calc method": if (valueLower == "sampleminussampleaverage" || valueLower == "sampleminusreference") @@ -1274,8 +1288,8 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m }); //Isotope tracking setting - case "tracking isotope label": if (valueLower == "true" || valueLower == "false") param.TrackingIsotopeLabels = bool.Parse(valueLower); return true; - case "set fully labeled reference file": if (valueLower == "true" || valueLower == "false") param.SetFullyLabeledReferenceFile = bool.Parse(valueLower); return true; + case "tracking isotope label": return Flag(valueLower, v => param.TrackingIsotopeLabels = v); + case "set fully labeled reference file": return Flag(valueLower, v => param.SetFullyLabeledReferenceFile = v); case "non labeled reference id": return Count(valueLower, v => param.NonLabeledReferenceID = v); case "fully labeled reference id": return Count(valueLower, v => param.FullyLabeledReferenceID = v); // ParameterBase writes "Number of threads" into every exported method file, @@ -1293,10 +1307,7 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m //CorrDec settings case "corrdec execute": - if (valueLower.ToLower() == "false") { - param.CorrDecParam.CanExcute = false; - } - return true; + return Flag(valueLower, v => param.CorrDecParam.CanExcute = v); case "corrdec ms2 tolerance": return Number(valueLower, v => param.CorrDecParam.MS2Tolerance = (float)v); case "corrdec minimum ms2 peak height": @@ -1316,7 +1327,7 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "corrdec minimum ms2 relative intensity": return Number(valueLower, v => param.CorrDecParam.MinMS2RelativeIntensity = (float)v); case "corrdec remove peaks larger than precursor": - if (valueLower == "true" || valueLower == "false") param.CorrDecParam.CorrDecRemoveAfterPrecursor = bool.Parse(valueLower); return true; + return Flag(valueLower, v => param.CorrDecParam.CorrDecRemoveAfterPrecursor = v); default: return false; } } diff --git a/tests/MSDIAL5/MsdialCoreTestAppTests/Parser/ConfigParserTests.cs b/tests/MSDIAL5/MsdialCoreTestAppTests/Parser/ConfigParserTests.cs index d0da86837..94b3fa3d0 100644 --- a/tests/MSDIAL5/MsdialCoreTestAppTests/Parser/ConfigParserTests.cs +++ b/tests/MSDIAL5/MsdialCoreTestAppTests/Parser/ConfigParserTests.cs @@ -1,6 +1,8 @@ using CompMs.App.MsdialConsole.Parser; using CompMs.Common.DataObj.Result; using CompMs.Common.Enum; +using CompMs.MsdialGcMsApi.Parameter; +using CompMs.MsdialLcImMsApi.Parameter; using CompMs.MsdialLcmsApi.Parameter; using Microsoft.VisualStudio.TestTools.UnitTesting; using Newtonsoft.Json.Linq; @@ -122,6 +124,86 @@ public void ReadCommonParameter_ReadsTheTwoKeysABadRenameHadMadeUnreachable() Assert.IsTrue(parameter.IsReplaceTrueZeroValuesWithHalfOfMinimumPeakHeightOverAllSamples); } + [DataTestMethod] + [DataRow("keep original precursor isotopes")] + [DataRow("exclude after precursor")] + [DataRow("corrdec execute")] + [DataRow("is private version")] + [DataRow("is private version of tada")] + public void ReadCommonParameter_ReadsAnOnOffKeyInBothDirections(string key) + { + // THE REGRESSION. These arms assigned only one of the two values and returned true for + // either, so the other value was reported as applied and silently ignored. + // KeepOriginalPrecursorIsotopes defaults to false, so "Keep original precursor isotopes: + // True" never took effect while the key record said it had. + var parameter = new MsdialLcmsParameter(); + Func current = key switch + { + "keep original precursor isotopes" => () => parameter.KeepOriginalPrecursorIsotopes, + "exclude after precursor" => () => parameter.RemoveAfterPrecursor, + "corrdec execute" => () => parameter.CorrDecParam.CanExcute, + "is private version" => () => parameter.IsLabPrivate, + "is private version of tada" => () => parameter.IsLabPrivateVersionTada, + _ => throw new ArgumentOutOfRangeException(nameof(key)), + }; + + AssertReadsBothDirections(value => ConfigParser.ReadCommonParameter(parameter, key, value), current); + } + + [DataTestMethod] + [DataRow("replace quant mass by user defined value")] + [DataRow("is quant mass based on base peak mz")] + public void ReadGcmsSpecificParameter_ReadsAnOnOffKeyInBothDirections(string key) + { + var parameter = new MsdialGcmsParameter(); + Func current = key switch + { + "replace quant mass by user defined value" => () => parameter.IsReplaceQuantmassByUserDefinedValue, + "is quant mass based on base peak mz" => () => parameter.IsRepresentativeQuantMassBasedOnBasePeakMz, + _ => throw new ArgumentOutOfRangeException(nameof(key)), + }; + + AssertReadsBothDirections(value => ConfigParser.ReadGcmsSpecificParameter(parameter, key, value), current); + } + + [TestMethod] + public void ReadLcImMsSpecificParameter_ReadsAccumulateMs2SpectraInBothDirections() + { + var parameter = new MsdialLcImMsParameter(); + + AssertReadsBothDirections( + value => ConfigParser.ReadLcImMsSpecificParameter(parameter, "accumulate ms2 spectra", value), + () => parameter.IsAccumulateMS2Spectra); + } + + [TestMethod] + public void ReadCommonParameter_ReportsAnUnreadableOnOffValueOnAKeyThatWasAlreadyTwoWay() + { + // These arms already assigned both values, but still answered true for "yes", so the + // key record said a value was applied that the run never saw. + var parameter = new MsdialLcmsParameter(); + + AssertReadsBothDirections( + value => ConfigParser.ReadCommonParameter(parameter, "together with alignment", value), + () => parameter.TogetherWithAlignment); + } + + private static void AssertReadsBothDirections(Func read, Func current) + { + Assert.IsTrue(read("True").IsApplied); + Assert.IsTrue(current(), "True takes effect"); + + Assert.IsTrue(read("False").IsApplied); + Assert.IsFalse(current(), "False takes effect"); + + Assert.IsTrue(read("TRUE").IsApplied); + Assert.IsTrue(current(), "the letter case does not matter"); + + var unusable = read("yes"); + Assert.IsTrue(unusable.IsUnusableValue, "a value that is neither true nor false is reported, not guessed at"); + Assert.IsTrue(current(), "the refused value left the previous one alone"); + } + [TestMethod] public void ReadCommonParameter_TreatsAThreadCountOutsideTheUsableRangeAsUnusable() { From 486dd577bdfaf7b73cb0b172b6cb2082b36a4307 Mon Sep 17 00:00:00 2001 From: Yuki Matsuzawa Date: Tue, 29 Sep 2026 11:19:44 +0900 Subject: [PATCH 2/2] Name the on/off helper TrueOrFalse, as master already does Co-Authored-By: Claude Opus 5.5 --- .../MsdialCoreTestApp/Parser/ConfigParser.cs | 86 +++++++++---------- 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs b/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs index 05e380578..7e8b384a0 100644 --- a/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs +++ b/tests/MSDIAL5/MsdialCoreTestApp/Parser/ConfigParser.cs @@ -177,7 +177,7 @@ private static MethodKeyOutcome Count(string text, Action assign) { /// at, because ParameterBase writes these keys with bool.ToString() and any other spelling /// came from somewhere that did not know the format. /// - private static MethodKeyOutcome Flag(string text, Action assign) { + private static MethodKeyOutcome TrueOrFalse(string text, Action assign) { if (string.Equals(text, "true", StringComparison.OrdinalIgnoreCase)) { return Assign(true, assign); } @@ -477,7 +477,7 @@ private static MethodKeyOutcome AlignmentLightModeLine(string method, string val case "alignment light mode": case "alignment light": case "console alignment light mode": - return Flag(value, assign); + return TrueOrFalse(value, assign); default: return MethodKeyOutcome.UnknownKey; } @@ -499,7 +499,7 @@ private static MethodKeyOutcome DetailedAlignmentProvenanceLine(string method, s switch (method.ToLower()) { case "detailed alignment provenance": case "export detailed alignment provenance": - return Flag(value, assign); + return TrueOrFalse(value, assign); default: return MethodKeyOutcome.UnknownKey; } @@ -509,7 +509,7 @@ private static MethodKeyOutcome AnnotationCandidateExportLine(string method, str switch (method.ToLower()) { case "annotation candidates": case "export annotation candidates": - return Flag(value, assign); + return TrueOrFalse(value, assign); default: return MethodKeyOutcome.UnknownKey; } @@ -956,9 +956,9 @@ public static MethodKeyOutcome ReadGcmsSpecificParameter(MsdialGcmsParameter par case "retention index alignment tolerance": return Number(valueLower, v => param.RetentionIndexAlignmentTolerance = (float)v); case "replace quant mass by user defined value": - return Flag(valueLower, v => param.IsReplaceQuantmassByUserDefinedValue = v); + return TrueOrFalse(valueLower, v => param.IsReplaceQuantmassByUserDefinedValue = v); case "is quant mass based on base peak mz": - return Flag(valueLower, v => param.IsRepresentativeQuantMassBasedOnBasePeakMz = v); + return TrueOrFalse(valueLower, v => param.IsRepresentativeQuantMassBasedOnBasePeakMz = v); default: return false; } } @@ -973,7 +973,7 @@ public static MethodKeyOutcome ReadLcImMsSpecificParameter(MsdialLcImMsParameter case "drift time end": return Number(value, v => param.DriftTimeEnd = (float)v); case "accumulated rt ragne": return Number(value, v => param.AccumulatedRtRange = (float)v); case "accumulate ms2 spectra": - return Flag(value, v => param.IsAccumulateMS2Spectra = v); + return TrueOrFalse(value, v => param.IsAccumulateMS2Spectra = v); case "drift time alignment tolerance": return Number(value, v => param.DriftTimeAlignmentTolerance = (float)v); case "drift time alignment factor": return Number(value, v => param.DriftTimeAlignmentFactor = (float)v); case "ion mobility type": @@ -1028,7 +1028,7 @@ private static MethodKeyOutcome ReadMoleculerNetworkingParameter(MolecularSpectr if (value == "Bonanza" || value == "ModDot" || value == "Cosine" || value == "All") param.MsmsSimilarityCalc = (MsmsSimilarityCalc)Enum.Parse(typeof(MsmsSimilarityCalc), value, true); return true; case "mnisexportioncorrelation": - return Flag(valueLower, v => param.MnIsExportIonCorrelation = v); + return TrueOrFalse(valueLower, v => param.MnIsExportIonCorrelation = v); default: return false; } } @@ -1129,9 +1129,9 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m // Private version case "is private version of tada": - return Flag(valueLower, v => param.IsLabPrivateVersionTada = v); + return TrueOrFalse(valueLower, v => param.IsLabPrivateVersionTada = v); case "is private version": - return Flag(valueLower, v => param.IsLabPrivate = v); + return TrueOrFalse(valueLower, v => param.IsLabPrivate = v); //Data correction case "retention time begin": return Number(valueLower, v => param.RetentionTimeBegin = (float)v); @@ -1180,8 +1180,8 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "amplitude cut off": return Number(valueLower, v => param.ChromDecBaseParam.AmplitudeCutoff = (float)v); case "relative amplitude cut off": return Number(valueLower, v => param.ChromDecBaseParam.RelativeAmplitudeCutoff = (float)v); case "keep isotope range": return Number(valueLower, v => param.KeptIsotopeRange = (float)v); - case "exclude after precursor": return Flag(valueLower, v => param.RemoveAfterPrecursor = v); - case "keep original precursor isotopes": return Flag(valueLower, v => param.KeepOriginalPrecursorIsotopes = v); + case "exclude after precursor": return TrueOrFalse(valueLower, v => param.RemoveAfterPrecursor = v); + case "keep original precursor isotopes": return TrueOrFalse(valueLower, v => param.KeepOriginalPrecursorIsotopes = v); case "target ce": return Number(valueLower, v => param.TargetCE = v); //Identification @@ -1216,14 +1216,14 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "total score cutoff for msp-based annotation": return Number(valueLower, v => param.MspSearchParam.TotalScoreCutoff = (float)v); case "ms1 tolerance for msp-based annotation": return Number(valueLower, v => param.MspSearchParam.Ms1Tolerance = (float)v); case "ms2 tolerance for msp-based annotation": return Number(valueLower, v => param.MspSearchParam.Ms2Tolerance = (float)v); - case "use retention information for msp-based annotation scoring": return Flag(valueLower, v => param.MspSearchParam.IsUseTimeForAnnotationScoring = v); - case "use retention information for msp-based annotation filtering": return Flag(valueLower, v => param.MspSearchParam.IsUseTimeForAnnotationFiltering = v); - case "use ccs for msp-based annotation scoring": return Flag(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationScoring = v); - case "use ccs for msp-based annotation filtering": return Flag(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationFiltering = v); - case "only report top hit for msp-based annotation": return Flag(valueLower, v => param.OnlyReportTopHitInMspSearch = v); + case "use retention information for msp-based annotation scoring": return TrueOrFalse(valueLower, v => param.MspSearchParam.IsUseTimeForAnnotationScoring = v); + case "use retention information for msp-based annotation filtering": return TrueOrFalse(valueLower, v => param.MspSearchParam.IsUseTimeForAnnotationFiltering = v); + case "use ccs for msp-based annotation scoring": return TrueOrFalse(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationScoring = v); + case "use ccs for msp-based annotation filtering": return TrueOrFalse(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationFiltering = v); + case "only report top hit for msp-based annotation": return TrueOrFalse(valueLower, v => param.OnlyReportTopHitInMspSearch = v); case "execute annotation process only for alignment file": case "execute annotation process only for alignment file for msp-based annotation": - return Flag(valueLower, v => param.IsIdentificationOnlyPerformedForAlignmentFile = v); + return TrueOrFalse(valueLower, v => param.IsIdentificationOnlyPerformedForAlignmentFile = v); //Identification case "rt tolerance for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.RtTolerance = (float)v); @@ -1244,11 +1244,11 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "total score cutoff for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.TotalScoreCutoff = (float)v); case "ms1 tolerance for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.Ms1Tolerance = (float)v); case "ms2 tolerance for lbm-based annotation": return Number(valueLower, v => param.LbmSearchParam.Ms2Tolerance = (float)v); - case "use retention information for lbm-based annotation scoring": return Flag(valueLower, v => param.LbmSearchParam.IsUseTimeForAnnotationScoring = v); - case "use retention information for lbm-based annotation filtering": return Flag(valueLower, v => param.LbmSearchParam.IsUseTimeForAnnotationFiltering = v); - case "use ccs for lbm-based annotation scoring": return Flag(valueLower, v => param.LbmSearchParam.IsUseCcsForAnnotationScoring = v); - case "use ccs for lbm-based annotation filtering": return Flag(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationFiltering = v); - case "execute annotation process only for alignment file for lbm-based annotation": return Flag(valueLower, v => param.IsIdentificationOnlyPerformedForAlignmentFile = v); + case "use retention information for lbm-based annotation scoring": return TrueOrFalse(valueLower, v => param.LbmSearchParam.IsUseTimeForAnnotationScoring = v); + case "use retention information for lbm-based annotation filtering": return TrueOrFalse(valueLower, v => param.LbmSearchParam.IsUseTimeForAnnotationFiltering = v); + case "use ccs for lbm-based annotation scoring": return TrueOrFalse(valueLower, v => param.LbmSearchParam.IsUseCcsForAnnotationScoring = v); + case "use ccs for lbm-based annotation filtering": return TrueOrFalse(valueLower, v => param.MspSearchParam.IsUseCcsForAnnotationFiltering = v); + case "execute annotation process only for alignment file for lbm-based annotation": return TrueOrFalse(valueLower, v => param.IsIdentificationOnlyPerformedForAlignmentFile = v); //Post identification @@ -1257,11 +1257,11 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "ccs tolerance for text-based annotation": return Number(valueLower, v => param.TextDbSearchParam.CcsTolerance = (float)v); case "total score cutoff for text-based annotation": return Number(valueLower, v => param.TextDbSearchParam.TotalScoreCutoff = (float)v); case "accurate ms1 tolerance for text-based annotation": return Number(valueLower, v => param.TextDbSearchParam.Ms1Tolerance = (float)v); - case "use retention information for text-based annotation scoring": return Flag(valueLower, v => param.TextDbSearchParam.IsUseTimeForAnnotationScoring = v); - case "use retention information for text-based annotation filtering": return Flag(valueLower, v => param.TextDbSearchParam.IsUseTimeForAnnotationFiltering = v); - case "use ccs for text-based annotation scoring": return Flag(valueLower, v => param.TextDbSearchParam.IsUseCcsForAnnotationScoring = v); - case "use ccs for text-based annotation filtering": return Flag(valueLower, v => param.TextDbSearchParam.IsUseCcsForAnnotationFiltering = v); - case "only report top hit for text-based annotation": return Flag(valueLower, v => param.OnlyReportTopHitInTextDBSearch = v); + case "use retention information for text-based annotation scoring": return TrueOrFalse(valueLower, v => param.TextDbSearchParam.IsUseTimeForAnnotationScoring = v); + case "use retention information for text-based annotation filtering": return TrueOrFalse(valueLower, v => param.TextDbSearchParam.IsUseTimeForAnnotationFiltering = v); + case "use ccs for text-based annotation scoring": return TrueOrFalse(valueLower, v => param.TextDbSearchParam.IsUseCcsForAnnotationScoring = v); + case "use ccs for text-based annotation filtering": return TrueOrFalse(valueLower, v => param.TextDbSearchParam.IsUseCcsForAnnotationFiltering = v); + case "only report top hit for text-based annotation": return TrueOrFalse(valueLower, v => param.OnlyReportTopHitInTextDBSearch = v); //Alignment parameters setting case "alignment reference file id": return Count(valueLower, v => param.AlignmentReferenceFileID = v); @@ -1271,9 +1271,9 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "spectrum similarity factor for alignment": return Number(valueLower, v => param.SpectrumSimilarityAlignmentFactor = (float)v); case "ms1 tolerance for alignment": return Number(valueLower, v => param.Ms1AlignmentTolerance = (float)v); case "ms1 factor for alignment": return Number(valueLower, v => param.Ms1AlignmentFactor = (float)v); - case "force insert peaks in gap filling": return Flag(valueLower, v => param.IsForceInsertForGapFilling = v); - case "together with alignment": return Flag(valueLower, v => param.TogetherWithAlignment = v); - case "execute automatic rt correction for alignment": return Flag(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.Execute = v); + case "force insert peaks in gap filling": return TrueOrFalse(valueLower, v => param.IsForceInsertForGapFilling = v); + case "together with alignment": return TrueOrFalse(valueLower, v => param.TogetherWithAlignment = v); + case "execute automatic rt correction for alignment": return TrueOrFalse(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.Execute = v); case "automatic rt correction reference file id": return Count(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.ReferenceFileId = v); case "automatic rt correction rt bin width": return Number(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.RtBinWidth = (float)v); case "automatic rt correction match rt tolerance": return Number(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.MatchRtTolerance = (float)v); @@ -1287,12 +1287,12 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "automatic rt correction minimum ideal slope": return Number(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.MinimumIdealSlope = (float)v); case "automatic rt correction outlier mad threshold": return Number(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.OutlierMadThreshold = (float)v); case "automatic rt correction reference centrality weight": return Number(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.ReferenceCentralityWeight = (float)v); - case "automatic rt correction interpolate blanks by analytical order": return Flag(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.InterpolateBlankByAnalyticalOrder = v); + case "automatic rt correction interpolate blanks by analytical order": return TrueOrFalse(valueLower, v => param.AlignmentBaseParam.AutomaticRtCorrection.InterpolateBlankByAnalyticalOrder = v); //Filtering case "peak count filter": return Number(valueLower, v => param.PeakCountFilter = (float)v); case "n percent detected in one group": return Number(valueLower, v => param.NPercentDetectedInOneGroup = (float)v); - case "remove feature based on peak height fold-change": return Flag(valueLower, v => param.IsRemoveFeatureBasedOnBlankPeakHeightFoldChange = v); + case "remove feature based on peak height fold-change": return TrueOrFalse(valueLower, v => param.IsRemoveFeatureBasedOnBlankPeakHeightFoldChange = v); case "blank filtering": if (valueLower.ToLower() == "samplemaxoverblankave") param.BlankFiltering = (BlankFiltering)Enum.Parse(typeof(BlankFiltering), valueLower, true); @@ -1303,14 +1303,14 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m param.FoldChangeForBlankFiltering = (float)v; }); case "sample average / blank average": return Number(valueLower, v => param.SampleAverageOverBlankAverage = (float)v); - case "keep reference matched metabolites": return Flag(valueLower, v => param.IsKeepRefMatchedMetaboliteFeatures = v); - case "keep suggested metabolites": return Flag(valueLower, v => param.IsKeepSuggestedMetaboliteFeatures = v); - case "keep removable features and assigned tag for checking": return Flag(valueLower, v => param.IsKeepRemovableFeaturesAndAssignedTagForChecking = v); - case "replace true zero values with 1/2 of minimum peak height over all samples": return Flag(valueLower, v => param.IsReplaceTrueZeroValuesWithHalfOfMinimumPeakHeightOverAllSamples = v); + case "keep reference matched metabolites": return TrueOrFalse(valueLower, v => param.IsKeepRefMatchedMetaboliteFeatures = v); + case "keep suggested metabolites": return TrueOrFalse(valueLower, v => param.IsKeepSuggestedMetaboliteFeatures = v); + case "keep removable features and assigned tag for checking": return TrueOrFalse(valueLower, v => param.IsKeepRemovableFeaturesAndAssignedTagForChecking = v); + case "replace true zero values with 1/2 of minimum peak height over all samples": return TrueOrFalse(valueLower, v => param.IsReplaceTrueZeroValuesWithHalfOfMinimumPeakHeightOverAllSamples = v); //Retentiontime correction - case "execute rt correction": return Flag(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.ExcuteRtCorrection = v); - case "rt correction with smoothing for rt diff": return Flag(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.doSmoothing = v); + case "execute rt correction": return TrueOrFalse(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.ExcuteRtCorrection = v); + case "rt correction with smoothing for rt diff": return TrueOrFalse(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.doSmoothing = v); case "user setting intercept": return Number(valueLower, v => param.RetentionTimeCorrectionCommon.RetentionTimeCorrectionParam.UserSettingIntercept = (float)v); case "rt diff calc method": if (valueLower == "sampleminussampleaverage" || valueLower == "sampleminusreference") @@ -1339,8 +1339,8 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m }); //Isotope tracking setting - case "tracking isotope label": return Flag(valueLower, v => param.TrackingIsotopeLabels = v); - case "set fully labeled reference file": return Flag(valueLower, v => param.SetFullyLabeledReferenceFile = v); + case "tracking isotope label": return TrueOrFalse(valueLower, v => param.TrackingIsotopeLabels = v); + case "set fully labeled reference file": return TrueOrFalse(valueLower, v => param.SetFullyLabeledReferenceFile = v); case "non labeled reference id": return Count(valueLower, v => param.NonLabeledReferenceID = v); case "fully labeled reference id": return Count(valueLower, v => param.FullyLabeledReferenceID = v); // ParameterBase writes "Number of threads" into every exported method file, @@ -1358,7 +1358,7 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m //CorrDec settings case "corrdec execute": - return Flag(valueLower, v => param.CorrDecParam.CanExcute = v); + return TrueOrFalse(valueLower, v => param.CorrDecParam.CanExcute = v); case "corrdec ms2 tolerance": return Number(valueLower, v => param.CorrDecParam.MS2Tolerance = (float)v); case "corrdec minimum ms2 peak height": @@ -1378,7 +1378,7 @@ public static MethodKeyOutcome ReadCommonParameter(ParameterBase param, string m case "corrdec minimum ms2 relative intensity": return Number(valueLower, v => param.CorrDecParam.MinMS2RelativeIntensity = (float)v); case "corrdec remove peaks larger than precursor": - return Flag(valueLower, v => param.CorrDecParam.CorrDecRemoveAfterPrecursor = v); + return TrueOrFalse(valueLower, v => param.CorrDecParam.CorrDecRemoveAfterPrecursor = v); default: return false; } }