Changeset 4134

Timestamp:

Feb 8, 2008, 2:48:22 PM (15 years ago)

Author:

Nicklas Nordborg

Message:

Fixes #921: Experiment overview should be updated with support for mutli-array slides

Location:

trunk/src/core/net/sf/basedb

Files:

• core/Hybridization.java (modified) (1 diff)
• util/overview/ExperimentOverview.java (modified) (14 diffs)
• util/overview/Failure.java (modified) (5 diffs)
• util/overview/Validator.java (modified) (1 diff)

trunk/src/core/net/sf/basedb/core/Hybridization.java

@@ -311 +311 @@
   
   /**
+    Get a query that returns labeled extracts connected to
+    this hybridization.
+    @param arrayNum If > 0 only labeled extracts on the specific sub-array
+      are returned by the query, if <= 0, all labeled extracts
+      are returned
+    @return An {@link ItemQuery} object
+    @since 2.6
+  */
+  @SuppressWarnings("unchecked")
+  public ItemQuery<LabeledExtract> getLabeledExtracts(int arrayNum)
+  {
+    ItemQuery<LabeledExtract> query = (ItemQuery<LabeledExtract>)getCreationEvent().getSources();
+    if (arrayNum > 0)
+    {
+      query.restrictPermanent(
+        Restrictions.eq(
+          Hql.property("srcevt", "sourceGroup"), 
+          Expressions.integer(arrayNum)
+        )
+      );
+    }
+    return query;
+  }
+  
+  /**
     Create a new {@link Scan} from this hybridization.
    

trunk/src/core/net/sf/basedb/util/overview/ExperimentOverview.java

@@ -168 +168 @@
             Validator.NONMATHCING_ARRAYDESIGN, Validator.MULTIPLE_ARRAYDESIGNS, 
             Validator.INCORRECT_PROTOCOLTYPE, Validator.INCORRECT_SOFTWARETYPE,
-            Validator.INCORRECT_HARDWARETYPE, Validator.INCORRECT_NUM_LABELEDEXTRACTS,
+            Validator.INCORRECT_HARDWARETYPE, Validator.INCORRECT_ARRAY_NUM,
+            Validator.DUPLICATE_ARRAY_NUM, Validator.INCORRECT_NUM_LABELEDEXTRACTS,
             Validator.NONUNIQUE_LABEL, Validator.DIFFERENT_LABEL, 
             Validator.NONUNIQUE_NAME_FOR_TYPE, Validator.NONUNIQUE_NAME_GLOBAL,
@@ -261 +262 @@
   private Map<String, Node> allNodes;
   private Map<Item, Set<AnnotationType>> miameAnnotations;
-  private Map<Annotatable, Set<Annotatable>> annotatableParents;
+  private Map<Object, Set<Annotatable>> annotatableParents;
+  private Map<String, Node> usedHybArrays;
   
   /**
@@ -299 +301 @@
   {
     this.failures = new LinkedList<Failure>();
-    this.annotatableParents = new HashMap<Annotatable, Set<Annotatable>>();
+    this.annotatableParents = new HashMap<Object, Set<Annotatable>>();
+    this.usedHybArrays = new HashMap<String, Node>();
     
     // Load 'Required for MIAME' annotation types (parameter='false' must also be set)
@@ -349 +352 @@
     }
     
+    usedHybArrays.clear(); // No longer needed
     this.allNodes = new HashMap<String, Node>();
     allNodes.put(rootNode.getId(), rootNode);
@@ -470 +474 @@
   public Set<Annotatable> getAnnotatableParents(Annotatable item)
   {
-    Set<Annotatable> parents = annotatableParents.get(item);
+    return getAnnotatableParents(item, item);
+  }
+  
+  private Set<Annotatable> getAnnotatableParents(Annotatable current, Annotatable root)
+  {
+    Object cacheKey = current;
+    Hybridization hyb = null;
+    int arrayNum = 1;
+    // Special case when starting with a raw bioassay since we only
+    // want to get parents from the sub-array with the same 
+    // index = rba.getArrayNum()
+    if (root instanceof RawBioAssay)
+    {
+      RawBioAssay rba = (RawBioAssay)root;
+      arrayNum = rba.getArrayNum();
+      if (current instanceof Scan)
+      {
+        cacheKey = "SCAN:" + current.getId() + ":" + arrayNum;
+      }
+      else if (current instanceof Hybridization)
+      {
+        hyb = (Hybridization)current;
+        cacheKey = "HYB:" + hyb.getId() + ":" + arrayNum;
+      }
+    }
+  
+    Set<Annotatable> parents = annotatableParents.get(cacheKey);
     if (parents == null)
     {
       parents = new HashSet<Annotatable>();
-      annotatableParents.put(item, parents);
-      Set<Annotatable> temp = item.getAnnotatableParents();
+      annotatableParents.put(cacheKey, parents);
+      Set<Annotatable> temp = hyb != null ?
+        hyb.getAnnotatableParents(arrayNum) : current.getAnnotatableParents();
       if (temp != null)
       {
@@ -481 +512 @@
         {
           parents.add(a);
-          parents.addAll(getAnnotatableParents(a));
+          parents.addAll(getAnnotatableParents(a, root));
         }
       }
     }
     return parents;
+    
   }
   
@@ -773 +805 @@
       addImages(dc, scanNode);
       addHardware(dc, scanNode, "Scanner");
-      addHybridization(dc, scanNode);
+      addHybridization(dc, scanNode, rawBioAssayNode);
       addProtocol(dc, scanNode, Project.Default.SCANNING_PROTOCOL);
     }
@@ -788 +820 @@
     Creates an item-type node with the name <code>hybridization</code>.
   */
