X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=forester%2Fjava%2Fsrc%2Forg%2Fforester%2Fphylogeny%2FPhylogenyMethods.java;h=c3fbc95cb6b32731f0ee22c3525775f5cf7a21a9;hb=5cad5dbd4f9e8cf09a123d4ee490cf314c05fd2f;hp=eba76de7f21119a4dde3ed682c8bdd70f8467a45;hpb=9e1353590a88991e7593d38c8e307f713a0f3d5b;p=jalview.git

diff --git a/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java b/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java
index eba76de..c3fbc95 100644
--- a/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java
+++ b/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java
@@ -40,12 +40,14 @@ import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
 
 import org.forester.io.parsers.FastaParser;
 import org.forester.io.parsers.PhylogenyParser;
 import org.forester.io.parsers.phyloxml.PhyloXmlDataFormatException;
 import org.forester.io.parsers.phyloxml.PhyloXmlUtil;
 import org.forester.io.parsers.util.PhylogenyParserException;
+import org.forester.msa.Msa;
 import org.forester.phylogeny.data.Accession;
 import org.forester.phylogeny.data.Annotation;
 import org.forester.phylogeny.data.BranchColor;
@@ -105,7 +107,7 @@ public class PhylogenyMethods {
         return could_extract;
     }
 
-    public static DescriptiveStatistics calculatBranchLengthStatistics( final Phylogeny phy ) {
+    public static DescriptiveStatistics calculateBranchLengthStatistics( final Phylogeny phy ) {
         final DescriptiveStatistics stats = new BasicDescriptiveStatistics();
         for( final PhylogenyNodeIterator iter = phy.iteratorPreorder(); iter.hasNext(); ) {
             final PhylogenyNode n = iter.next();
@@ -116,7 +118,7 @@ public class PhylogenyMethods {
         return stats;
     }
 
-    public static List<DescriptiveStatistics> calculatConfidenceStatistics( final Phylogeny phy ) {
+    public static List<DescriptiveStatistics> calculateConfidenceStatistics( final Phylogeny phy ) {
         final List<DescriptiveStatistics> stats = new ArrayList<DescriptiveStatistics>();
         for( final PhylogenyNodeIterator iter = phy.iteratorPreorder(); iter.hasNext(); ) {
             final PhylogenyNode n = iter.next();
@@ -146,8 +148,8 @@ public class PhylogenyMethods {
 
     /**
      * Calculates the distance between PhylogenyNodes node1 and node2.
-     * 
-     * 
+     *
+     *
      * @param node1
      * @param node2
      * @return distance between node1 and node2
@@ -161,8 +163,8 @@ public class PhylogenyMethods {
 
     /**
      * Returns the LCA of PhylogenyNodes node1 and node2.
-     * 
-     * 
+     *
+     *
      * @param node1
      * @param node2
      * @return LCA of node1 and node2
@@ -207,8 +209,8 @@ public class PhylogenyMethods {
     /**
      * Returns the LCA of PhylogenyNodes node1 and node2.
      * Precondition: ids are in pre-order (or level-order).
-     * 
-     * 
+     *
+     *
      * @param node1
      * @param node2
      * @return LCA of node1 and node2
@@ -277,7 +279,7 @@ public class PhylogenyMethods {
         }
         return max;
     }
-    
+
     public static PhylogenyNode calculateNodeWithMaxDistanceToRoot( final Phylogeny phy ) {
         double max = 0.0;
         PhylogenyNode max_node = phy.getFirstExternalNode();
@@ -303,7 +305,7 @@ public class PhylogenyMethods {
         return x;
     }
 
-    public static DescriptiveStatistics calculatNumberOfDescendantsPerNodeStatistics( final Phylogeny phy ) {
+    public static DescriptiveStatistics calculateNumberOfDescendantsPerNodeStatistics( final Phylogeny phy ) {
         final DescriptiveStatistics stats = new BasicDescriptiveStatistics();
         for( final PhylogenyNodeIterator iter = phy.iteratorPreorder(); iter.hasNext(); ) {
             final PhylogenyNode n = iter.next();
@@ -498,9 +500,9 @@ public class PhylogenyMethods {
     }
 
     /**
-     * 
+     *
      * Convenience method
-     * 
+     *
      * @param node
      * @return
      */
@@ -551,9 +553,9 @@ public class PhylogenyMethods {
     }
 
     /**
-     * Returns taxonomy t if all external descendants have 
+     * Returns taxonomy t if all external descendants have
      * the same taxonomy t, null otherwise.
-     * 
+     *
      */
     public static Taxonomy getExternalDescendantsTaxonomy( final PhylogenyNode node ) {
         final List<PhylogenyNode> descs = node.getAllExternalDescendants();
@@ -681,7 +683,7 @@ public class PhylogenyMethods {
 
     /*
      * This is case insensitive.
-     * 
+     *
      */
     public synchronized static boolean isTaxonomyHasIdentifierOfGivenProvider( final Taxonomy tax,
                                                                                final String[] providers ) {
@@ -775,7 +777,7 @@ public class PhylogenyMethods {
      * all external nodes of node.
      * If at least one of the external nodes has no taxonomy,
      * null is returned.
-     * 
+     *
      */
     public static Map<Taxonomy, Integer> obtainDistinctTaxonomyCounts( final PhylogenyNode node ) {
         final List<PhylogenyNode> descs = node.getAllExternalDescendants();
@@ -799,10 +801,10 @@ public class PhylogenyMethods {
      * Arranges the order of childern for each node of this Phylogeny in such a
      * way that either the branch with more children is on top (right) or on
      * bottom (left), dependent on the value of boolean order.
-     * 
+     *
      * @param order
      *            decides in which direction to order
-     * @param pri 
+     * @param pri
      */
     public static void orderAppearance( final PhylogenyNode n,
                                         final boolean order,
@@ -934,11 +936,46 @@ public class PhylogenyMethods {
         }
     }
 
+    private static enum NDF {
+        NodeName( "NN" ),
+        TaxonomyCode( "TC" ),
+        TaxonomyCommonName( "CN" ),
+        TaxonomyScientificName( "TS" ),
+        TaxonomyIdentifier( "TI" ),
+        TaxonomySynonym( "SY" ),
+        SequenceName( "SN" ),
+        GeneName( "GN" ),
+        SequenceSymbol( "SS" ),
+        SequenceAccession( "SA" ),
+        Domain( "DO" ),
+        Annotation( "AN" ),
+        CrossRef( "XR" ),
+        BinaryCharacter( "BC" ),
+        MolecularSequence( "MS" );
+
+        private final String _text;
+
+        NDF( final String text ) {
+            _text = text;
+        }
+
+        public static NDF fromString( final String text ) {
+            for( final NDF n : NDF.values() ) {
+                if ( text.startsWith( n._text ) ) {
+                    return n;
+                }
+            }
+            return null;
+        }
+    }
+
     public static List<PhylogenyNode> searchData( final String query,
                                                   final Phylogeny phy,
                                                   final boolean case_sensitive,
                                                   final boolean partial,
-                                                  final boolean search_domains ) {
+                                                  final boolean regex,
+                                                  final boolean search_domains,
+                                                  final double domains_confidence_threshold ) {
         final List<PhylogenyNode> nodes = new ArrayList<PhylogenyNode>();
         if ( phy.isEmpty() || ( query == null ) ) {
             return nodes;
@@ -946,120 +983,160 @@ public class PhylogenyMethods {
         if ( ForesterUtil.isEmpty( query ) ) {
             return nodes;
         }
+        String my_query = query;
+        NDF ndf = null;
+        if ( ( my_query.length() > 2 ) && ( my_query.indexOf( ":" ) == 2 ) ) {
+            ndf = NDF.fromString( my_query );
+            if ( ndf != null ) {
+                my_query = my_query.substring( 3 );
+            }
+        }
         for( final PhylogenyNodeIterator iter = phy.iteratorPreorder(); iter.hasNext(); ) {
             final PhylogenyNode node = iter.next();
             boolean match = false;
-            if ( match( node.getName(), query, case_sensitive, partial ) ) {
+            if ( ( ( ndf == null ) || ( ndf == NDF.NodeName ) )
+                    && match( node.getName(), my_query, case_sensitive, partial, regex ) ) {
                 match = true;
             }
-            else if ( node.getNodeData().isHasTaxonomy()
-                    && match( node.getNodeData().getTaxonomy().getTaxonomyCode(), query, case_sensitive, partial ) ) {
+            else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyCode ) )
+                    && node.getNodeData().isHasTaxonomy()
+                    && match( node.getNodeData().getTaxonomy().getTaxonomyCode(),
+                              my_query,
+                              case_sensitive,
+                              partial,
+                              regex ) ) {
                 match = true;
             }
-            else if ( node.getNodeData().isHasTaxonomy()
-                    && match( node.getNodeData().getTaxonomy().getCommonName(), query, case_sensitive, partial ) ) {
+            else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyCommonName ) )
+                    && node.getNodeData().isHasTaxonomy()
+                    && match( node.getNodeData().getTaxonomy().getCommonName(),
+                              my_query,
+                              case_sensitive,
+                              partial,
+                              regex ) ) {
                 match = true;
             }
-            else if ( node.getNodeData().isHasTaxonomy()
-                    && match( node.getNodeData().getTaxonomy().getScientificName(), query, case_sensitive, partial ) ) {
+            else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyScientificName ) )
+                    && node.getNodeData().isHasTaxonomy()
+                    && match( node.getNodeData().getTaxonomy().getScientificName(),
+                              my_query,
+                              case_sensitive,
+                              partial,
+                              regex ) ) {
                 match = true;
             }
-            else if ( node.getNodeData().isHasTaxonomy()
+            else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyIdentifier ) )
+                    && node.getNodeData().isHasTaxonomy()
                     && ( node.getNodeData().getTaxonomy().getIdentifier() != null )
                     && match( node.getNodeData().getTaxonomy().getIdentifier().getValue(),
-                              query,
+                              my_query,
                               case_sensitive,
-                              partial ) ) {
+                              partial,
+                              regex ) ) {
                 match = true;
             }
-            else if ( node.getNodeData().isHasTaxonomy() && !node.getNodeData().getTaxonomy().getSynonyms().isEmpty() ) {
+            else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomySynonym ) ) && node.getNodeData().isHasTaxonomy()
+                    && !node.getNodeData().getTaxonomy().getSynonyms().isEmpty() ) {
                 final List<String> syns = node.getNodeData().getTaxonomy().getSynonyms();
                 I: for( final String syn : syns ) {
-                    if ( match( syn, query, case_sensitive, partial ) ) {
+                    if ( match( syn, my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break I;
                     }
                 }
             }
-            if ( !match && node.getNodeData().isHasSequence()
-                    && match( node.getNodeData().getSequence().getName(), query, case_sensitive, partial ) ) {
+            if ( !match && ( ( ndf == null ) || ( ndf == NDF.SequenceName ) ) && node.getNodeData().isHasSequence()
+                    && match( node.getNodeData().getSequence().getName(), my_query, case_sensitive, partial, regex ) ) {
                 match = true;
             }
-            if ( !match && node.getNodeData().isHasSequence()
-                    && match( node.getNodeData().getSequence().getGeneName(), query, case_sensitive, partial ) ) {
+            if ( !match && ( ( ndf == null ) || ( ndf == NDF.GeneName ) ) && node.getNodeData().isHasSequence()
+                    && match( node.getNodeData().getSequence().getGeneName(), my_query, case_sensitive, partial, regex ) ) {
                 match = true;
             }
-            if ( !match && node.getNodeData().isHasSequence()
-                    && match( node.getNodeData().getSequence().getSymbol(), query, case_sensitive, partial ) ) {
+            if ( !match && ( ( ndf == null ) || ( ndf == NDF.SequenceSymbol ) ) && node.getNodeData().isHasSequence()
+                    && match( node.getNodeData().getSequence().getSymbol(), my_query, case_sensitive, partial, regex ) ) {
                 match = true;
             }
             if ( !match
+                    && ( ( ndf == null ) || ( ndf == NDF.SequenceAccession ) )
                     && node.getNodeData().isHasSequence()
                     && ( node.getNodeData().getSequence().getAccession() != null )
                     && match( node.getNodeData().getSequence().getAccession().getValue(),
-                              query,
+                              my_query,
                               case_sensitive,
-                              partial ) ) {
+                              partial,
+                              regex ) ) {
                 match = true;
             }
-            if ( search_domains && !match && node.getNodeData().isHasSequence()
+            if ( !match && ( ( ( ndf == null ) && search_domains ) || ( ndf == NDF.Domain ) )
+                    && node.getNodeData().isHasSequence()
                     && ( node.getNodeData().getSequence().getDomainArchitecture() != null ) ) {
                 final DomainArchitecture da = node.getNodeData().getSequence().getDomainArchitecture();
                 I: for( int i = 0; i < da.getNumberOfDomains(); ++i ) {
-                    if ( match( da.getDomain( i ).getName(), query, case_sensitive, partial ) ) {
+                    if ( ( da.getDomain( i ).getConfidence() <= domains_confidence_threshold )
+                            && ( match( da.getDomain( i ).getName(), my_query, case_sensitive, partial, regex ) ) ) {
                         match = true;
                         break I;
                     }
                 }
             }
-            //
-            if ( !match && node.getNodeData().isHasSequence()
+            if ( !match && ( ( ndf == null ) || ( ndf == NDF.Annotation ) ) && node.getNodeData().isHasSequence()
                     && ( node.getNodeData().getSequence().getAnnotations() != null ) ) {
                 for( final Annotation ann : node.getNodeData().getSequence().getAnnotations() ) {
-                    if ( match( ann.getDesc(), query, case_sensitive, partial ) ) {
+                    if ( match( ann.getDesc(), my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break;
                     }
-                    if ( match( ann.getRef(), query, case_sensitive, partial ) ) {
+                    if ( match( ann.getRef(), my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break;
                     }
                 }
             }
-            if ( !match && node.getNodeData().isHasSequence()
+            if ( !match && ( ( ndf == null ) || ( ndf == NDF.CrossRef ) ) && node.getNodeData().isHasSequence()
                     && ( node.getNodeData().getSequence().getCrossReferences() != null ) ) {
                 for( final Accession x : node.getNodeData().getSequence().getCrossReferences() ) {
-                    if ( match( x.getComment(), query, case_sensitive, partial ) ) {
+                    if ( match( x.getComment(), my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break;
                     }
-                    if ( match( x.getSource(), query, case_sensitive, partial ) ) {
+                    if ( match( x.getSource(), my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break;
                     }
-                    if ( match( x.getValue(), query, case_sensitive, partial ) ) {
+                    if ( match( x.getValue(), my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break;
                     }
                 }
             }
-            //
-            if ( !match && ( node.getNodeData().getBinaryCharacters() != null ) ) {
+            if ( !match && ( ( ndf == null ) || ( ndf == NDF.BinaryCharacter ) )
+                    && ( node.getNodeData().getBinaryCharacters() != null ) ) {
                 Iterator<String> it = node.getNodeData().getBinaryCharacters().getPresentCharacters().iterator();
                 I: while ( it.hasNext() ) {
-                    if ( match( it.next(), query, case_sensitive, partial ) ) {
+                    if ( match( it.next(), my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break I;
                     }
                 }
                 it = node.getNodeData().getBinaryCharacters().getGainedCharacters().iterator();
                 I: while ( it.hasNext() ) {
-                    if ( match( it.next(), query, case_sensitive, partial ) ) {
+                    if ( match( it.next(), my_query, case_sensitive, partial, regex ) ) {
                         match = true;
                         break I;
                     }
                 }
             }
+            if ( !match
+                    && ( ndf == NDF.MolecularSequence )
+                    && node.getNodeData().isHasSequence()
+                    && match( node.getNodeData().getSequence().getMolecularSequence(),
+                              my_query,
+                              case_sensitive,
+                              true,
+                              regex ) ) {
+                match = true;
+            }
             if ( match ) {
                 nodes.add( node );
             }
@@ -1071,7 +1148,8 @@ public class PhylogenyMethods {
                                                             final Phylogeny phy,
                                                             final boolean case_sensitive,
                                                             final boolean partial,
-                                                            final boolean search_domains ) {
+                                                            final boolean search_domains,
+                                                            final double domains_confidence_threshold ) {
         final List<PhylogenyNode> nodes = new ArrayList<PhylogenyNode>();
         if ( phy.isEmpty() || ( queries == null ) || ( queries.length < 1 ) ) {
             return nodes;
@@ -1079,123 +1157,168 @@ public class PhylogenyMethods {
         for( final PhylogenyNodeIterator iter = phy.iteratorPreorder(); iter.hasNext(); ) {
             final PhylogenyNode node = iter.next();
             boolean all_matched = true;
-            for( final String query : queries ) {
+            for( String query : queries ) {
+                if ( query == null ) {
+                    continue;
+                }
+                query = query.trim();
+                NDF ndf = null;
+                if ( ( query.length() > 2 ) && ( query.indexOf( ":" ) == 2 ) ) {
+                    ndf = NDF.fromString( query );
+                    if ( ndf != null ) {
+                        query = query.substring( 3 );
+                    }
+                }
                 boolean match = false;
                 if ( ForesterUtil.isEmpty( query ) ) {
                     continue;
                 }
-                if ( match( node.getName(), query, case_sensitive, partial ) ) {
+                if ( ( ( ndf == null ) || ( ndf == NDF.NodeName ) )
+                        && match( node.getName(), query, case_sensitive, partial, false ) ) {
                     match = true;
                 }
-                else if ( node.getNodeData().isHasTaxonomy()
-                        && match( node.getNodeData().getTaxonomy().getTaxonomyCode(), query, case_sensitive, partial ) ) {
+                else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyCode ) )
+                        && node.getNodeData().isHasTaxonomy()
+                        && match( node.getNodeData().getTaxonomy().getTaxonomyCode(),
+                                  query,
+                                  case_sensitive,
+                                  partial,
+                                  false ) ) {
                     match = true;
                 }
-                else if ( node.getNodeData().isHasTaxonomy()
-                        && match( node.getNodeData().getTaxonomy().getCommonName(), query, case_sensitive, partial ) ) {
+                else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyCommonName ) )
+                        && node.getNodeData().isHasTaxonomy()
+                        && match( node.getNodeData().getTaxonomy().getCommonName(),
+                                  query,
+                                  case_sensitive,
+                                  partial,
+                                  false ) ) {
                     match = true;
                 }
-                else if ( node.getNodeData().isHasTaxonomy()
-                        && match( node.getNodeData().getTaxonomy().getScientificName(), query, case_sensitive, partial ) ) {
+                else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyScientificName ) )
+                        && node.getNodeData().isHasTaxonomy()
+                        && match( node.getNodeData().getTaxonomy().getScientificName(),
+                                  query,
+                                  case_sensitive,
+                                  partial,
+                                  false ) ) {
                     match = true;
                 }
-                else if ( node.getNodeData().isHasTaxonomy()
+                else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomyIdentifier ) )
+                        && node.getNodeData().isHasTaxonomy()
                         && ( node.getNodeData().getTaxonomy().getIdentifier() != null )
                         && match( node.getNodeData().getTaxonomy().getIdentifier().getValue(),
                                   query,
                                   case_sensitive,
-                                  partial ) ) {
+                                  partial,
+                                  false ) ) {
                     match = true;
                 }
-                else if ( node.getNodeData().isHasTaxonomy()
+                else if ( ( ( ndf == null ) || ( ndf == NDF.TaxonomySynonym ) ) && node.getNodeData().isHasTaxonomy()
                         && !node.getNodeData().getTaxonomy().getSynonyms().isEmpty() ) {
                     final List<String> syns = node.getNodeData().getTaxonomy().getSynonyms();
                     I: for( final String syn : syns ) {
-                        if ( match( syn, query, case_sensitive, partial ) ) {
+                        if ( match( syn, query, case_sensitive, partial, false ) ) {
                             match = true;
                             break I;
                         }
                     }
                 }
-                if ( !match && node.getNodeData().isHasSequence()
-                        && match( node.getNodeData().getSequence().getName(), query, case_sensitive, partial ) ) {
+                if ( !match && ( ( ndf == null ) || ( ndf == NDF.SequenceName ) ) && node.getNodeData().isHasSequence()
+                        && match( node.getNodeData().getSequence().getName(), query, case_sensitive, partial, false ) ) {
                     match = true;
                 }
-                if ( !match && node.getNodeData().isHasSequence()
-                        && match( node.getNodeData().getSequence().getGeneName(), query, case_sensitive, partial ) ) {
+                if ( !match
+                        && ( ( ndf == null ) || ( ndf == NDF.GeneName ) )
+                        && node.getNodeData().isHasSequence()
+                        && match( node.getNodeData().getSequence().getGeneName(), query, case_sensitive, partial, false ) ) {
                     match = true;
                 }
-                if ( !match && node.getNodeData().isHasSequence()
-                        && match( node.getNodeData().getSequence().getSymbol(), query, case_sensitive, partial ) ) {
+                if ( !match && ( ( ndf == null ) || ( ndf == NDF.SequenceSymbol ) )
+                        && node.getNodeData().isHasSequence()
+                        && match( node.getNodeData().getSequence().getSymbol(), query, case_sensitive, partial, false ) ) {
                     match = true;
                 }
                 if ( !match
+                        && ( ( ndf == null ) || ( ndf == NDF.SequenceAccession ) )
                         && node.getNodeData().isHasSequence()
                         && ( node.getNodeData().getSequence().getAccession() != null )
                         && match( node.getNodeData().getSequence().getAccession().getValue(),
                                   query,
                                   case_sensitive,
-                                  partial ) ) {
+                                  partial,
+                                  false ) ) {
                     match = true;
                 }
-                if ( search_domains && !match && node.getNodeData().isHasSequence()
+                if ( !match && ( ( ( ndf == null ) && search_domains ) || ( ndf == NDF.Domain ) )
+                        && node.getNodeData().isHasSequence()
                         && ( node.getNodeData().getSequence().getDomainArchitecture() != null ) ) {
                     final DomainArchitecture da = node.getNodeData().getSequence().getDomainArchitecture();
                     I: for( int i = 0; i < da.getNumberOfDomains(); ++i ) {
-                        if ( match( da.getDomain( i ).getName(), query, case_sensitive, partial ) ) {
+                        if ( ( da.getDomain( i ).getConfidence() <= domains_confidence_threshold )
+                                && match( da.getDomain( i ).getName(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break I;
                         }
                     }
                 }
-                //
-                if ( !match && node.getNodeData().isHasSequence()
+                if ( !match && ( ( ndf == null ) || ( ndf == NDF.Annotation ) ) && node.getNodeData().isHasSequence()
                         && ( node.getNodeData().getSequence().getAnnotations() != null ) ) {
                     for( final Annotation ann : node.getNodeData().getSequence().getAnnotations() ) {
-                        if ( match( ann.getDesc(), query, case_sensitive, partial ) ) {
+                        if ( match( ann.getDesc(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break;
                         }
-                        if ( match( ann.getRef(), query, case_sensitive, partial ) ) {
+                        if ( match( ann.getRef(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break;
                         }
                     }
                 }
-                if ( !match && node.getNodeData().isHasSequence()
+                if ( !match && ( ( ndf == null ) || ( ndf == NDF.CrossRef ) ) && node.getNodeData().isHasSequence()
                         && ( node.getNodeData().getSequence().getCrossReferences() != null ) ) {
                     for( final Accession x : node.getNodeData().getSequence().getCrossReferences() ) {
-                        if ( match( x.getComment(), query, case_sensitive, partial ) ) {
+                        if ( match( x.getComment(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break;
                         }
-                        if ( match( x.getSource(), query, case_sensitive, partial ) ) {
+                        if ( match( x.getSource(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break;
                         }
-                        if ( match( x.getValue(), query, case_sensitive, partial ) ) {
+                        if ( match( x.getValue(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break;
                         }
                     }
                 }
-                //
-                if ( !match && ( node.getNodeData().getBinaryCharacters() != null ) ) {
+                if ( !match && ( ( ndf == null ) || ( ndf == NDF.BinaryCharacter ) )
+                        && ( node.getNodeData().getBinaryCharacters() != null ) ) {
                     Iterator<String> it = node.getNodeData().getBinaryCharacters().getPresentCharacters().iterator();
                     I: while ( it.hasNext() ) {
-                        if ( match( it.next(), query, case_sensitive, partial ) ) {
+                        if ( match( it.next(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break I;
                         }
                     }
                     it = node.getNodeData().getBinaryCharacters().getGainedCharacters().iterator();
                     I: while ( it.hasNext() ) {
-                        if ( match( it.next(), query, case_sensitive, partial ) ) {
+                        if ( match( it.next(), query, case_sensitive, partial, false ) ) {
                             match = true;
                             break I;
                         }
                     }
                 }
+                if ( !match
+                        && ( ndf == NDF.MolecularSequence )
+                        && node.getNodeData().isHasSequence()
+                        && match( node.getNodeData().getSequence().getMolecularSequence(),
+                                  query,
+                                  case_sensitive,
+                                  true,
+                                  false ) ) {
+                    match = true;
+                }
                 if ( !match ) {
                     all_matched = false;
                     break;
@@ -1216,7 +1339,7 @@ public class PhylogenyMethods {
 
     /**
      * Convenience method.
-     * Sets value for the first confidence value (created if not present, values overwritten otherwise). 
+     * Sets value for the first confidence value (created if not present, values overwritten otherwise).
      */
     public static void setBootstrapConfidence( final PhylogenyNode node, final double bootstrap_confidence_value ) {
         setConfidence( node, bootstrap_confidence_value, "bootstrap" );
@@ -1238,7 +1361,7 @@ public class PhylogenyMethods {
 
     /**
      * Convenience method.
-     * Sets value for the first confidence value (created if not present, values overwritten otherwise). 
+     * Sets value for the first confidence value (created if not present, values overwritten otherwise).
      */
     public static void setConfidence( final PhylogenyNode node, final double confidence_value ) {
         setConfidence( node, confidence_value, "" );
@@ -1246,7 +1369,7 @@ public class PhylogenyMethods {
 
     /**
      * Convenience method.
-     * Sets value for the first confidence value (created if not present, values overwritten otherwise). 
+     * Sets value for the first confidence value (created if not present, values overwritten otherwise).
      */
     public static void setConfidence( final PhylogenyNode node, final double confidence_value, final String type ) {
         Confidence c = null;
@@ -1270,11 +1393,11 @@ public class PhylogenyMethods {
 
     /**
      * Convenience method to set the taxonomy code of a phylogeny node.
-     * 
-     * 
+     *
+     *
      * @param node
      * @param taxonomy_code
-     * @throws PhyloXmlDataFormatException 
+     * @throws PhyloXmlDataFormatException
      */
     public static void setTaxonomyCode( final PhylogenyNode node, final String taxonomy_code )
             throws PhyloXmlDataFormatException {
@@ -1285,159 +1408,6 @@ public class PhylogenyMethods {
     }
 
     final static public void sortNodeDescendents( final PhylogenyNode node, final DESCENDANT_SORT_PRIORITY pri ) {
-        class PhylogenyNodeSortTaxonomyPriority implements Comparator<PhylogenyNode> {
-
-            @Override
-            public int compare( final PhylogenyNode n1, final PhylogenyNode n2 ) {
-                if ( n1.getNodeData().isHasTaxonomy() && n2.getNodeData().isHasTaxonomy() ) {
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getScientificName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getScientificName() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getScientificName().toLowerCase()
-                                .compareTo( n2.getNodeData().getTaxonomy().getScientificName().toLowerCase() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getTaxonomyCode() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getTaxonomyCode() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getTaxonomyCode()
-                                .compareTo( n2.getNodeData().getTaxonomy().getTaxonomyCode() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getCommonName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getCommonName() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getCommonName().toLowerCase()
-                                .compareTo( n2.getNodeData().getTaxonomy().getCommonName().toLowerCase() );
-                    }
-                }
-                if ( n1.getNodeData().isHasSequence() && n2.getNodeData().isHasSequence() ) {
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getName() ) ) ) {
-                        return n1.getNodeData().getSequence().getName().toLowerCase()
-                                .compareTo( n2.getNodeData().getSequence().getName().toLowerCase() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getSymbol() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getSymbol() ) ) ) {
-                        return n1.getNodeData().getSequence().getSymbol()
-                                .compareTo( n2.getNodeData().getSequence().getSymbol() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getGeneName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getGeneName() ) ) ) {
-                        return n1.getNodeData().getSequence().getGeneName()
-                                .compareTo( n2.getNodeData().getSequence().getGeneName() );
-                    }
-                    if ( ( n1.getNodeData().getSequence().getAccession() != null )
-                            && ( n2.getNodeData().getSequence().getAccession() != null )
-                            && !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getAccession().getValue() )
-                            && !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getAccession().getValue() ) ) {
-                        return n1.getNodeData().getSequence().getAccession().getValue()
-                                .compareTo( n2.getNodeData().getSequence().getAccession().getValue() );
-                    }
-                }
-                if ( ( !ForesterUtil.isEmpty( n1.getName() ) ) && ( !ForesterUtil.isEmpty( n2.getName() ) ) ) {
-                    return n1.getName().toLowerCase().compareTo( n2.getName().toLowerCase() );
-                }
-                return 0;
-            }
-        }
-        class PhylogenyNodeSortSequencePriority implements Comparator<PhylogenyNode> {
-
-            @Override
-            public int compare( final PhylogenyNode n1, final PhylogenyNode n2 ) {
-                if ( n1.getNodeData().isHasSequence() && n2.getNodeData().isHasSequence() ) {
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getName() ) ) ) {
-                        return n1.getNodeData().getSequence().getName().toLowerCase()
-                                .compareTo( n2.getNodeData().getSequence().getName().toLowerCase() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getSymbol() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getSymbol() ) ) ) {
-                        return n1.getNodeData().getSequence().getSymbol()
-                                .compareTo( n2.getNodeData().getSequence().getSymbol() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getGeneName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getGeneName() ) ) ) {
-                        return n1.getNodeData().getSequence().getGeneName()
-                                .compareTo( n2.getNodeData().getSequence().getGeneName() );
-                    }
-                    if ( ( n1.getNodeData().getSequence().getAccession() != null )
-                            && ( n2.getNodeData().getSequence().getAccession() != null )
-                            && !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getAccession().getValue() )
-                            && !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getAccession().getValue() ) ) {
-                        return n1.getNodeData().getSequence().getAccession().getValue()
-                                .compareTo( n2.getNodeData().getSequence().getAccession().getValue() );
-                    }
-                }
-                if ( n1.getNodeData().isHasTaxonomy() && n2.getNodeData().isHasTaxonomy() ) {
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getScientificName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getScientificName() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getScientificName().toLowerCase()
-                                .compareTo( n2.getNodeData().getTaxonomy().getScientificName().toLowerCase() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getTaxonomyCode() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getTaxonomyCode() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getTaxonomyCode()
-                                .compareTo( n2.getNodeData().getTaxonomy().getTaxonomyCode() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getCommonName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getCommonName() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getCommonName().toLowerCase()
-                                .compareTo( n2.getNodeData().getTaxonomy().getCommonName().toLowerCase() );
-                    }
-                }
-                if ( ( !ForesterUtil.isEmpty( n1.getName() ) ) && ( !ForesterUtil.isEmpty( n2.getName() ) ) ) {
-                    return n1.getName().toLowerCase().compareTo( n2.getName().toLowerCase() );
-                }
-                return 0;
-            }
-        }
-        class PhylogenyNodeSortNodeNamePriority implements Comparator<PhylogenyNode> {
-
-            @Override
-            public int compare( final PhylogenyNode n1, final PhylogenyNode n2 ) {
-                if ( ( !ForesterUtil.isEmpty( n1.getName() ) ) && ( !ForesterUtil.isEmpty( n2.getName() ) ) ) {
-                    return n1.getName().toLowerCase().compareTo( n2.getName().toLowerCase() );
-                }
-                if ( n1.getNodeData().isHasTaxonomy() && n2.getNodeData().isHasTaxonomy() ) {
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getScientificName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getScientificName() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getScientificName().toLowerCase()
-                                .compareTo( n2.getNodeData().getTaxonomy().getScientificName().toLowerCase() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getTaxonomyCode() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getTaxonomyCode() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getTaxonomyCode()
-                                .compareTo( n2.getNodeData().getTaxonomy().getTaxonomyCode() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getCommonName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getCommonName() ) ) ) {
-                        return n1.getNodeData().getTaxonomy().getCommonName().toLowerCase()
-                                .compareTo( n2.getNodeData().getTaxonomy().getCommonName().toLowerCase() );
-                    }
-                }
-                if ( n1.getNodeData().isHasSequence() && n2.getNodeData().isHasSequence() ) {
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getName() ) ) ) {
-                        return n1.getNodeData().getSequence().getName().toLowerCase()
-                                .compareTo( n2.getNodeData().getSequence().getName().toLowerCase() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getSymbol() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getSymbol() ) ) ) {
-                        return n1.getNodeData().getSequence().getSymbol()
-                                .compareTo( n2.getNodeData().getSequence().getSymbol() );
-                    }
-                    if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getGeneName() ) )
-                            && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getGeneName() ) ) ) {
-                        return n1.getNodeData().getSequence().getGeneName()
-                                .compareTo( n2.getNodeData().getSequence().getGeneName() );
-                    }
-                    if ( ( n1.getNodeData().getSequence().getAccession() != null )
-                            && ( n2.getNodeData().getSequence().getAccession() != null )
-                            && !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getAccession().getValue() )
-                            && !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getAccession().getValue() ) ) {
-                        return n1.getNodeData().getSequence().getAccession().getValue()
-                                .compareTo( n2.getNodeData().getSequence().getAccession().getValue() );
-                    }
-                }
-                return 0;
-            }
-        }
         Comparator<PhylogenyNode> c;
         switch ( pri ) {
             case SEQUENCE:
@@ -1460,7 +1430,7 @@ public class PhylogenyMethods {
     /**
      * Removes from Phylogeny to_be_stripped all external Nodes which are
      * associated with a species NOT found in Phylogeny reference.
-     * 
+     *
      * @param reference
      *            a reference Phylogeny
      * @param to_be_stripped
@@ -1747,7 +1717,7 @@ public class PhylogenyMethods {
     /**
      * Calculates the distance between PhylogenyNodes n1 and n2.
      * PRECONDITION: n1 is a descendant of n2.
-     * 
+     *
      * @param n1
      *            a descendant of n2
      * @param n2
@@ -1767,21 +1737,54 @@ public class PhylogenyMethods {
     private static boolean match( final String s,
                                   final String query,
                                   final boolean case_sensitive,
-                                  final boolean partial ) {
+                                  final boolean partial,
+                                  final boolean regex ) {
         if ( ForesterUtil.isEmpty( s ) || ForesterUtil.isEmpty( query ) ) {
             return false;
         }
         String my_s = s.trim();
         String my_query = query.trim();
-        if ( !case_sensitive ) {
+        if ( !case_sensitive && !regex ) {
             my_s = my_s.toLowerCase();
             my_query = my_query.toLowerCase();
         }
-        if ( partial ) {
+        if ( regex ) {
+            Pattern p = null;
+            try {
+                if ( case_sensitive ) {
+                    p = Pattern.compile( my_query );
+                }
+                else {
+                    p = Pattern.compile( my_query, Pattern.CASE_INSENSITIVE );
+                }
+            }
+            catch ( final PatternSyntaxException e ) {
+                return false;
+            }
+            if ( p != null ) {
+                return p.matcher( my_s ).find();
+            }
+            else {
+                return false;
+            }
+        }
+        else if ( partial ) {
             return my_s.indexOf( my_query ) >= 0;
         }
         else {
-            return Pattern.compile( "(\\b|_)" + Pattern.quote( my_query ) + "(\\b|_)" ).matcher( my_s ).find();
+            Pattern p = null;
+            try {
+                p = Pattern.compile( "(\\b|_)" + Pattern.quote( my_query ) + "(\\b|_)" );
+            }
+            catch ( final PatternSyntaxException e ) {
+                return false;
+            }
+            if ( p != null ) {
+                return p.matcher( my_s ).find();
+            }
+            else {
+                return false;
+            }
         }
     }
 
@@ -1810,4 +1813,142 @@ public class PhylogenyMethods {
         TAXONOMY_ID_UNIPROT_2,
         TAXONOMY_SCIENTIFIC_NAME;
     }
+
+    public static void addMolecularSeqsToTree( final Phylogeny phy, final Msa msa ) {
+        for( int s = 0; s < msa.getNumberOfSequences(); ++s ) {
+            final org.forester.sequence.MolecularSequence seq = msa.getSequence( s );
+            final PhylogenyNode node = phy.getNode( seq.getIdentifier() );
+            final org.forester.phylogeny.data.Sequence new_seq = new Sequence();
+            new_seq.setMolecularSequenceAligned( true );
+            new_seq.setMolecularSequence( seq.getMolecularSequenceAsString() );
+            new_seq.setName( seq.getIdentifier() );
+            try {
+                new_seq.setType( PhyloXmlUtil.SEQ_TYPE_PROTEIN );
+            }
+            catch ( final PhyloXmlDataFormatException ignore ) {
+                // do nothing
+            }
+            node.getNodeData().addSequence( new_seq );
+        }
+    }
+
+    final private static class PhylogenyNodeSortTaxonomyPriority implements Comparator<PhylogenyNode> {
+
+        @Override
+        public int compare( final PhylogenyNode n1, final PhylogenyNode n2 ) {
+            if ( n1.getNodeData().isHasTaxonomy() && n2.getNodeData().isHasTaxonomy() ) {
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getScientificName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getScientificName() ) ) ) {
+                    return n1.getNodeData().getTaxonomy().getScientificName().toLowerCase()
+                            .compareTo( n2.getNodeData().getTaxonomy().getScientificName().toLowerCase() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getTaxonomyCode() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getTaxonomyCode() ) ) ) {
+                    return n1.getNodeData().getTaxonomy().getTaxonomyCode()
+                            .compareTo( n2.getNodeData().getTaxonomy().getTaxonomyCode() );
+                }
+            }
+            if ( n1.getNodeData().isHasSequence() && n2.getNodeData().isHasSequence() ) {
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getName() ) ) ) {
+                    return n1.getNodeData().getSequence().getName().toLowerCase()
+                            .compareTo( n2.getNodeData().getSequence().getName().toLowerCase() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getGeneName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getGeneName() ) ) ) {
+                    return n1.getNodeData().getSequence().getGeneName()
+                            .compareTo( n2.getNodeData().getSequence().getGeneName() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getSymbol() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getSymbol() ) ) ) {
+                    return n1.getNodeData().getSequence().getSymbol()
+                            .compareTo( n2.getNodeData().getSequence().getSymbol() );
+                }
+            }
+            if ( ( !ForesterUtil.isEmpty( n1.getName() ) ) && ( !ForesterUtil.isEmpty( n2.getName() ) ) ) {
+                return n1.getName().toLowerCase().compareTo( n2.getName().toLowerCase() );
+            }
+            return 0;
+        }
+    }
+
+    final private static class PhylogenyNodeSortSequencePriority implements Comparator<PhylogenyNode> {
+
+        @Override
+        public int compare( final PhylogenyNode n1, final PhylogenyNode n2 ) {
+            if ( n1.getNodeData().isHasSequence() && n2.getNodeData().isHasSequence() ) {
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getName() ) ) ) {
+                    return n1.getNodeData().getSequence().getName().toLowerCase()
+                            .compareTo( n2.getNodeData().getSequence().getName().toLowerCase() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getGeneName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getGeneName() ) ) ) {
+                    return n1.getNodeData().getSequence().getGeneName()
+                            .compareTo( n2.getNodeData().getSequence().getGeneName() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getSymbol() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getSymbol() ) ) ) {
+                    return n1.getNodeData().getSequence().getSymbol()
+                            .compareTo( n2.getNodeData().getSequence().getSymbol() );
+                }
+            }
+            if ( n1.getNodeData().isHasTaxonomy() && n2.getNodeData().isHasTaxonomy() ) {
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getScientificName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getScientificName() ) ) ) {
+                    return n1.getNodeData().getTaxonomy().getScientificName().toLowerCase()
+                            .compareTo( n2.getNodeData().getTaxonomy().getScientificName().toLowerCase() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getTaxonomyCode() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getTaxonomyCode() ) ) ) {
+                    return n1.getNodeData().getTaxonomy().getTaxonomyCode()
+                            .compareTo( n2.getNodeData().getTaxonomy().getTaxonomyCode() );
+                }
+            }
+            if ( ( !ForesterUtil.isEmpty( n1.getName() ) ) && ( !ForesterUtil.isEmpty( n2.getName() ) ) ) {
+                return n1.getName().toLowerCase().compareTo( n2.getName().toLowerCase() );
+            }
+            return 0;
+        }
+    }
+
+    final private static class PhylogenyNodeSortNodeNamePriority implements Comparator<PhylogenyNode> {
+
+        @Override
+        public int compare( final PhylogenyNode n1, final PhylogenyNode n2 ) {
+            if ( ( !ForesterUtil.isEmpty( n1.getName() ) ) && ( !ForesterUtil.isEmpty( n2.getName() ) ) ) {
+                return n1.getName().toLowerCase().compareTo( n2.getName().toLowerCase() );
+            }
+            if ( n1.getNodeData().isHasTaxonomy() && n2.getNodeData().isHasTaxonomy() ) {
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getScientificName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getScientificName() ) ) ) {
+                    return n1.getNodeData().getTaxonomy().getScientificName().toLowerCase()
+                            .compareTo( n2.getNodeData().getTaxonomy().getScientificName().toLowerCase() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getTaxonomy().getTaxonomyCode() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getTaxonomy().getTaxonomyCode() ) ) ) {
+                    return n1.getNodeData().getTaxonomy().getTaxonomyCode()
+                            .compareTo( n2.getNodeData().getTaxonomy().getTaxonomyCode() );
+                }
+            }
+            if ( n1.getNodeData().isHasSequence() && n2.getNodeData().isHasSequence() ) {
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getName() ) ) ) {
+                    return n1.getNodeData().getSequence().getName().toLowerCase()
+                            .compareTo( n2.getNodeData().getSequence().getName().toLowerCase() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getGeneName() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getGeneName() ) ) ) {
+                    return n1.getNodeData().getSequence().getGeneName()
+                            .compareTo( n2.getNodeData().getSequence().getGeneName() );
+                }
+                if ( ( !ForesterUtil.isEmpty( n1.getNodeData().getSequence().getSymbol() ) )
+                        && ( !ForesterUtil.isEmpty( n2.getNodeData().getSequence().getSymbol() ) ) ) {
+                    return n1.getNodeData().getSequence().getSymbol()
+                            .compareTo( n2.getNodeData().getSequence().getSymbol() );
+                }
+            }
+            return 0;
+        }
+    }
 }