Changeset 75 for trunk/grails-app/domain

Timestamp:

Nov 28, 2011, 9:18:01 AM (12 years ago)

Author:

robert@…

Message:

Last fixes and extra bugfix in import controller

Location:

trunk/grails-app/domain/nl/tno/massSequencing

Files:

• AssaySample.groovy (modified) (7 diffs)
• Sequence.groovy (modified) (2 diffs)
• classification/Taxon.groovy (modified) (4 diffs)

trunk/grails-app/domain/nl/tno/massSequencing/AssaySample.groovy

@@ -1 +1 @@
 package nl.tno.massSequencing
+import nl.tno.massSequencing.classification.*
 
 import org.codehaus.groovy.grails.commons.ApplicationHolder as AH
@@ -12 +13 @@
         // Grails datasource is used for executing custom SQL statement
         def dataSource
+        def sessionFactory
         
         // To be computed at run time (and saved in cache)
@@ -76 +78 @@
          */
         public int numClassifiedSequences() {
-                return Sequence.countByAssaySample( this );
+                int numSeqs = 0;
+                if( this.sequenceData ) {
+                        sequenceData.each {
+                                def sequenceDataNum = Sequence.countBySequenceData( it );
+                                numSeqs += sequenceDataNum ?: 0;
+                        }
+                }
+                
+                return numSeqs
         }
         
@@ -280 +290 @@
                 otherAssaySample.numSequences   = numSequences;
 
+                otherAssaySample.save( flush: true );
+                
                 // Move attached data
                 def dataList = [] + sequenceData?.toList()
@@ -293 +305 @@
                                         // Clone the sequencedata object
                                         def sd = dataList[ j ]?.clone();
-                                        
+
                                         if( sd )
                                                 otherAssaySample.addToSequenceData( sd );
-
+                                        
                                         // Copy all sequence classifications to the new sequenceData
-                                        Sequence.executeUpdate( "UPDATE Sequence s SET s.sequenceData = :new WHERE s.sequenceData = :old ", [ 'old': dataList[ j ], 'new': sd ] )
+                                        //log.debug "Removing sequences from sequencedata " + dataList[ j ]?.id + " to " + sd?.id
+                                        //Sequence.executeUpdate( "UPDATE Sequence s SET s.sequenceData = :new WHERE s.sequenceData = :old ", [ 'old': dataList[ j ], 'new': sd ] )
+                                        //Sequence.executeUpdate( "DELETE FROM Sequence s WHERE s.sequenceData = :old ", [ 'old': dataList[ j ] ] )
                                 
                                         // Remove the old sequencedata object
@@ -310 +324 @@
                         otherAssaySample.run.removeFromAssaySamples( otherAssaySample );
                 }
-                
+
                 // Remove this sample from the run.
                 if( run ) {
@@ -319 +333 @@
                         otherAssaySample.run = null;
                 }
+                
         }
         

trunk/grails-app/domain/nl/tno/massSequencing/Sequence.groovy

@@ -3 +3 @@
 import nl.tno.massSequencing.classification.Taxon
 
-class Sequence {
+class Sequence implements Serializable {
         // Unique name of this sequence
         String name
@@ -22 +22 @@
         
         static mapping = {
+                id composite: ['name']
                 name index: 'name_idx'
                 classification index: 'taxon_idx'
-                sequenceData index: 'sequenceData_idx'
+                sequenceData index: 'sequenceData_idx', cascade: "all-delete-orphan"
+                
         }
 }

trunk/grails-app/domain/nl/tno/massSequencing/classification/Taxon.groovy

@@ -169 +169 @@
          * @return                              First taxon that is found and matches the criteria or null if nothing is found
          */
-        public static Taxon findTaxonByPath( def path, int startLevel = 0 ) {
+        public static Taxon findTaxonByPath( def path, int startLevel = 0, taxonCache ) {
                 if( path.size() == 0 )
                         return null;
+                        
+                // Check taxon cache
+                def cacheTaxon = findTaxonInCache( taxonCache, path );
+                if( cacheTaxon )
+                        return cacheTaxon;
                         
                 def leafLevel = path.size() - 1 + startLevel;
@@ -203 +208 @@
                         }
                         
+                        storeTaxonInCache( taxonCache, path, leaf );
+                        
                         return leaf;
                 }
                 
                 return null;
+        }
+        
+        public static emptyTaxonCache() {
+                return [ "top": [:], "sub": [:] ];
+        }
+        
+        protected static Taxon findTaxonInCache( cache, path ) {
+                if( path.size() <= 3 ) { 
+                        return cache[ "top" ][ cacheKey( path ) ];
+                } else {
+                        def topCacheKey = cacheKey( path[0..2] );
+                        
+                        if( !cache[ "sub" ][ topCacheKey ] )
+                                return null;
+                        
+                        return findTaxonInCache( cache[ "sub" ][ topCacheKey ], path[ 3..-1] );
+                } 
+        }
+        
+        protected static void storeTaxonInCache( cache, path, taxon ) {
+                // Keep a 'layered' cache: the first three levels are kept in this cache. The
+                // next levels are kept in a separate cache, one map for each subtree, so 
+                // each map will have a size that we can still deal with
+                //      [ 
+                //      "top": [ "bacteria": x, "bacteria;firmicutes": y ],
+                //      "sub": [ "bacteria;firmicutes;abc": 
+                //                              [ "def;ghi" : z, "def;gkl": m ]
+                //                      ]
+                if( path.size() <= 3 ) {
+                        cache[ "top" ][ cacheKey( path ) ] = taxon;
+                } else { 
+                        def topCacheKey = cacheKey( path[0..2] );
+                        def restPath = path[3..-1]
+                        
+                        if( cache[ "sub" ][ topCacheKey ] == null ) {
+                                cache[ "sub" ][ topCacheKey ] = emptyTaxonCache();
+                        }
+                        
+                        storeTaxonInCache( cache[ "sub" ][ topCacheKey ], restPath, taxon )
+                }
+                
+        }
+        
+        protected static cacheKey( path ) {
+                return  path.join( ";" );
         }
         
@@ -215 +267 @@
          * @param path                  An array or list with the names of the taxa in the path, ordered by level
          * @param startLevel    Which level is the first entry in the list. Defaults to zero. Can be used in order to find taxa
-         *                                              without the whole tree being specified (e.g. without the root element) 
+         *                                              without the whole tree being specified (e.g. without the root element)
+         * @param taxonCache    Hashmap with cached data about taxa found 
          * @return                              First taxon that is found and matches the criteria or a new taxon if it didn't exist
          */
-        static Taxon findOrCreateTaxonByPath( def path, int startLevel = 0 ) {
-                def taxon = findTaxonByPath( path, startLevel );
+        static Taxon findOrCreateTaxonByPath( def path, int startLevel = 0, def taxonCache = null ) {
+                def taxon = findTaxonByPath( path, startLevel, taxonCache );
                 
                 if( taxon )
@@ -233 +286 @@
                 // However, we don't have to check the highest level, so we start at depth - 2 
                 for( def level = depth - 2; level >= 0 && !found ; level-- ) {
-                        parentNode = findTaxonByPath( path[ 0 .. level ], startLevel );
+                        parentNode = findTaxonByPath( path[ 0 .. level ], startLevel, taxonCache );
                         
                         // If this taxon is found, it is the highest level