Changeset 2140

Timestamp:

Nov 18, 2013, 11:46:46 AM (10 years ago)

Author:

Nicklas Nordborg

Message:

References #527: Implement manual pooled library selection

Re-factored the volume calculations. There are some additional cases that could not happen before that must be considered. One example is that libraries may have lower remaining quantity than 5 or 10 µl which may result that there is not enough material even if the molarity is higher than 2.0nM.

For all calculations to be reproducable when generating the protocol we need to store both the target molarity and target volume on the pool so PoolTargetMolarity has been added as an annotation.

Location:

extensions/net.sf.basedb.reggie/trunk

Files:

• resources/libprep/create_manual_pool.jsp (modified) (13 diffs)
• resources/libprep/create_pools.jsp (modified) (12 diffs)
• resources/libprep/pool_protocol2.jsp (modified) (9 diffs)
• resources/libprep/pools.js (modified) (2 diffs)
• src/net/sf/basedb/reggie/dao/Annotationtype.java (modified) (1 diff)
• src/net/sf/basedb/reggie/servlet/InstallServlet.java (modified) (2 diffs)
• src/net/sf/basedb/reggie/servlet/PoolServlet.java (modified) (8 diffs)

extensions/net.sf.basedb.reggie/trunk/resources/libprep/create_manual_pool.jsp

@@ -31 +31 @@
 
 <script language="JavaScript">
-var debug = 1;
+var debug = 0;
 var currentStep = 1;
 
 var selectedLibraries = [];
 var targetVolumePerLibIsValid = false;
+var poolInfo;
 
 // Loaded from servlet when getting Library information
@@ -264 +265 @@
 
 
-function calculateRemarks(lib, duplicateBarcodes)
+function calculateRemarks(lib, mixingStrategy, duplicateBarcodes)
 {
   var remarks = [];
@@ -276 +277 @@
     }
     
-    if (lib.volume > lib.maxVolume)
-    {
-      remarks[remarks.length] = 'Low molarity';
-    }
-
+    if (lib.volume != lib.actualVolume)
+    {
+      if (lib.volume > lib.remainingVolume)
+      {
+        remarks[remarks.length] = 'Low quantity';
+      }
+      else 
+      {
+        remarks[remarks.length] = 'Low molarity';
+      }
+      if (mixingStrategy == 'fixed')
+      {
+        remarks[remarks.length] = 'Mix <span class="volume">'+Numbers.formatNumber(lib.actualVolume, 1) + '</span>+<span class="eb">' + Numbers.formatNumber(lib.actualEb, 1)+'µl</span>';
+      }
+      else
+      {
+        remarks[remarks.length] = 'Use <span class="volume">'+Numbers.formatNumber(lib.actualVolume, 1) + 'µl</span>';
+      }
+    }
+    
     if (lib.speedVacConc != null)
     {
@@ -286 +302 @@
     }
     
-    if (lib.mixFactor > 1.001)
+    if (lib.mixFactor > 1)
     {
       // Larger mix than default
@@ -344 +360 @@
       }
       PoolMix.calculateLibVolume(lib, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
+      PoolMix.calculateEbVolume(lib, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
     }
   }
     
-  // Calculate EB
-  PoolMix.calculateEbForLibs(libs, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
-  
   // Calculate final pool volumes, molarity, etc.
-  var poolInfo = PoolMix.calculateFinalPoolInfo(libs, mixingStrategy);
+  poolInfo = PoolMix.calculateFinalPoolInfo(libs, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
   
   // Make remarks for each lib
@@ -371 +385 @@
         lib.hasError = false;
       }
-      if (lib.volume > lib.maxVolume)
+      if (lib.volume != lib.actualVolume)
       {
         mark = '*';
@@ -380 +394 @@
         Main.removeClass(tr, 'warning');
       }
-      setInnerHTML('lib.'+lib.id+'.volume', lib.mixFactor > 1 ? '-' : Numbers.formatNumber(lib.volume*lib.mixFactor, 1)+mark);
+      setInnerHTML('lib.'+lib.id+'.volume', lib.mixFactor > 1 ? '-' : Numbers.formatNumber(lib.volume, 1)+mark);
       if (mixingStrategy == 'fixed' && lib.mixFactor < 1.001)
       {
-        setInnerHTML('lib.'+lib.id+'.eb', Numbers.formatNumber(lib.eb*lib.mixFactor, 1));
+        setInnerHTML('lib.'+lib.id+'.eb', Numbers.formatNumber(lib.eb, 1));
       }
       else
@@ -391 +405 @@
     }
     
