public void TestMotifPattern_Motif () { BiopatMLFilePath = "BioPaperTestData/MotifPattern/Motif.xml"; using ( BioPatMBF_Reader gbReader = new BioPatMBF_Reader() ) { BioList = gbReader.Read( Global.GetResourceReader( _singleDnaSeqGenBankFilename ) ); } MyPatterns = DefinitionIO.Read( Global.GetResourceReader( BiopatMLFilePath ) ); FeatureList Matches = BioList[0].Search( SearchPosition, BioList[0].Length, MyPatterns.Pattern ); //According to Jacobi library total matches should be 57 Assert.AreEqual( 57, Matches.Count ); Assert.AreEqual( "Pribnow-box", Matches.Name ); //Perform some random checks from the 57 list Match matched = (Match) Matches[10]; //try get the 11th matched Assert.AreEqual( 0.66, matched.Similarity, 1e-2 ); Assert.AreEqual( 6, matched.Length ); Assert.AreEqual( "ttttat", matched.Letters() ); //try the first match matched = (Match) Matches[0]; Assert.AreEqual( AlphabetFactory.Instance( AlphabetType.DNA ), matched.Alphabet ); Assert.AreEqual( 6, matched.Length ); Assert.AreEqual( 0.5, matched.Similarity, 1e-2 ); // Check the last match matched = (Match) Matches[56]; Assert.AreEqual( 0.5, matched.Similarity, 1e-2 ); Assert.AreEqual( "tttctt", matched.Letters() ); }
public void TestStructuredPattern_SeriesAll() { BiopatMLFilePath = "BioPaperTestData/StructuredPattern/SeriesAll.xml"; using (BioPatMBF_Reader gbReader = new BioPatMBF_Reader()) { BioList = gbReader.Read( Global.GetResourceReader( _singleDnaSeqGenBankFilename ) ); } MyPatterns = DefinitionIO.Read( Global.GetResourceReader( BiopatMLFilePath ) ); FeatureList Matches = BioList[0].Search( SearchPosition, BioList[0].Length, MyPatterns.Pattern ); //expecting 49 matches based on the old jacobi result Assert.AreEqual(49, Matches.Count); Match matched = (Match)Matches[0]; //Query the 1st matched from the list of matches Assert.AreEqual(3, matched.SubMatches.Count); //should have 3 sub matches Assert.AreEqual("aattt", matched.SubMatches[0].Letters()); Assert.AreEqual("tataagtg", matched.SubMatches[1].Letters()); Assert.AreEqual("ttcaa", matched.SubMatches[2].Letters()); //And finally the main matched Assert.AreEqual("aattttataagtgttcaa", matched.Letters()); }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <param name="node">Any Pattern node</param> /// <param name="definition">The container encapsulating this pattern</param> public override void ReadNode (XmlNode node, Definition definition) { base.ReadNode(node, definition); Impact = XMLHelper.GetAttrValDouble(node, "impact"); }
public void SetUp() { this.BiopatMLFilePath = string.Empty; this.BioList = null; this.MyPatterns = null; SearchPosition = 1; }
public void TestConstructor() { Definition definition = new Definition("test", new VoidPattern("VoidPattern")); Assert.AreEqual("test", definition.Name); Assert.AreEqual("VoidPattern", definition.Pattern.Name); Assert.IsNotNull(definition.Pattern); Assert.IsNotNull(definition.Definitions); }
public void TestConstructor () { Definition container = new Definition(); container.Definitions.Add( new Definition( "Def", new Any( "Any", 1, 3, 1 ) ) ); Use use = new Use { Name = "Use" }; use.ReferTo( container, "Def" ); Assert.AreEqual( "Use", use.Name ); Assert.AreEqual( "Def", use.ReferencedDefinition.Name ); }
/// <summary> /// Adds a definition to the list. The name of the definition must be unique. /// No two definitions with the same name can be stored in the list. /// </summary> /// <exception cref="System.ArgumentException">thrown when name already exist</exception> /// <param name="definition">Definition to add.</param> public void Add(Definition definition) { String name = definition.DefinitionName; if (NamesDictionary.ContainsKey(name)) throw new ArgumentException("Duplicate definition name: " + name); NamesDictionary.Add(name, definition); }
/// <summary> /// Process the processed BioPatML XML file and returns /// a Definition containning a list of search patterns /// </summary> /// <param name="doc">Loads in a premade document</param> /// <returns>A definition containning a collection of sub patterns, if exist.</returns> public static Definition Read ( XDocument doc ) { if ( doc.Root.Name != "BioPatML" ) { throw new ArgumentException( "Top level node should be 'BioPatML'" ); } Definition result = new Definition(); result.Parse( doc.Root.Element( "Definition" ) ); return result; }
/// <summary> Saves a definition as an xml document. </summary> /// <param name="definition"></param> /// <returns></returns> public static XDocument Write ( Definition definition ) { XDocument result = XDocument.Parse( @"<BioPatML xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='BioPatML.xsd' />" ); result.Root.Add( definition.ToXml() ); return result; }
public void TestSubDefinition() { DefinitionList definitions = new DefinitionList(); Definition definition = new Definition("test1", new VoidPattern("VoidPattern1")); definition.Definitions.Add(new Definition("test11", new VoidPattern("VoidPattern11"))); definitions.Add(definition); definitions.Add(new Definition("test2", new VoidPattern("VoidPattern2"))); definitions.Add(new Definition("test3", new VoidPattern("VoidPattern3"))); Assert.AreEqual("VoidPattern1", definitions.definition("test1").Pattern.Name); Assert.AreEqual("VoidPattern11", definitions.definition("test1.test11").Pattern.Name); Assert.AreEqual("VoidPattern2", definitions.definition("test2").Pattern.Name); Assert.AreEqual("VoidPattern3", definitions.definition("test3").Pattern.Name); Assert.AreEqual(null, definitions.definition("test4")); }
public void TestDefinition() { DefinitionList definitions = new DefinitionList(); Definition definition = new Definition("test1"); definition.Definitions.Add(new Definition("test11")); definitions.Add(definition); definitions.Add(new Definition("test2")); definitions.Add(new Definition("test3")); Assert.AreEqual("test1", definitions.definition("test1").Name); Assert.AreEqual("test11", definitions.definition("test1.test11").Name); Assert.AreEqual("test2", definitions.definition("test2").Name); Assert.AreEqual("test3", definitions.definition("test3").Name); Assert.AreEqual(null, definitions.definition("test4")); }
public void TestMatch () { Definition def = new Definition(); def.Definitions.Add( new Definition("Def", new Motif("Motif", AlphabetType.DNA, "atg", 0.0)) ); Sequence seq = new Sequence(AlphabetType.DNA, "atgc"); Use use = new Use{ Name = "Use" }; use.ReferTo( def, "Def" ); Match match = use.Match(seq, 1); Assert.AreEqual(use, match.MatchPattern); Assert.AreEqual(1, match.Start); Assert.AreEqual(3, match.Length); Assert.AreEqual(1, match.Strand); Assert.AreEqual(1.0, match.Similarity, 1e-2); }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <param name="node">Series Pattern node</param> /// <param name="definition">The container encapsulating this pattern</param> public override void ReadNode(XmlNode node, Definition definition) { PatternName = XMLHelper.GetAttrValueString(node, "name"); Threshold = XMLHelper.GetAttrValDouble(node, "threshold"); Impact = XMLHelper.GetAttrValDouble(node, "impact"); node = node.FirstChild; while (node != null) { if (node.NodeType == XmlNodeType.Element) Add(PatternComplex.ReadPattern(node, definition)); node = node.NextSibling; } }
public void TestRegionalPattern_Gap () { BiopatMLFilePath = "BioPaperTestData/RegionalPattern/RegionalGap.xml"; BioPatMBF_Reader gbReader = new BioPatMBF_Reader(); BioList = gbReader.Read( Global.GetResourceReader( _singleProteinSeqGenBankFilename ) ); MyPatterns = DefinitionIO.Read( Global.GetResourceReader( BiopatMLFilePath ) ); FeatureList Matches = BioList[0].Search( SearchPosition, BioList[0].Length, MyPatterns.Pattern ); //Total matches according to old jacobi is 309 Assert.AreEqual( 410, Matches.Count ); //Checks the first match Assert.AreEqual( "MT", Matches[0].MainSequence.Letters( Matches[0].Start, Matches[0].End ) ); //Checks if the last Match is in correect start and end pos Assert.AreEqual( "CE", Matches[409].MainSequence.Letters( Matches[409].Start, Matches[409].End ) ); }
public void TestPattern() { Series series1 = new SeriesBest("Series1", 1.0); series1.Add(new VoidPattern("VoidPattern1")); series1.Add(new VoidPattern("VoidPattern2")); Series series2 = new SeriesBest("Series2", 1.0); series2.Add(new VoidPattern("VoidPattern21")); series2.Add(series1); Definition definition = new Definition("test"); definition.Pattern = (series2); Assert.AreEqual("Series2", definition.Pattern.Name); Assert.AreEqual("VoidPattern21", definition.Patterns[1].Name); Assert.AreEqual("Series1", definition.Patterns[2].Name); Assert.AreEqual("VoidPattern1", definition.Patterns[3].Name); Assert.AreEqual("VoidPattern2", definition.Patterns[4].Name); }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <param name="definition">Definition wrapping this node element</param> /// <param name="node">The node with name Void</param> public override void ReadNode(XmlNode node, Definition definition) { PatternName = XMLHelper.GetAttrValueString(node, "name"); Impact = XMLHelper.GetAttrValDouble(node, "impact"); }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// /// Hides the ReadNode method for PatternComplex /// </summary> /// <param name="node">Profile Pattern node</param> /// <param name="definition">The container encapsulating this pattern</param> public new void ReadNode(XmlNode node, Definition definition) { Dictionary<String, ProfileElement> map = new Dictionary<string, ProfileElement>(); PatternName = XMLHelper.GetAttrValueString(node, "name"); Threshold = XMLHelper.GetAttrValDouble(node, "threshold"); Impact = XMLHelper.GetAttrValDouble(node, "impact"); node = node.FirstChild; while (node != null) { if (node.Name.Equals("Region")) { String name = XMLHelper.GetAttrValueString(node, "name"); String reference = XMLHelper.GetAttrValueString(node, "reference"); int minGap = XMLHelper.GetAttrValInt(node, "minGap"); int maxGap = XMLHelper.GetAttrValInt(node, "maxGap"); String align = XMLHelper.GetAttrValueString(node, "alignment"); //Has confusing method Pattern IPattern pattern = QUT.Bio.BioPatML.Patterns.Pattern.ReadPattern (node.FirstChild, definition); ProfileElement refElement = null; if (reference != null) { refElement = map[reference]; if (refElement == null) throw new ArgumentException ("Unknown reference : " + reference); } refElement = Add(refElement, StringToAlignment(align), minGap, maxGap, pattern); map.Add(name, refElement); } node = node.NextSibling; } }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <param name="node">Motif Pattern node</param> /// <param name="definition">The container encapsulating this pattern</param> public override void ReadNode(XmlNode node, Definition definition) { PatternName = XMLHelper.GetAttrValueString(node, "name"); Parse(XMLHelper.GetAttrValueString(node, "alphabet"), XMLHelper.GetAttrValueString(node, "motif")); Threshold = XMLHelper.GetAttrValDouble(node, "threshold"); Impact = XMLHelper.GetAttrValDouble(node, "impact"); }
/// <summary> /// Implementation of the pattern interface. /// <see cref="QUT.Bio.BioPatML.Patterns.IPattern">IPattern ReadNode(Node)</see> /// </summary> /// <param name="node">The Set[ALL/Best] Element</param> /// <param name="definition"></param> public override void ReadNode(XmlNode node, Definition definition) { PatternName = (XMLHelper.GetAttrValueString(node, "name")); Threshold = (XMLHelper.GetAttrValDouble(node, "threshold")); Impact = (XMLHelper.GetAttrValDouble(node, "impact")); Set(definition.Patterns[XMLHelper.GetAttrValueString(node, "pattern")], XMLHelper.GetAttrValueString(node, "mode")); node = node.FirstChild; while (node != null) { if (node.Name.Equals("Pairing")) { char original = XMLHelper.GetAttrValueString(node, "original")[0]; char repeat = XMLHelper.GetAttrValueString(node, "repeat")[0]; double weight = XMLHelper.GetAttrValDouble(node, "weight"); Weight(original, repeat, weight); } node = node.NextSibling; } }
/// <summary> /// Reads a list of definitions at the specified node. /// This method recursivly calls the reading methods of the different definitions. /// </summary> /// <param name="node">Node of the XML the reading starts with.</param> /// <param name="def">Definition which definition list will be extend with /// all read definitions.</param> public static void ReadNode(XmlNode node, Definition def) { node = node.FirstChild; while (node != null) { if (node.Name.Equals("Definition")) def.Definitions.Add(Definition.ReadNode(node)); else if (node.Name.Equals("Import")) def.Definitions.Add(XMLHelper.GetAttrValueString(node, "uri")); node = node.NextSibling; } }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <param name="node">Any Pattern node</param> /// <param name="definition">The container encapsulating this pattern</param> public override void ReadNode(XmlNode node, Definition definition) { PatternName = XMLHelper.GetAttrValueString(node, "name"); Threshold = XMLHelper.GetAttrValDouble(node, "threshold"); Impact = XMLHelper.GetAttrValDouble(node, "impact"); Set(PatternComplex.ReadPattern(node.FirstChild, definition), XMLHelper.GetAttrValInt(node, "minimum"), XMLHelper.GetAttrValInt(node, "maximum")); }
/// <summary> /// Implementation of the pattern interface. /// Reads in the Gap node and populate the attributes accordingly. /// <see cref="QUT.Bio.BioPatML.Patterns.IPattern">IPattern</see> /// </summary> /// <param name="node"></param> /// <param name="definition"></param> public override void ReadNode(XmlNode node, Definition definition) { base.ReadNode(node, definition); Threshold = XMLHelper.GetAttrValDouble(node, "threshold"); Impact = XMLHelper.GetAttrValDouble(node, "impact"); String weightstr = XMLHelper.GetTextContent(node, "Weights"); Weights = (weightstr == null ? null : PrimitiveParse.StringToDoubleArray(weightstr)); }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <exception cref="System.ArgumentNullException"> /// Thrown when sequences in blocks are missing.</exception> /// <param name="node"></param> /// <param name="definition">The Definition element where the node sits in</param> public override void ReadNode (XmlNode node, Definition definition) { PatternName = (XMLHelper.GetAttrValueString(node, "name")); Threshold = (XMLHelper.GetAttrValDouble(node, "threshold")); Impact = (XMLHelper.GetAttrValDouble(node, "impact")); PWMalphabet = AlphabetFactory.Instance (XMLHelper.GetAttrValueString(node, "alphabet")); SequenceList seqList = new SequenceList(); node = node.FirstChild; while (node != null) { if (node.Name.Equals("Sequence")) { String letters = node.InnerText.Trim(); if (letters == null) throw new ArgumentNullException ("Sequences in Block are missing!"); seqList.Add(new Sequence(PWMalphabet, letters, false)); } node = node.NextSibling; } Estimate(seqList, null); }
/// <summary> /// A static method for reading the definition of a pattern. /// </summary> /// <param name="node">The definition node with the starting tag of Definition</param> /// <returns></returns> public static Definition ReadNode(XmlNode node) { Definition definition = new Definition(XMLHelper.GetAttrValueString(node, "name")); node = node.FirstChild; while (node != null) { if (node.Name.Equals("Annotations")) { /*AnnotationList.read(node, definition);*/} else if (node.Name.Equals("Parameters")) { /*ParameterList.read(node, definition);*/} else if (node.Name.Equals("Definitions")) DefinitionList.ReadNode(node, definition); else if (node.NodeType == XmlNodeType.Element) Pattern.ReadPattern(node, definition); node = node.NextSibling; } return definition; }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <param name="node">Any Pattern node that extends pattern flexible </param> /// <param name="definition">The container encapsulating this pattern</param> public override void ReadNode(XmlNode node, Definition definition) { PatternName = (XMLHelper.GetAttrValueString(node, "name")); Set(XMLHelper.GetAttrValInt (node, "minimum"), XMLHelper.GetAttrValInt (node, "maximum"), XMLHelper.GetAttrValDouble(node, "increment")); }
/// <summary> /// Reads the parameters for a pattern at the given node. /// </summary> /// <param name="node">The Alignment pattern node</param> /// <param name="definition">Definition encapsulating the pattern</param> public override void ReadNode(System.Xml.XmlNode node, Definition definition) { PatternName = (XMLHelper.GetAttrValueString(node, "name")); Impact = (XMLHelper.GetAttrValDouble(node, "impact")); Set(definition.Patterns[XMLHelper.GetAttrValueString(node, "pattern")], XMLHelper.GetAttrValueString(node, "position"), XMLHelper.GetAttrValInt(node, "offset")); }
/// <summary> /// /// </summary> /// <param name="node"></param> /// <param name="definition"></param> public virtual void ReadNode(XmlNode node, Definition definition) { throw new NotImplementedException(); }
public void TestRegionalPattern_Composition () { BiopatMLFilePath = "BioPaperTestData/RegionalPattern/RegionalComposition.xml"; using ( BioPatMBF_Reader gbReader = new BioPatMBF_Reader() ) { BioList = gbReader.Read( Global.GetResourceReader( _singleProteinSeqGenBankFilename ) ); } MyPatterns = DefinitionIO.Read( Global.GetResourceReader( BiopatMLFilePath ) ); FeatureList Matches = BioList[0].Search( SearchPosition, BioList[0].Length, MyPatterns.Pattern ); //Total matches according to old jacobi is 309 Assert.AreEqual( 49, Matches.Count ); //Checks the first match Assert.AreEqual( "GATLFKTRCLQCHTV", Matches[0].MainSequence.Letters( Matches[0].Start, Matches[0].End ) ); //Check see if the pattern used to match has the correct name for its matches Assert.AreEqual( "transmembrane domain", Matches.Name ); Assert.AreEqual( 12, Matches[0].Start ); Assert.AreEqual( 26, Matches[0].End ); //Checks if the last Match is in correect start and end pos Assert.AreEqual( "KDRNDLITYLKKACE", Matches[48].MainSequence.Letters( Matches[48].Start, Matches[48].End ) ); }
/// <summary> /// Reads the parameters and populate the attributes for this pattern. /// </summary> /// <param name="node">Constraint Pattern node</param> /// <param name="definition">The container encapsulating this pattern</param> public override void ReadNode(XmlNode node, Definition definition) { PatternName = (XMLHelper.GetAttrValueString(node, "name")); Impact = (XMLHelper.GetAttrValDouble(node, "impact")); Position = (XMLHelper.GetAttrValueString(node, "position")); Offset = (XMLHelper.GetAttrValInt(node, "offset")); }
/// <summary> /// /// Reads a pattern from a starting specified node. This method /// recursivly calls the reading methods of the different patterns. /// </summary> /// <param name="node">Node of the pattern the reading starts with.</param> /// <param name="definition">Pattern definition which pattern list will be extended /// with the pattern and all its sub-patterns read. /// </param> /// <returns>The read pattern or null if there is no pattern to read.</returns> /// <exception cref="System.SystemException">Thrown when unknown pattern was found</exception> public static IPattern ReadPattern (XmlNode node, Definition definition) { while (node != null && node.NodeType != XmlNodeType.Element) node = node.NextSibling; //Iterate thru the list of nodes until it is an element IPattern pattern = null; String mode = XMLHelper.GetAttrValueString(node, "mode"); switch (node.Name) { case "Any": pattern = new Any(); break; case "Alignment": pattern = new Alignment(); break; case "Composition" : pattern = new Composition(); break; case "Constraint": pattern = new Constraint(); break; case "Iteration": pattern = new Iteration(); break; case "Logic": pattern = new Logic(); break; case "Motif": pattern = new Motif(); break; case "PWM": pattern = new PWM(); break; case "Regex": pattern = new RegularExp(); break; case "Prosite": pattern = new Prosite(); break; case "Block": pattern = new Block(); break; case "Gap": pattern = new Gap(); break; case "Repeat": pattern = new Repeat(); break; case "Series": pattern = mode.Equals("ALL") ? pattern = new SeriesAll() : pattern = new SeriesBest(); break; case "Set": pattern = mode.Equals("ALL") ? pattern = new SetAll() : pattern = new SetBest(); break; case "Void": pattern = new VoidPattern(); break; case "Use": pattern = new Use(); break; throw new SystemException ("Unknown pattern found: " + node.Name); } pattern.ReadNode(node, definition); // read the node data and initialize the pattern definition.Patterns.Add (0, pattern); //Always adding the element to last index return pattern; }