-  private Node addHybridization(DbControl dc, Node scanNode)
+  private Node addHybridization(DbControl dc, Node scanNode, Node rawBioAssayNode)
   {
     Scan scan = (Scan)scanNode.getItem();
+    RawBioAssay rba = (RawBioAssay)rawBioAssayNode.getItem();
     Node hybNode = null;
     Hybridization hyb = null;
@@ -806 +839 @@
       hybNode = new Node("hybridization", "Hybridization: " + hyb.getName(), scanNode, hyb);
       addAnnotations(dc, hybNode);
-      addLabeledExtracts(dc, hybNode);
+      addLabeledExtracts(dc, hybNode, rawBioAssayNode);
       addHardware(dc, hybNode, "Hyb. station");
       addProtocol(dc, hybNode, Project.Default.HYBRIDIZATION_PROTOCOL);
       addArraySlide(dc, hybNode);
+      
+      // Check that arrayNum <= hyb.getNumArrays()
+      int arrayNum = rba.getArrayNum();
+      if (arrayNum > hyb.getNumArrays())
+      {
+        Failure failure = new Failure(Validator.INCORRECT_ARRAY_NUM, rawBioAssayNode,
+          "Incorrect sub-array index: " + arrayNum + " (expected 1--" + hyb.getNumArrays() + ")",
+          new Fix("Change array index on raw bioassay", rba), 
+          new Fix("Increase arrays on hybridization", hyb));
+        failures.add(failure);
+      }
+      
+      String usedHybIndex = hyb.getId() + ":" + arrayNum;
+      if (usedHybArrays.containsKey(usedHybIndex))
+      {
+        Node other = usedHybArrays.get(usedHybIndex);
+        Fix fixA = new Fix("Change array index on " + rba.getName(), rba);
+        Fix fixB = new Fix("Change array index on " + other.getTitle(), other.getItem()); 
+
+        Failure failure = new Failure(Validator.DUPLICATE_ARRAY_NUM, rawBioAssayNode,
+            "Duplicate sub-array index: " + arrayNum + " (used by " + other.getTitle() + ")",
+            fixA, fixB);
+        failures.add(failure);
+        
+        failure = new Failure(Validator.DUPLICATE_ARRAY_NUM, other,
+            "Duplicate sub-array index: " + arrayNum + " (used by " + rba.getName() + ")",
+            fixB, fixA);
+        failures.add(failure);
+      }
+      else
+      {
+        usedHybArrays.put(usedHybIndex, rawBioAssayNode);
+      }
+      
     }
     if (hybNode == null)
@@ -853 +920 @@
   */
   @SuppressWarnings("unchecked")
-  private Node addLabeledExtracts(DbControl dc, Node hybNode)
+  private Node addLabeledExtracts(DbControl dc, Node hybNode, Node rawBioAssayNode)
   {
     Node leNode = new Node("labeledextracts", "Labeled extracts", hybNode);
     Hybridization hyb = (Hybridization)hybNode.getItem();
+    RawBioAssay rba = (RawBioAssay)rawBioAssayNode.getItem();
+    int arrayNum = rba.getArrayNum();
     ItemQuery<LabeledExtract> leQuery = 
-      (ItemQuery<LabeledExtract>)initQuery(hyb.getCreationEvent().getSources(), null, "label.name");
+      initQuery(hyb.getLabeledExtracts(arrayNum), null, "label.name");
     int added = 0;
     int channels = experiment.getRawDataType().getChannels();
@@ -893 +962 @@
       String message = added > channels ?
         "Too many labeled extracts" : "Too few labeled extracts";
-      failures.add(new Failure(Validator.INCORRECT_NUM_LABELEDEXTRACTS, hybNode, message, fix));
+      message += ": " + added + " (" + channels + " expected)";
+      Failure failure = new Failure(Validator.INCORRECT_NUM_LABELEDEXTRACTS, hybNode, message, fix);
+      failure.setDescriptor(arrayNum);
+      failures.add(failure);
     }
     