-    calculateRemarks(lib, duplicateBarcodes);
+    calculateRemarks(lib, mixingStrategy, duplicateBarcodes);
     setInnerHTML('lib.'+lib.id+'.remarks', lib.remarks.join('; '));
   }
   
   var warnMsg = null;
-  if (poolInfo.eb < 0) 
+  if (poolInfo.ebVolumeExtra < 0) 
   {
     warnMsg = 'Too many libs with low molarity';
   }
   
-  setInnerHTML('pool.eb', Numbers.formatNumber(poolInfo.ebFinalMix, 1));
+  setInnerHTML('pool.eb', Numbers.formatNumber(poolInfo.ebVolumeExtra, 1));
 
   var poolDiv = document.getElementById('pool-summary');
@@ -411 +425 @@
   if (mixingStrategy == 'dynamic')
   {
-    poolData += ' • <span class="eb">'+Numbers.formatNumber(poolInfo.ebFinalMix, 1, 'µl')+'</span>';
+    poolData += ' • <span class="eb">'+Numbers.formatNumber(Math.max(0, poolInfo.ebVolumeExtra), 1, 'µl')+'</span>';
   }
   if (warnMsg)
@@ -423 +437 @@
     setInnerHTML('pool.remarks', '');
   }
+  
   poolData += '</div>';
   poolDiv.innerHTML = poolData;
@@ -460 +475 @@
   var frm = document.forms['reggie'];
   submitInfo.targetVolumeInPoolPerLib = parseFloat(frm.target_volume.value);
+  submitInfo.targetPoolMolarity = TARGET_MOLARITY_IN_POOL;
   submitInfo.mixingStrategy = Forms.getCheckedRadio(frm.mixing_strategy).value;
   
-  var poolInfo = {};
-  poolInfo.name = frm.poolName.value;
-  poolInfo.comment = frm.poolComments.value;
-  poolInfo.libs = [];
-  poolInfo.excluded = [];
+  var pool = {};
+  pool.name = frm.poolName.value;
+  pool.comment = frm.poolComments.value;
+  pool.ebVolumeExtra = Math.max(0, poolInfo.ebVolumeExtra);
+  pool.libs = [];
+  pool.excluded = [];
   
   for (var libNo = 0; libNo < selectedLibraries.length; libNo++)
@@ -479 +496 @@
       tmp.id = lib.id;
       tmp.name = lib.name;
-      tmp.volume = Math.min(lib.volume, lib.maxVolume); // Never submit more than max volume
-      tmp.eb = Math.max(0, lib.eb); // Never submit negative EB volumes!
+      tmp.volume = lib.actualVolume;
+      tmp.eb = lib.actualEb;
       tmp.mixFactor = lib.mixFactor;
       tmp.comment = lib.comment;
-      poolInfo.libs[poolInfo.libs.length] = tmp;
-    }
-  }
-  submitInfo.pools[submitInfo.pools.length] = poolInfo;
+      pool.libs[pool.libs.length] = tmp;
+    }
+  }
+  submitInfo.pools[submitInfo.pools.length] = pool;
   
   Main.addClass(document.getElementById('step.1.section'), 'disabled');
@@ -848 +865 @@
       </table>
       <div style="margin: 1em; font-style: italic;">
-      * Low molarity = The concentration of this library too low to mix to target molarity for the pool.
+      * Low quantity = The remaining quantity of this library too low to mix to target molarity for the pool.
       </div>
       </div>

extensions/net.sf.basedb.reggie/trunk/resources/libprep/create_pools.jsp

@@ -37 +37 @@
 
 var targetVolumePerLibIsValid = false;
+var POOL_DATA = [];
 
 // Loaded from servlet when getting Library information
@@ -139 +140 @@
   var frm = document.forms['reggie'];
   submitInfo.targetVolumeInPoolPerLib = parseFloat(frm.target_volume.value);
+  submitInfo.targetPoolMolarity = TARGET_MOLARITY_IN_POOL;
   submitInfo.mixingStrategy = Forms.getCheckedRadio(frm.mixing_strategy).value;
 
@@ -149 +151 @@
     poolInfo.name = POOL_NAMES[poolNo];
     poolInfo.comment = frm['comment.'+poolNo].value;
+    poolInfo.ebVolumeExtra = POOL_DATA[poolNo].ebVolumeExtra;
     poolInfo.libs = [];
     poolInfo.excluded = [];
@@ -161 +164 @@
         tmp.id = lib.id;
         tmp.name = lib.name;
-        tmp.volume = Math.min(lib.volume, lib.maxVolume); // Never submit more than max volume
-        tmp.eb = Math.max(0, lib.eb); // Never submit negative EB volumes!
+        tmp.volume = lib.actualVolume; 
+        tmp.eb = lib.actualEb;
         tmp.mixFactor = lib.mixFactor;
         tmp.comment = lib.comment;
