public void Build() { foreach (var methodTranList in MethodTrans) { Console.Error.WriteLine("MESSAGE: Exporting method {0}", Path.GetFileName(methodTranList.FinalMethod)); if (string.IsNullOrEmpty(methodTranList.TransitionList)) { throw new IOException(string.Format("Failure creating method file {0}. The mass list is empty.", methodTranList.FinalMethod)); } string outMeth = EnsureExtension(methodTranList.OutputMethod, ".meth"); // Thermo needs the extension to be .meth if (!Equals(outMeth, methodTranList.OutputMethod) && File.Exists(methodTranList.OutputMethod)) { File.Move(methodTranList.OutputMethod, outMeth); } try { using (IMethodXMLContext mxc = MethodXMLFactory.CreateContext(InstrumentType, InstrumentVersion)) using (IMethodXML mx = mxc.Create()) { mx.Open(TemplateMethod); mx.EnableValidation(true); ListItem[] listItems = ParseList(methodTranList.TransitionList).ToArray(); if (!listItems.Any()) { throw new IOException("Empty mass list found."); } if (InstrumentType.Equals(InstrumentFusion)) { mx.ApplyMethodModificationsFromXML(GetFusionModificationXml(listItems, outMeth)); } else { mx.ImportMassListFromXML(GetTsqMassListXml(listItems, outMeth)); } mx.SaveAs(outMeth); } if (!File.Exists(outMeth)) { throw new IOException(string.Format("Failure creating method file {0}.", methodTranList.FinalMethod)); } } finally { if (!Equals(outMeth, methodTranList.OutputMethod)) { File.Move(outMeth, methodTranList.OutputMethod); } } } }
/// <summary> /// Helper function to get the MethodXMLContext /// </summary> /// <param name="model">The instrument model</param> /// <param name="version">The instrument version</param> /// <returns></returns> public static IMethodXMLContext CreateContext(string model = "", string version = "") { if (string.IsNullOrEmpty(model)) { model = MethodXMLFactory.GetInstalledServerModel(); } if (string.IsNullOrEmpty(version)) { version = MethodXMLFactory.GetLatestInstalledVersion(model); } if (!MethodXMLFactory.GetInstalledInstrumentModels().Contains(model)) { throw new ArgumentException("Cannot create method context for non-installed instrument model: " + model); } return(MethodXMLFactory.CreateContext(model, version)); }
/// <summary> /// Prints information about the executing computer's TNG status /// </summary> public static IEnumerable <string> PrintInformation() { // Get all installed instruments for executing computer // Searches the registry for installed TNG instruments. // HKEY_LOCAL_MACHINE\SOFTWARE\Thermo Instruments\TNG // or // HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Thermo Instruments\TNG var instruments = MethodXMLFactory.GetInstalledInstrumentModels(); yield return("== Configured Instruments =="); int i = 1; foreach (string instrument in instruments) { Console.WriteLine("{0,2}: {1}", i++, instrument); // Get all installed instrument versions for this particular instrument (i.e., Fusion 1.1, 1.2, etc...) var versions = MethodXMLFactory.GetInstalledVersions(instrument); // TNG can be installed as Full (connected to instrument) or Workstation (just MethodEditor) mode. var fullInstalledVersions = new HashSet <string>(MethodXMLFactory.GetFullInstalledVersions(instrument)); // The most recently installed version for this instrument model var lastInstalledVersion = MethodXMLFactory.GetLatestInstalledVersion(instrument); foreach (string version in versions) { yield return(string.Format("{0,8} ({1}){2}", version, fullInstalledVersions.Contains(version) ? "Full" : "WorkStation", version == lastInstalledVersion ? " Latest Installed" : "")); } } yield return("============================"); yield return(string.Format("Installed Server Model: {0}", MethodXMLFactory.GetInstalledServerModel())); yield return(string.Format("Installed Server Version: {0}", MethodXMLFactory.GetInstalledServerVersion())); }
public void ParseCommandArgs(string[] args) { string outputMethod = null; bool readStdin = false; bool multiFile = false; int i = 0; while (i < args.Length && args[i][0] == '-') { string arg = args[i++]; switch (arg[1]) { case 'f': InstrumentType = InstrumentFusion; break; case 'e': InstrumentType = InstrumentEndura; break; case 'q': InstrumentType = InstrumentQuantiva; break; case 'a': InstrumentType = InstrumentAltis; break; case 'o': if (i >= args.Length) { throw new UsageException(); } outputMethod = Path.GetFullPath(args[i++]); break; case 'x': ExportXml = true; break; case 's': readStdin = true; break; case 'm': multiFile = true; break; default: throw new UsageException(string.Format("Unknown argument {0}", arg)); } } InstrumentVersion = MethodXMLFactory.GetLatestInstalledVersion(InstrumentType); if (multiFile && !string.IsNullOrEmpty(outputMethod)) { Usage("Multi-file and specific output are not compatibile."); } int argcLeft = args.Length - i; if (argcLeft < 1 || (!readStdin && argcLeft < 2)) { Usage(); } TemplateMethod = Path.GetFullPath(args[i++]); // Read input into a list of lists of fields if (readStdin) { if (!multiFile && string.IsNullOrEmpty(outputMethod)) { Usage("Reading from standard in without multi-file format must specify an output file."); } ReadTransitions(Console.In, outputMethod); } else { for (; i < args.Length; i++) { string inputFile = Path.GetFullPath(args[i]); string filter = null; if (inputFile.Contains('*')) { filter = Path.GetFileName(inputFile); } else if (Directory.Exists(inputFile)) { filter = "*.csv"; } if (string.IsNullOrEmpty(filter)) { ReadFile(inputFile, outputMethod, multiFile); } else { string dirName = Path.GetDirectoryName(filter) ?? "."; foreach (var fileName in Directory.GetFiles(dirName, filter)) { ReadFile(Path.Combine(dirName, fileName), null, multiFile); } } } } }
/// <summary> /// Get all the installed instrument model names /// </summary> /// <returns>The installed instrument names</returns> public static IEnumerable <string> GetInstalledInstrumentModels() { return(MethodXMLFactory.GetInstalledInstrumentModels()); }
/// <summary> /// Applies the modification XML file to the method template, to produce a modified method file /// </summary> /// <param name="methodTemplate">The method to base off of</param> /// <param name="methodModXML">The modifications to be applied to the template method</param> /// <param name="outputMethod">The file path for the generated method</param> /// <param name="model">The instrument model</param> /// <param name="version">The instrument version</param> /// <param name="enableValidation">Enable automatic validation on saving</param> public static void ModifyMethod(string methodTemplate, string methodModXML, string outputMethod = "", string model = "", string version = "", bool enableValidation = true) { if (string.IsNullOrEmpty(methodTemplate)) { throw new ArgumentException("A method file path must be specified", "Method Template"); } if (string.IsNullOrEmpty(methodModXML)) { throw new ArgumentException("A method modification path must be specified", "Method Modification"); } // Handle relative/absolute paths methodTemplate = Path.GetFullPath(methodTemplate); methodModXML = Path.GetFullPath(methodModXML); // These files are required if (!File.Exists(methodTemplate)) { throw new IOException("File Not Found: " + methodTemplate); } if (!File.Exists(methodModXML)) { throw new IOException("File Not Found: " + methodModXML); } // Create output file path if not specified if (string.IsNullOrEmpty(outputMethod)) { outputMethod = methodTemplate.Replace(".meth", "_modified.meth"); } outputMethod = Path.GetFullPath(outputMethod); // Create output directory if doesn't exist if (!Directory.Exists(Path.GetDirectoryName(outputMethod))) { Directory.CreateDirectory(Path.GetDirectoryName(outputMethod)); } // If the instrument model is not specified, get the default installed one. (might not be the best) if (string.IsNullOrEmpty(model)) { model = MethodXMLFactory.GetInstalledServerModel(); if (string.IsNullOrEmpty(model)) { var instruments = MethodXMLFactory.GetInstalledInstrumentModels(); if (instruments.Count > 1) { throw new Exception(string.Format("Unable to find default installed instrument, you have {0} instruments registered", instruments.Count)); } else if (instruments.Count == 0) { throw new Exception("Unable to find any installed instruments!"); } else { model = instruments[0]; } } } // Get the type of instrument based on its name InstrumentFamily instrumentFamily = GetInstrumentFamilyFromModel(model); // Get the type of instrument modification based on the xml file InstrumentFamily xmlInstrumentFamily = GetInstrumentFamilyFromXml(methodModXML); // These two need to be equivalent to correctly apply the modifications if (instrumentFamily != xmlInstrumentFamily) { throw new ArgumentException(string.Format("The specified xml ({0}) is not compatible with the instrument model ({1}, {2})", xmlInstrumentFamily, instrumentFamily, model)); } using (IMethodXMLContext mxc = CreateContext(model, version)) using (IMethodXML xmlMeth = mxc.Create()) { // Open the template method xmlMeth.Open(methodTemplate); // Set the validation flag xmlMeth.EnableValidation(enableValidation); // Call the correct modification method based on the instrument type switch (instrumentFamily) { case InstrumentFamily.OrbitrapFusion: xmlMeth.ApplyMethodModificationsFromXMLFile(methodModXML); break; case InstrumentFamily.TSQ: xmlMeth.ImportMassListFromXMLFile(methodModXML); break; default: throw new ArgumentException("Unsupported instrument model:" + model); } // Save the in memory method to the output file xmlMeth.SaveAs(outputMethod); } }