@@ -900 +972 @@
     {
       Failure failure = new Failure(Validator.NONUNIQUE_LABEL, hybNode);
+      failure.setDescriptor(arrayNum);
       failure.addFix(new Fix("Change labeled extracts on hybridization", hyb));
       for (LabeledExtract le : nonUnique)
@@ -907 +980 @@
       failures.add(failure);
     }
+    
     return leNode;
   }
@@ -1826 +1900 @@
                 "Inheriting annotation '" + (at != null ? 
                   at.getName() : a.getValueType().toString()) + "' from non-parent",
-                new Fix("Remove inherited annotation", parentNode.getItem(), at, true)
+                new Fix("Inherit from another item", parentNode.getItem(), at, true)
               ));
             }

trunk/src/core/net/sf/basedb/util/overview/Failure.java

@@ -39 +39 @@
   this object is a bit unorthodox. Two failures are considered equal
   if they have the same validator but different nodes referencing the
-  same item. Two failures on the same node are never equal. This allows
-  us to filter out duplicate failures that happens because there
-  can be several ways to reach a certain item (for example a reference
-  sample that is used on all hybridizations).   
+  same item with the same descriptor. Two failures on the same node 
+  are never equal. This allows us to filter out duplicate failures that 
+  happens because there can be several ways to reach a certain item (for 
+  example a reference sample that is used on all hybridizations).   
   
   @author Nicklas
@@ -59 +59 @@
   private String message;
   private List<Fix> fixes;
+  private Object descriptor;
   
   /**
@@ -102 +103 @@
   
   /**
+    Set a descriptor on this failure. This affects the {@link #equals(Object)}
+    method, since the descriptor must be equal for two failures to be
+    equal. 
+    <p>
+    NOTE! The main reason for this property is that we need to discriminate
+    between failures on different sub-arrays on hybridizations.
+    @param descriptor Any object
+    @since 2.6
+  */
+  public void setDescriptor(Object descriptor)
+  {
+    this.descriptor = descriptor;
+  }
+  /**
+    @return The descriptor
+    @since 2.6
+    @see #setDescriptor(Object)
+  */
+  public Object getDescriptor()
+  {
+    return descriptor;
+  }
+  
+  /**
     Get the validation rule that failed.
   */
@@ -154 +179 @@
   /**
     One failure is the same as another if they have the same validator
-    but different nodes referencing the same item.
+    but different nodes referencing the same item with equal descriptors.
   */
   @Override
@@ -165 +190 @@
     boolean sameItem = sameNode || this.node.getItem() ==  other.node.getItem();
     boolean sameValidator = this.validator == other.validator;
-    return !sameNode && sameItem && sameValidator;
+    boolean sameSpecificator = sameNode || this.descriptor == other.descriptor ||
+      (this.descriptor != null && this.descriptor.equals(other.descriptor));
+    return !sameNode && sameItem && sameValidator && sameSpecificator;
   }
 

trunk/src/core/net/sf/basedb/util/overview/Validator.java

@@ -468 +468 @@
       "Checks if the hardware attached to an item has a correct hardware type.",
       "Incorrect hardware type", Severity.WARNING
+    );
+  
+  /**
+    Validator rule that checks if the sub-array index on a raw bioassay
+    is between 1 and the number of sub-arrays on the hybridization.
+    Default severity level is WARNING.
+  */
+  public static final Validator INCORRECT_ARRAY_NUM = new Validator(
+      "misc.incorrectarraynum", "Incorrect sub-array index",
+      "Checks if the sub-array index on a raw bioassay " +
+      "is between 1 and the number of sub-arrays on the hybridization.",
+      "Incorrect sub-array index", Severity.WARNING
+    );
+
+  /**
+    Validator rule that checks if the same sub-array index is used
+    on more than one raw bioassay from the same hybridization. 
+    Default severity level is WARNING.
+  */
+  public static final Validator DUPLICATE_ARRAY_NUM = new Validator(
+      "misc.duplicatearraynum", "Duplicate sub-array index",
+      "Checks if the same sub-array index is used on more " +
+      "than one raw bioassay from the same hybridization.",
+      "Duplicate sub-array index", Severity.WARNING
     );