@@ -359 +362 @@
       {
         PoolMix.calculateLibVolume(lib, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
+        PoolMix.calculateEbVolume(lib, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
       }
     }
@@ -387 +391 @@
   if (lib.molarity != null)
   {
-    if (lib.volume > lib.maxVolume)
-    {
-      remarks[remarks.length] = 'Low molarity';
+    if (lib.volume != lib.actualVolume)
+    {
+      if (lib.volume > lib.remainingVolume)
+      {
+        remarks[remarks.length] = 'Low quantity';
+      }
+      else 
+      {
+        remarks[remarks.length] = 'Low molarity';
+      }
     }
 
@@ -397 +408 @@
     }
     
-    if (lib.mixFactor > 1.001)
+    if (lib.mixFactor > 1)
     {
       // Larger mix than default
-      remarks[remarks.length] = 'Use ' + Numbers.formatNumber(lib.volume+lib.eb, 1, 'µl') + ' in pool';
+      remarks[remarks.length] = 'Use ' + Numbers.formatNumber(lib.actualVolume+lib.actualEb, 1, 'µl') + ' in pool';
     }
     
@@ -435 +446 @@
     }
     
-    // Calculate EB
-    PoolMix.calculateEbForLibs(libs, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
-    
     // Calculate final pool volumes, molarity, etc.
-    var poolInfo = PoolMix.calculateFinalPoolInfo(libs, mixingStrategy);
+    var poolInfo = PoolMix.calculateFinalPoolInfo(libs, TARGET_MOLARITY_IN_POOL, targetVolumePerLib, mixingStrategy);
+    POOL_DATA[poolNo] = poolInfo;
     
     // Make remarks for each lib
@@ -449 +458 @@
     
     var warnMsg = null;
-    if (poolInfo.eb < 0) 
+    if (poolInfo.ebVolumeExtra < 0) 
     {
       warnMsg = 'Too many libs with low molarity';
@@ -461 +470 @@
     if (mixingStrategy == 'dynamic')
     {
-      poolData += ' • <span class="pool-eb">'+Numbers.formatNumber(poolInfo.ebFinalMix, 1, 'µl')+'</span>';
+      poolData += ' • <span class="pool-eb">'+Numbers.formatNumber(poolInfo.ebVolumeExtra, 1, 'µl')+'</span>';
     }
     if (warnMsg)
@@ -517 +526 @@
         cls += ' flagged';
       }
-      if (!lib.flag && lib.volume > lib.maxVolume)
+      if (!lib.flag && lib.actualVolume < lib.volume)
       {
         cls += ' low-volume';
@@ -549 +558 @@
       if (!lib.excludeFromPool)
       {
-        mark = (lib.volume > lib.maxVolume) ? '*' : '';
+        mark = (lib.volume > lib.actualVolume) ? '*' : '';
         text += '<div>';
         text += '<span class="volume">'+(isFinite(lib.volume) ? Numbers.formatNumber(lib.volume*mixFactor, 1, 'µl'+mark) : '∞')+'</span>';
-        if (painter.mixingStrategy == 'fixed' || lib.mixFactor > 1.001)
+        if (painter.mixingStrategy == 'fixed' || lib.mixFactor > 1)
         {
           text += '<span class="eb">'+(isFinite(lib.eb) ? Numbers.formatNumber(lib.eb*mixFactor, 1, 'µl') : '-∞')+'</span>';

extensions/net.sf.basedb.reggie/trunk/resources/libprep/pool_protocol2.jsp

@@ -154 +154 @@
       // Calculate some pool quantities
       pool.volume = 1000 * pool.originalQuantity / pool.conc;
-      
-      PoolMix.calculateEbForLibs(pool.libraries, pool.molarity, pool.targetVolumePerLib, pool.mixingStrategy);
-      pool.extra = PoolMix.calculateFinalPoolInfo(pool.libraries, pool.mixingStrategy);
-
-      for (var j = 0; j < pool.libraries.length; j++)
-      {
-        checkAndPreProcessLibrary(pool.libraries[j], pool, POOL_CURRENT_SCHEMA, POOL_CURRENT_BARCODE_VARIANT, '<%=view%>');       
-      }
-      
+
+      for (var libNo = 0; libNo < pool.libraries.length; libNo++)
+      {
+        var lib = pool.libraries[libNo];
+        PoolMix.calculateLibVolumeForProtocol(lib, pool.targetPoolMolarity, pool.targetVolumePerLib, pool.mixingStrategy, true);
+        PoolMix.calculateEbVolume(lib, pool.targetPoolMolarity, pool.targetVolumePerLib, pool.mixingStrategy);
+        checkAndPreProcessLibrary(lib, pool, POOL_CURRENT_SCHEMA, POOL_CURRENT_BARCODE_VARIANT, '<%=view%>');       
+      }
+
+      pool.extra = PoolMix.calculateFinalPoolInfo(pool.libraries, pool.targetPoolMolarity, pool.targetVolumePerLib, pool.mixingStrategy);
     }
     
@@ -213 +214 @@
       }
   
-      if (lib.mixFactor > 1.001)
+      if (lib.mixFactor > 1)
       {
         // Larger mix than default
         if (view != 'plate')
         {
-          remarks[remarks.length] = '<span class="mix-remark">Mix <span class="volume">'+Numbers.formatNumber(lib.volume*lib.mixFactor, 1) + '</span>+<span class="eb">' + Numbers.formatNumber(lib.eb*lib.mixFactor, 1)+'µl</span></span>';
-        }
-        remarks[remarks.length] = 'Use <b>' + Numbers.formatNumber(lib.volume+lib.eb, 1) + 'µl</b> in pool';
+          remarks[remarks.length] = '<span class="mix-remark">Mix <span class="volume">'+Numbers.formatNumber(lib.actualVolume*lib.mixFactor, 1) + '</span>+<span class="eb">' + Numbers.formatNumber(lib.actualEb*lib.mixFactor, 1)+'µl</span></span>';
+        }
+        remarks[remarks.length] = 'Use <b>' + Numbers.formatNumber(lib.actualVolume+lib.actualEb, 1) + 'µl</b> in pool';
       }
 
@@ -261 +262 @@
         var well = lib.bioWell;
         
+        var tr = document.createElement('tr');
         if (POOL_CURRENT_SCHEMA)
         {
           wellIndex = createMissingRows(tbody, wellsInPool, wellIndex, well, barcodeVariant);
-        }
-        
-        var tr = document.createElement('tr');
-        tr.className = well.column % 2 == 0 ? "evencol" : "oddcol";
+          tr.className = well.column % 2 == 0 ? "evencol" : "oddcol";
+        }
+        else
+        {
+          tr.className = 'evencol';
+        }
     
         if (barcodeVariant)
@@ -279 +283 @@
 
         addColumn(tr, 'lib', lib.name);
-        addColumn(tr, 'remain', Numbers.formatNumber((lib.remainingQuantity+lib.usedQuantity)*1000, 2));
+        addColumn(tr, 'remain', Numbers.formatNumber((lib.remainingVolume), 1));
         addColumn(tr, 'molarity', Numbers.formatNumber(lib.molarity, 2));
         <%
@@ -296 +300 @@
         %>
         var mixFactor = lib.mixFactor || 1.0;
-        addColumn(tr, 'volume', mixFactor > 1.0 ? '—' : Numbers.formatNumber(lib.volume*mixFactor, 1));
-        addColumn(tr, 'eb', pool.mixingStrategy == 'dynamic' || mixFactor > 1.001 ? '—' : Numbers.formatNumber(lib.eb*mixFactor, 1));
+        addColumn(tr, 'volume', mixFactor > 1.0 ? '—' : Numbers.formatNumber(lib.actualVolume, 1));
+        addColumn(tr, 'eb', pool.mixingStrategy == 'dynamic' || mixFactor > 1.0 ? '—' : Numbers.formatNumber(lib.actualEb, 1));
         addColumn(tr, "remarks", lib.remarks.join('; '));
         tbody.appendChild(tr);
@@ -312 +316 @@
       poolData += '</div>';
       setInnerHTML('molarity.'+pool.id, poolData);
-      setInnerHTML('eb-volume.'+pool.id, Numbers.formatNumber(pool.extra.ebFinalMix, 1));
+      setInnerHTML('eb-volume.'+pool.id, Numbers.formatNumber(Math.max(0, pool.extra.ebVolumeExtra), 1));
       Main.show('pool.'+pool.id);
     }
