public void TestBinaryDeserialize() { BinarySerial serializer = new BinarySerial(); BinaryModel model = serializer.DeserializeBinaryData(); Assert.AreEqual(model.Commmand, serializer.GetModel().Commmand); }
/// <summary> /// Populates the edges list based on the SBML Qual model content. /// </summary> /// <param name="model">The target binary model to populate</param> /// <param name="sbmlModel">The input SBML Qual model</param> private void PopulateEdges(BinaryModel model, Model sbmlModel) { var modelQualPlugin = (QualModelPlugin)sbmlModel.getPlugin("qual"); var numTransitions = modelQualPlugin.getNumTransitions(); for (var i = 0; i < numTransitions; i++) { var transition = modelQualPlugin.getTransition(i); var numInputs = transition.getNumInputs(); var numOutputs = transition.getNumOutputs(); for (var j = 0; j < numInputs; j++) { var input = transition.getInput(j); for (var k = 0; k < numOutputs; k++) { var output = transition.getOutput(k); var edge = new BinaryEdge(model, transition.getId(), input.getSign() == libsbml.INPUT_SIGN_NEGATIVE ? EdgeType.Negative : EdgeType.Positive) { Input = model.Nodes.FirstOrDefault(n => n.Id.Equals(input.getQualitativeSpecies())), Output = model.Nodes.FirstOrDefault(n => n.Id.Equals(output.getQualitativeSpecies())) }; model.Edges.Add(edge); } } } }
/// <summary> /// Enriches the target model with the appropriate drugs having a positive effect on the target phenotype /// </summary> /// <param name="model">The target model</param> /// <param name="targetPhenotypes">The target phenotypes</param> /// <param name="drugsList">The available drugs list</param> /// <param name="drugNodes">The drug nodes that have been added to the model</param> /// <param name="drugEdges">The drug edges that have been added to the model</param> public void AddDrugsToModel(BinaryModel model, List <TargetPhenotype> targetPhenotypes, List <DrugDescription> drugsList, out List <BinaryNode> drugNodes, out List <BinaryEdge> drugEdges) { var phenotypes = GetTargetPhenotypes(model, targetPhenotypes); // Get drugs nodes and edges for each model drugNodes = new List <BinaryNode>(); drugEdges = new List <BinaryEdge>(); foreach (var phenotype in phenotypes) { var clonedModel = model.Clone(); FindDrugs(clonedModel, phenotype.Key.Id, phenotype.Value, drugsList, out List <BinaryNode> intDrugNodes, out List <BinaryEdge> intDrugEdges); foreach (var drugNode in intDrugNodes) { if (!drugNodes.Any(n => n.Id.Equals(drugNode.Id))) { drugNodes.Add(drugNode); } } foreach (var drugEdge in intDrugEdges) { if (!drugEdges.Any(e => e.Input.Id.Equals(drugEdge.Input.Id) && e.Output.Id.Equals(drugEdge.Output.Id) && e.Type == drugEdge.Type)) { drugEdges.Add(drugEdge); } } } }
/// <summary> /// Converts the current binary model to an SBML 3.1 Qual document and writes it to a file. /// </summary> public void WriteToSbmlFile(BinaryModel model, string outputPath) { var outputSbmlDocument = ToSbmlQualDocument(model); var writer = new SBMLWriter(); writer.writeSBML(outputSbmlDocument, outputPath); }
/// <summary> /// Protects inputs and outputs /// </summary> /// <param name="model">The target model</param> public void ProtectInputsAndOutputs(BinaryModel model) { foreach (var binaryNode in model.Nodes) { if (binaryNode.IsInput() || binaryNode.IsOutput()) { binaryNode.Protected = true; } } }
/// <summary> /// Initializes and returns a new binary model based on an SBML file. /// </summary> /// <param name="filePath">The SBML file path</param> /// <returns>A new <see cref="BinaryModel" /> instance initialized from <paramref name="filePath" /></returns> public BinaryModel ReadFromSbmlFile(string filePath) { var reader = new SBMLReader(); var sbmlDoc = reader.readSBML(filePath); var sbmlModel = sbmlDoc.getModel(); Console.WriteLine("Initializing boolean model"); var binaryModel = new BinaryModel(); InitFromSbmlQualModel(binaryModel, sbmlModel); return(binaryModel); }
/// <summary> /// Populates the model nodes list based on the SBML Qual model content. /// </summary> /// <param name="model">The target binary model to populate</param> /// <param name="sbmlModel">The input SBML Qual model</param> private void PopulateNodes(BinaryModel model, Model sbmlModel) { var modelQualPlugin = (QualModelPlugin)sbmlModel.getPlugin("qual"); var numQualitativeSpecies = modelQualPlugin.getNumQualitativeSpecies(); for (var i = 0; i < numQualitativeSpecies; i++) { var qualitativeSpecies = modelQualPlugin.getQualitativeSpecies(i); var node = new BinaryNode(model, qualitativeSpecies.getId()) { Name = qualitativeSpecies.isSetName() ? qualitativeSpecies.getName() : string.Empty }; model.Nodes.Add(node); } }
/// <summary> /// Protects nodes based on a list. /// </summary> /// <param name="model">The target model</param> /// <param name="protectedNodes">The list of nodes to protect</param> /// <param name="drugsList">The list of drugs to protect</param> /// <param name="phenotypes">The list of phenotyeps to protect</param> public void ProtectNodes(BinaryModel model, List <string> protectedNodes, List <DrugDescription> drugsList, List <BinaryNode> phenotypes) { foreach (var binaryNode in model.Nodes) { if (protectedNodes.Contains(binaryNode.Id)) { binaryNode.Protected = true; } else if (drugsList.Any(d => d.TargetId.Equals(binaryNode.Id))) { binaryNode.Protected = true; } } foreach (var binaryNode in phenotypes) { binaryNode.Protected = true; } }
/// <summary> /// Converts the current binary model to an SBML 3.1 Qual document. /// </summary> /// <returns>A new SBML Qual document based on curent binary model</returns> public SBMLDocument ToSbmlQualDocument(BinaryModel model) { var sbmlns = new SBMLNamespaces(3, 1, "qual", 1); var document = new SBMLDocument(sbmlns); document.setPackageRequired("qual", true); var sbmlModel = document.createModel(); var qualModel = (QualModelPlugin)sbmlModel.getPlugin("qual"); var compartment = sbmlModel.createCompartment(); compartment.setConstant(false); compartment.setId("Default"); compartment.setName("Default"); foreach (var binaryNode in model.Nodes) { var qualitativeSpecies = qualModel.createQualitativeSpecies(); qualitativeSpecies.setConstant(false); qualitativeSpecies.setId(binaryNode.Id); qualitativeSpecies.setName(binaryNode.Name); qualitativeSpecies.setCompartment("Default"); } foreach (var binaryEdge in model.Edges) { var transition = qualModel.createTransition(); var input = transition.createInput(); input.setQualitativeSpecies(binaryEdge.Input.Id); input.setTransitionEffect(libsbml.INPUT_TRANSITION_EFFECT_NONE); input.setSign(binaryEdge.IsPositive() ? libsbml.INPUT_SIGN_POSITIVE : libsbml.INPUT_SIGN_NEGATIVE); var output = transition.createOutput(); output.setQualitativeSpecies(binaryEdge.Output.Id); output.setTransitionEffect(libsbml.OUTPUT_TRANSITION_EFFECT_PRODUCTION); output.setOutputLevel(1); var defaultTrem = transition.createDefaultTerm(); defaultTrem.setResultLevel(1); } return(document); }
/// <summary> /// In a target model, finds the drugs that could have the desired effect on the target node. /// </summary> /// <param name="model">The target model</param> /// <param name="nodeId">The Id of the target node</param> /// <param name="drugEffect">The desired effect</param> /// <param name="drugsList">The list of available drugs</param> /// <param name="drugNodes">The new nodes added for the drugs</param> /// <param name="drugsEdges">The new edges added for the drugs</param> public void FindDrugs(BinaryModel model, string nodeId, DrugEffect drugEffect, List <DrugDescription> drugsList, out List <BinaryNode> drugNodes, out List <BinaryEdge> drugsEdges) { drugNodes = new List <BinaryNode>(); drugsEdges = new List <BinaryEdge>(); var node = model.GetNode(nodeId); if (node.State != State.Unset) { return; } node.State = drugEffect == DrugEffect.Activation ? State.Active : State.Inactive; var targetDrug = drugsList.FirstOrDefault(d => d.TargetId.Equals(nodeId) && d.Effect == drugEffect); if (targetDrug != null) { var drugNode = new BinaryNode(model, targetDrug.Id); drugNode.State = State.Active; drugNodes.Add(drugNode); var drugEdge = new BinaryEdge(model, string.Concat(targetDrug.Id, node.Id), targetDrug.Effect == DrugEffect.Activation ? EdgeType.Positive : EdgeType.Negative); drugEdge.Input = drugNode; drugEdge.Output = node; drugsEdges.Add(drugEdge); } foreach (var edge in model.Edges.Where(e => e.Output == node)) { var modelClone = model.Clone(); var inputEffect = DrugEffect.Activation; switch (edge.Type) { case EdgeType.Positive: inputEffect = drugEffect; break; case EdgeType.Negative: inputEffect = drugEffect == DrugEffect.Activation ? DrugEffect.Inhibition : DrugEffect.Activation; break; } FindDrugs(modelClone, edge.Input.Id, inputEffect, drugsList, out var newDrugNodes, out var newDrugEdges); drugNodes.AddRange(newDrugNodes); drugsEdges.AddRange(newDrugEdges); } }
/// <summary> /// Adds new entities to the target model /// </summary> /// <param name="model">The target model</param> /// <param name="newNodes">The nodes to add</param> /// <param name="newEdges">The edges to add</param> /// <param name="protectNodes">If set to<c>true</c>, new nodes and nodes related to the added edges will be protected</param> public void AddEntitiesToModel(BinaryModel model, List <BinaryNode> newNodes, List <BinaryEdge> newEdges, bool protectNodes) { // Add them to the model without duplicates foreach (var drugNode in newNodes) { drugNode.Model = model; drugNode.Protected = protectNodes; } model.Nodes.AddRange(newNodes); foreach (var fullDrugEdge in newEdges) { var newEdge = new BinaryEdge(model, fullDrugEdge.Id, fullDrugEdge.Type) { Input = model.Nodes.First(n => n.Id.Equals(fullDrugEdge.Input.Id)), Output = model.Nodes.First(n => n.Id.Equals(fullDrugEdge.Output.Id)) }; newEdge.Input.Protected = protectNodes; newEdge.Output.Protected = protectNodes; model.Edges.Add(newEdge); } }
/// <summary> /// Simplifies the input model and extends it with drugs susceptible of having a posiive efect on the target phenotypes. /// </summary> /// <param name="model">The binary model to extend</param> /// <param name="protectedNodes">The nodes that should be protected</param> /// <param name="targetPhenotypes">The target phenotypes</param> public void SimplifyAndExtendModelWithDrugs(BinaryModel model, List <string> protectedNodes, List <TargetPhenotype> targetPhenotypes) { // Clone the model var modelClone = model.Clone(); // Set inputs and outputs as protected _networkSimplifier.ProtectInputsAndOutputs(modelClone); // Get available drugs list var drugsList = _drugDatabase.GetAvailableDrugs(); // Set protected nodes based on configuration _networkSimplifier.ProtectNodes(modelClone, protectedNodes, drugsList, new List <BinaryNode>()); // Remove all intermediary nodes int removedNodes; do { removedNodes = _networkSimplifier.CleanupNodes(modelClone); } while (removedNodes != 0); // Add drugs AddDrugsToModel(modelClone, targetPhenotypes, drugsList, out var drugNodes, out var drugEdges); // Add the nodes to the original model AddEntitiesToModel(model, drugNodes, drugEdges, true); // Protect other nodes if nescessary // More than nodes impacted by drugs and mandatory nodes, protect target phenotypes nodes _networkSimplifier.ProtectNodes(model, protectedNodes, new List <DrugDescription>(), GetTargetPhenotypes(model, targetPhenotypes).Keys.ToList()); // Remove all unnescesary nodes do { removedNodes = _networkSimplifier.CleanupNodes(model); } while (removedNodes != 0); }
/// <summary> /// Checks if a model already contains an edge with the same input and output but a different type /// </summary> /// <param name="model">The target model</param> /// <param name="input">The input node</param> /// <param name="output">The output node</param> /// <param name="type">The edge type</param> /// <returns><c>true</c> if the model already contains the oposite edge, <c>false</c> otherwise</returns> private bool HasOpositeEdge(BinaryModel model, BinaryNode input, BinaryNode output, EdgeType type) { return(model.Edges.Any(e => e.Input == input && e.Output == output && e.Type != type)); }
/// <summary> /// Removes non protected nodes with only one input and one output and merges the appropriate edges. /// Loop nodes and nodes with no input and/or output are also removed. /// </summary> /// <param name="model">The binary model</param> /// <returns>The number of nodes removed</returns> public int CleanupNodes(BinaryModel model) { int entitiesRemoved = 0; var nodes = model.Nodes.ToList(); foreach (var node in nodes) { if (node.Protected) { continue; } var canRemoveNode = true; var edges = model.Edges.ToList(); var inputs = edges.Where(e => e.Output == node).ToList(); var outputs = edges.Where(e => e.Input == node).ToList(); // If a node has no imput nor output or is a loop, remove it if (inputs.Count == 0 || outputs.Count == 0) { model.Nodes.Remove(node); model.Edges.RemoveAll(e => inputs.Contains(e) || outputs.Contains(e)); entitiesRemoved++; } // Remove self regulations model.Edges.RemoveAll(e => e.Input == e.Output); var outputsToKeep = new List <BinaryEdge>(); var inputsToKeep = new List <BinaryEdge>(); var newEdgesToAdd = new List <BinaryEdge>(); foreach (var inputEdge in inputs) { foreach (var outputEdge in outputs) { var newEdge = new BinaryEdge(model, string.Concat(inputEdge.Id, outputEdge.Id), GetMergedEdgeType(inputEdge, outputEdge)) { Input = inputEdge.Input, Output = outputEdge.Output }; if (HasOpositeEdge(model, newEdge.Input, newEdge.Output, newEdge.Type)) { canRemoveNode = false; inputsToKeep.Add(inputEdge); outputsToKeep.Add(outputEdge); continue; } if (newEdge.Input != newEdge.Output && !HasSameEdge(model, newEdge.Input, newEdge.Output, newEdge.Type)) { newEdgesToAdd.Add(newEdge); } } } // Compute edges to remove var edgesToRemove = (model.Edges.Where(e => e.Input == node && !outputsToKeep.Contains(e) || e.Output == node && !inputsToKeep.Contains(e))).ToList(); // Compare edges to add count with edges to remove var delta = newEdgesToAdd.Count - edgesToRemove.Count; if (delta <= 0) { entitiesRemoved += model.Edges.RemoveAll(e => edgesToRemove.Contains(e)); model.Edges.AddRange(newEdgesToAdd); if (!canRemoveNode) { continue; } model.Nodes.Remove(node); entitiesRemoved++; } } return(entitiesRemoved); }
/// <summary> /// Creates a new binary model based onan SBML Qual model. /// </summary> public void InitFromSbmlQualModel(BinaryModel model, Model sbmlModel) { PopulateNodes(model, sbmlModel); PopulateEdges(model, sbmlModel); }
/// <summary> /// Returns the desired phenotype nodes from a target model /// </summary> /// <param name="model">The target model</param> /// <param name="targetPhenotypes">The desired phenotypes</param> /// <returns></returns> private Dictionary <BinaryNode, DrugEffect> GetTargetPhenotypes(BinaryModel model, List <TargetPhenotype> targetPhenotypes) { // Store phenotypes and target action return(targetPhenotypes.ToDictionary(targetPhenotype => model.Nodes.First(n => n.Id.Equals(targetPhenotype.PhenotypeId)), targetPhenotype => targetPhenotype.Effect)); }