@@ -382 +386 @@
       if (pool.mixingStrategy == 'dynamic')
       {
-        poolData += ' • <span class="pool-eb">'+Numbers.formatNumber(pool.extra.ebFinalMix, 1, 'µl')+'</span>';
+        poolData += ' • <span class="pool-eb">'+Numbers.formatNumber(pool.extra.ebVolumeExtra, 1, 'µl')+'</span>';
       }
       poolData += '<div class="comments">'+pool.comments+'</div>';
@@ -418 +422 @@
         var i = name.indexOf('.m');
         text += '<div class="lib">'+name.substring(0, i)+'.<br>&nbsp;'+name.substring(i)+'</div>';
-        text += '<div><span class="volume">'+Numbers.formatNumber(lib.volume*mixFactor, 1)+'µl</span>';
+        text += '<div><span class="volume">'+Numbers.formatNumber(lib.actualVolume*mixFactor, 1)+'µl</span>';
         if (painter.mixingStrategy == 'fixed' || lib.mixFactor > 1.001)
         {
-          text += '<span class="eb">'+Numbers.formatNumber(lib.eb*mixFactor, 1)+'µl</span>';
+          text += '<span class="eb">'+Numbers.formatNumber(lib.actualEb*mixFactor, 1)+'µl</span>';
         }
         else
@@ -746 +750 @@
         <tr>
           <th class="lib">Library</th>
-          <th>(ng)</th>
+          <th>(µl)</th>
           <th>(nM)</th>
           <th class="workplate">plate</th>

extensions/net.sf.basedb.reggie/trunk/resources/libprep/pools.js

@@ -294 +294 @@
   
   /**
-    Calculate the volume of a lib to take for a pool given the
+    Checks if v1 is less than v2 within the given accuracy
+    Eg. v1+accuracy <= v2
+   */
+  pm.lessThan = function(v1, v2, accuracy)
+  {
+    return v1 + accuracy < v2;
+  }
+  
+  /**
+    Calculate the volume of a lib to use for a pool given the
     target molarity for the pool and average volume for each lib
-    in the pool. The volume is affect by two limits:
-    
-    1. It may not be lower than LIMIT_FOR_EXTRA_LARGE_MIX. In this case
-       a larger mix is made and only half is used.
-       
-    2. It may not be higher than AVAILABLE_VOLUME or AVAILABLE_VOLUME_AFTER_SPEEDVAC.
+    in the pool. This method calculates two different volumes:
+    
+    lib.volume = The theoretical volume needed to reach the same
+    amount of DNA as the target molarity and volume suggests
+    
+    lib.actualVolume: The actual volume that can be used due to
+    remaining quantity, lib molarity and mixing strategy
     
     The volume is rounded to one decimal in µl.
+    
   */
   pm.calculateLibVolume = function(lib, targetMolarity, targetVolume, mixingStrategy)
   {
-    var maxVolume = lib.remainingVolume;
-    if (mixingStrategy == 'fixed' && maxVolume > targetVolume)
-    {
-      maxVolume = targetVolume;
-    }
     var volume = pm.round(targetVolume * targetMolarity / lib.molarity);
     var mixFactor = 1;
-    if (volume < LIMIT_FOR_EXTRA_LARGE_MIX)
+    
+    if (pm.lessThan(volume, LIMIT_FOR_EXTRA_LARGE_MIX, 0.05))
     {
       mixFactor = 2;
@@ -322 +329 @@
     }
     
-    lib.maxVolume = maxVolume;
+    // This is the theoretical volume that should be used...
     lib.volume = volume;
+    lib.eb = null;
     lib.mixFactor = mixFactor;
-    lib.eb = null;
-    return volume;
-  }
-  
-  /**
-    Calculate the amount of EB to mix with each of the libs. If mixing
-    strategy is 'fixed' all libraries are mixed to the target volume,
-    otherwise a dynamic strategy that prioritize the final pool molarity
-    is used:
-    
-    1. The total amount of EB needed to achive the target molarity
-       in the pool is calculated. 
-       
-    2. Libs with a mixFactor > 1 are always mixed to the given target 
-       molarity since the saved lib should be standardized
-       
-    3. The remaining EB volume is equally split among the rest of the
-       libs. To avoid rounding errors for the pool as a total the
-       volume is rounded down and then any remaining EB is added to
-       the last lib.
-  */
-  pm.calculateEbForLibs = function(libs, targetMolarity, targetVolume, mixingStrategy)
-  {
-    if (mixingStrategy == 'fixed')
-    {
-      // Fixed strategy
-      // All libs are mixed with EB to target volume
-      for (var libNo = 0; libNo < libs.length; libNo++)
-      {
-        var lib = libs[libNo];
-        lib.eb = targetVolume - lib.volume;
-      }
+      
+    // However, reality has limitations due to remaining volume, mixing strategy, etc.
+    // Check what volume that can actually be used
+    if (mixingStrategy == 'fixed' || lib.mixFactor > 1)
+    {
+      // Do not use more than target volume or remaining volume
+      volume = Math.min(volume, targetVolume, lib.remainingVolume);
     }
     else
     {
-      // Dynamic strategy
-      // First, calculate total volume of all libs 
-      // and their contribution to the total amount of DNA in the pool
-      var totalLibVolume = 0;
-      var totalLibAmount = 0;
-      var fixedEbVolume = 0;
-      var fixedLibs = 0;
-      for (var libNo = 0; libNo < libs.length; libNo++)
-      {
-        var lib = libs[libNo];
-        var vol = lib.maxVolume < lib.volume ? lib.maxVolume : lib.volume;
-        totalLibVolume += vol;
-        totalLibAmount += vol * lib.molarity;
-        
-        // Always mix to target molarity when doing extra large mix
-        if (lib.mixFactor > 1)
-        {
-          var eb = targetVolume - lib.volume;
-          fixedEbVolume += eb;
-          lib.eb = eb;
-          fixedLibs++;
-        }
-      }
-
-      
-      // Calculate the total volume needed to get to the
-      // target molarity for the pooled libs
-      // Round all summarized values to avoid precision problems (eg. 4.0 --> 3.999999998)
-      var totalPoolVolume = pm.round(totalLibAmount / targetMolarity);
-      totalLibVolume = pm.round(totalLibVolume);
-      fixedEbVolume = pm.round(fixedEbVolume);
-      var totalEbVolume = pm.round(totalPoolVolume - totalLibVolume - fixedEbVolume);
-
-      // Divide EB volume among the libs (rounded to 1 decimal)
-      var ebPerLib = pm.floor(totalEbVolume / (libs.length - fixedLibs), 1);
-      var usedEb = 0;
-      var adjustableLib;
-      for (var libNo = 0; libNo < libs.length; libNo++)
-      {
-        var lib = libs[libNo];
-        if (!lib.mixFactor || lib.mixFactor == 1)
-        {
-          lib.eb = ebPerLib;
-          usedEb += ebPerLib;
-          adjustableLib = lib;
-        }
-      }
-      
-      usedEb = pm.round(usedEb);
-      
-      // If the used EB doesn't add up to the total amount needed (due to rounding)
-      // add the extra amount to the last lib
-      if (Math.abs(totalEbVolume - usedEb) >= 0.05 && adjustableLib)
-      {
-        adjustableLib.eb += totalEbVolume - usedEb;
-      }
-    }
-    
-  }
-  
-  pm.calculateFinalPoolInfo = function(libs, mixingStrategy)
-  {
-    var info = {};
-    
+      volume = Math.min(volume, lib.remainingVolume);
+    }
+    lib.actualVolume = volume;      
+  }
+  
+  /**
+    Same as above method except that we already know the mixFactor and actualVolume of
+    the lib since that has already been saved to the database.
+  */
+  pm.calculateLibVolumeForProtocol = function(lib, targetMolarity, targetVolume, mixingStrategy)
+  {
+    if (lib.mixFactor > 1)
+    {
+      lib.volume = pm.ceil(lib.mixFactor * targetVolume * targetMolarity / lib.molarity) / lib.mixFactor;
+    }
+    else
+    {
+      lib.volume = pm.round(targetVolume * targetMolarity / lib.molarity);
+    }
+  }
+
+  
+  /**
+    Calculate the volume of EB to mix with a lib.
+    
+    The volume is rounded to one decimal in µl.
+  */
+  pm.calculateEbVolume = function(lib, targetMolarity, targetVolume, mixingStrategy)
+  {
+    var eb = 0;
+    if (mixingStrategy == 'fixed' || lib.mixFactor > 1)
+    {
+      eb = targetVolume - lib.volume;
+    }
+    
+    // This is the theoretical volume that should be used...
+    lib.eb = eb;
+    
+    // However, reality has limitations due to remaining volume, mixing strategy, etc.
+    // Check what volume that can actually be used
+    if (mixingStrategy == 'fixed' || lib.mixFactor > 1)
+    {
+      if (pm.lessThan(lib.molarity, targetMolarity, 0.01))
+      {
+        // Do not dilute if molarity is lower than target molarity
+        eb = 0;
+      }
+      else if (pm.lessThan(lib.actualVolume, lib.volume, 0.05))
+      {
+        // Reduce EB by the same factor as we have to reduce the volume
+        // so the final molarity is still 
+        eb = pm.round(eb * lib.actualVolume / lib.volume);
+      }
+    }   
+    lib.actualEb = eb;
+  }
+
+  
+  
+  /**
+    Summarize information for the pool. This will calculate the following and
+    return as an object:
+    
+    libVolume: Total volume of libs in the pool (µl)
+    libAmount: Total amount of libs in the pool (nano-mol)
+    ebVolumeFromLibs: Total EB volume from mixed directly with libs
+    ebVolumeExtra: Extra EB to add to the pool (dynamic mixing)
+    molarity: The final pool molarity after mixing everything
+  */
+  pm.calculateFinalPoolInfo = function(libs, targetMolarity, targetVolume, mixingStrategy)
+  {
     var libVolume = 0;
     var libAmount = 0;
-    var ebVolume = 0;
-    var ebFinalMix = 0;
+    var ebVolumeFromLibs = 0;
+    
     for (var libNo = 0; libNo < libs.length; libNo++)
     {
       var lib = libs[libNo];
-      var vol = lib.maxVolume < lib.volume ? lib.maxVolume : lib.volume;
-      libVolume += vol;
-      ebVolume += lib.eb;
-      if (mixingStrategy == 'dynamic' && (!lib.mixFactor || lib.mixFactor == 1)) 
-      {
-        ebFinalMix += lib.eb;
-      }
-      libAmount += vol * lib.molarity;
-    }
-    
-    info.volume = libVolume;
-    info.amount = libAmount;
-    info.eb = ebVolume;
-    info.ebFinalMix = ebFinalMix;
-    if (ebVolume < 0)
-    {
-      info.totalVolume = libVolume;
+      
+      var volume = lib.actualVolume;
+      var eb = lib.actualEb;
+
+      libVolume += volume;
+      ebVolumeFromLibs += eb;
+      libAmount += volume * lib.molarity;
+    }
+    
+    var info = {};
+    info.libVolume = libVolume;
+    info.libAmount = libAmount;
+    info.ebVolumeFromLibs = ebVolumeFromLibs;
+    
+    // Calculate extra EB and total pool volume
+    if (mixingStrategy == 'dynamic')
+    {
+      // Use the target molarity to calculate the total volume
+      var targetVolume = pm.round(libAmount / targetMolarity);
+      info.ebVolumeExtra = pm.round(targetVolume - info.libVolume - info.ebVolumeFromLibs);
+      if (info.ebVolumeExtra < 0)
+      {
+        info.totalVolume = info.libVolume + info.ebVolumeFromLibs;
+      }
+      else
+      {
+        info.totalVolume = targetVolume;
+      }
     }
     else
     {
-      info.totalVolume = libVolume + ebVolume;
-    }
-    info.molarity = libAmount / info.totalVolume;
-    
+      // No extra EB
+      info.ebVolumeExtra = 0;
+      info.totalVolume = info.libVolume + info.ebVolumeFromLibs;
+    }
+    // Calcualate the final molarity (which may be different that target due to rounding)
+    info.molarity = info.libAmount / info.totalVolume;
+
     return info;
   }

extensions/net.sf.basedb.reggie/trunk/src/net/sf/basedb/reggie/dao/Annotationtype.java

@@ -595 +595 @@
   public static final Annotationtype POOL_TARGET_VOLUME_PER_LIB =
     new Annotationtype("PoolTargetVolumePerLib", Type.FLOAT, Item.EXTRACT);
+
+  /**
+    The "PoolTargetMolarity" annotation, used for extracts (PooledLibrary).
+    Store the admin-defined setting for target molarity used when designing
+    the pool. The actual molarity may different due to limitations implied by
+    library concentration and rounding.
+    @since 2.14
+  */
+  public static final Annotationtype POOL_TARGET_MOLARITY =
+    new Annotationtype("PoolTargetMolarity", Type.FLOAT, Item.EXTRACT);
   
   /**

extensions/net.sf.basedb.reggie/trunk/src/net/sf/basedb/reggie/servlet/InstallServlet.java

@@ -277 +277 @@
         jsonChecks.add(checkAnnotationType(dc, Annotationtype.POOL_MOLARITY, 1, null, effectiveOptions, createIfMissing));
         jsonChecks.add(checkAnnotationType(dc, Annotationtype.POOL_TARGET_VOLUME_PER_LIB, 1, null, effectiveOptions, createIfMissing));
+        jsonChecks.add(checkAnnotationType(dc, Annotationtype.POOL_TARGET_MOLARITY, 1, null, effectiveOptions, createIfMissing));
         jsonChecks.add(checkAnnotationType(dc, Annotationtype.POOL_MIXING_STRATEGY, 1, 
             new ValueOptions(PooledLibrary.MIXING_STRATEGY_FIXED, PooledLibrary.MIXING_STRATEGY_DYNAMIC),
@@ -383 +384 @@
         jsonChecks.add(checkAnnotationTypeCategory(dc, Subtype.POOLED_LIBRARY, createIfMissing,
             Annotationtype.POOL_MOLARITY, Annotationtype.POOL_CONC, Annotationtype.POOL_TARGET_VOLUME_PER_LIB,
+            Annotationtype.POOL_TARGET_MOLARITY,
             Annotationtype.POOL_MIXING_STRATEGY, Annotationtype.POOL_DATE, Annotationtype.OPERATOR,
             Annotationtype.FLAG, Annotationtype.AUTO_PROCESSING));

extensions/net.sf.basedb.reggie/trunk/src/net/sf/basedb/reggie/servlet/PoolServlet.java

@@ -316 +316 @@
           if (targetVolumePerLib == null) targetVolumePerLib = DEFAULT_TARGET_VOLUME_IN_POOL_PER_LIB;
           pool.setAnnotation("targetVolumePerLib", targetVolumePerLib);
+          Float targetPoolMolarity = (Float)Annotationtype.POOL_TARGET_MOLARITY.getAnnotationValue(dc, pool.getExtract());
+          if (targetPoolMolarity == null) targetPoolMolarity = TARGET_MOLARITY_IN_POOL;
+          pool.setAnnotation("targetPoolMolarity", targetPoolMolarity);
           String mixingStrategy = (String)Annotationtype.POOL_MIXING_STRATEGY.getAnnotationValue(dc, pool.getExtract());
           if (mixingStrategy == null) mixingStrategy = PooledLibrary.MIXING_STRATEGY_FIXED;
@@ -326 +329 @@
         
         JSONObject poolInfo = new JSONObject();
-        poolInfo.put("targetMolarity", TARGET_MOLARITY_IN_POOL);
         poolInfo.put("extraLargeMixFactor", EXTRA_LARGE_MIX_FACTOR);
         poolInfo.put("limitForExtraLargeMix", LIMIT_FOR_EXTRA_LARGE_MIX);
@@ -374 +376 @@
         JSONArray jsonFlagged = (JSONArray)jsonReq.get("flagged");
         Number targetVolumeInPoolPerLib = (Number)jsonReq.get("targetVolumeInPoolPerLib");
+        Number targetPoolMolarity = (Number)jsonReq.get("targetPoolMolarity");
         String mixingStrategy = (String)jsonReq.get("mixingStrategy");
         
@@ -394 +397 @@
           pool.setDescription((String)jsonPool.get("comment"));
           Annotationtype.POOL_TARGET_VOLUME_PER_LIB.setAnnotationValue(dc, pool, targetVolumeInPoolPerLib.floatValue());
+          Annotationtype.POOL_TARGET_MOLARITY.setAnnotationValue(dc, pool, targetPoolMolarity.floatValue());
           Annotationtype.POOL_MIXING_STRATEGY.setAnnotationValue(dc, pool, mixingStrategy);
           
@@ -399 +403 @@
           
           // Total pool quantities
-          float poolVolume = 0f;  // volume in pool (µl)
+          float poolVolume = ((Number)jsonPool.get("ebVolumeExtra")).floatValue();  // volume in pool (µl)
           float poolQuantity = 0f; // quantity of DNA in pool (µg)
           float poolAmount = 0f;  // Amount of DNA in pool (nano-mole)
@@ -633 +637 @@
     // Load remaining quantity of the lib
     Float remain = libEx.getRemainingQuantity();
-    lib.setAnnotation("remainingQuantity", remain);
-    if (remain != null && (originalConc != null || speedVacConc != null))
-    {
-      // Remaining volume in µl
-      Float conc = speedVacConc == null ? originalConc : speedVacConc;
-      lib.setAnnotation("remainingVolume", 1000 * remain / conc);
-    }
 
     if (pool != null)
@@ -649 +646 @@
       Float usedVolumeForMix = 1000 * usedQuantity / usedConc;
       
-      lib.setAnnotation("volume", usedVolumeForMix);
+      // Add the used quantity back since we want the remaining quantity *before* pooling
+      if (remain != null) remain += usedQuantity; 
+      
+      // The actual volume used when pooling
+      lib.setAnnotation("actualVolume", usedVolumeForMix);
       
       // Check if '.dil' exists   
@@ -661 +662 @@
         Extract dil = result.get(0);
         Float dilQuantity = dil.getOriginalQuantity();
-        //Float dilConc = (Float)Annotationtype.POOL_CONC.getAnnotationValue(dc, dil);
         lib.setAnnotation("mixFactor", (dilQuantity + usedQuantity) / usedQuantity);
       }
       
       lib.setAnnotation("dils", result.size());
+    }
+    
+    lib.setAnnotation("remainingQuantity", remain);
+    if (remain != null && (originalConc != null || speedVacConc != null))
+    {
+      // Remaining volume in µl
+      Float conc = speedVacConc == null ? originalConc : speedVacConc;
+      lib.setAnnotation("remainingVolume", 1000 * remain / conc);
     }
   }