778 lines
29 KiB
Rust
778 lines
29 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
|
|
use regex::Regex;
|
|
|
|
use super::plate::Plate;
|
|
use crate::plate::PlateType;
|
|
use crate::util;
|
|
use crate::Well;
|
|
|
|
use std::fmt;
|
|
use std::sync::LazyLock;
|
|
|
|
#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
|
|
pub struct CustomRegion {
|
|
src: Vec<Well>,
|
|
dest: Vec<Well>,
|
|
}
|
|
|
|
impl CustomRegion {
|
|
pub fn new(src: Vec<Well>, dest: Vec<Well>) -> Self {
|
|
CustomRegion { src, dest }
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
|
|
pub enum Region {
|
|
Rect(Well, Well),
|
|
Point(Well),
|
|
Custom(CustomRegion),
|
|
}
|
|
impl Default for Region {
|
|
fn default() -> Self {
|
|
Region::Point(Well { row: 1, col: 1 })
|
|
}
|
|
}
|
|
impl Display for Region {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Region::Rect(ul, br) => {
|
|
write!(
|
|
f,
|
|
"{}{}:{}{}",
|
|
util::num_to_letters(ul.col).unwrap(),
|
|
ul.row,
|
|
util::num_to_letters(br.col).unwrap(),
|
|
br.row
|
|
)
|
|
}
|
|
Region::Point(w) => {
|
|
write!(f, "{}{}", util::num_to_letters(w.col).unwrap(), w.row)
|
|
}
|
|
Region::Custom(..) => {
|
|
write!(f, "Custom Region")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl TryFrom<Region> for (Well, Well) {
|
|
type Error = &'static str;
|
|
fn try_from(region: Region) -> Result<Self, Self::Error> {
|
|
if let Region::Rect(c1, c2) = region {
|
|
Ok((c1, c2))
|
|
} else {
|
|
// Should consider returning a degenerate rectangle here instead
|
|
Err("Cannot convert this region to a rectangle, it was a point.")
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Region {
|
|
pub fn new_custom(transfers: &Vec<(Well, Well)>) -> Self {
|
|
let mut src_pts: Vec<Well> = Vec::with_capacity(transfers.len());
|
|
let mut dest_pts: Vec<Well> = Vec::with_capacity(transfers.len());
|
|
|
|
for transfer in transfers {
|
|
src_pts.push(transfer.0);
|
|
dest_pts.push(transfer.1);
|
|
}
|
|
|
|
Region::Custom(CustomRegion {
|
|
src: src_pts,
|
|
dest: dest_pts,
|
|
})
|
|
}
|
|
|
|
pub fn new_from_wells(w1: Well, w2: Option<Well>) -> Self {
|
|
if w2.is_none() {
|
|
Self::Point(w1)
|
|
} else {
|
|
let w2 = w2.unwrap();
|
|
let (w1, w2) = standardize_rectangle(&w1, &w2);
|
|
Self::Rect(w1, w2)
|
|
}
|
|
}
|
|
|
|
pub fn try_parse_str(input: &str) -> Option<Self> {
|
|
static POINT_REGEX: LazyLock<Regex> =
|
|
LazyLock::new(|| Regex::new(r"([A-Z,a-z]+)(\d+)").unwrap());
|
|
static RECT_REGEX: LazyLock<Regex> =
|
|
LazyLock::new(|| Regex::new(r"([A-Z,a-z]+)(\d+):([A-Z,a-z]+)(\d+)").unwrap());
|
|
|
|
log::info!("{:?}", input);
|
|
if let Some(captures) = RECT_REGEX.captures(input) {
|
|
if let (Some(row1), Some(col1), Some(row2), Some(col2)) = (
|
|
crate::util::letters_to_num(&captures[1]),
|
|
captures[2].parse::<u8>().ok(),
|
|
crate::util::letters_to_num(&captures[3]),
|
|
captures[4].parse::<u8>().ok(),
|
|
) {
|
|
return Some(Region::Rect(
|
|
Well {
|
|
row: row1,
|
|
col: col1,
|
|
},
|
|
Well {
|
|
row: row2,
|
|
col: col2,
|
|
},
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
} else if let Some(captures) = POINT_REGEX.captures(input) {
|
|
if let (Some(row), Some(col)) = (
|
|
crate::util::letters_to_num(&captures[1]),
|
|
captures[2].parse::<u8>().ok(),
|
|
) {
|
|
return Some(Region::Point(Well { row, col }));
|
|
} else {
|
|
return None;
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
pub fn contains_well(&self, w: &Well, pt: Option<PlateType>) -> bool {
|
|
match self {
|
|
Self::Point(x) => x == w,
|
|
Self::Rect(ul, br) => {
|
|
w.row <= br.row && w.row >= ul.row && w.col <= br.col && w.col >= ul.col
|
|
}
|
|
Self::Custom(xs) => match pt {
|
|
Some(PlateType::Source) => xs.src.contains(w),
|
|
Some(PlateType::Destination) => xs.dest.contains(w),
|
|
None => {
|
|
unreachable!("Cannot check if custom contains well without knowing the type")
|
|
}
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Clone, Serialize, Deserialize, Debug, Hash)]
|
|
pub struct TransferRegion {
|
|
pub source_plate: Plate,
|
|
pub source_region: Region, // Even if it is just a point, we don't want corners.
|
|
pub dest_plate: Plate,
|
|
pub dest_region: Region,
|
|
pub interleave_source: (i8, i8),
|
|
pub interleave_dest: (i8, i8),
|
|
}
|
|
|
|
impl Default for TransferRegion {
|
|
fn default() -> Self {
|
|
TransferRegion {
|
|
source_plate: Plate::default(),
|
|
source_region: Region::default(),
|
|
dest_plate: Plate::default(),
|
|
dest_region: Region::default(),
|
|
interleave_source: (1, 1),
|
|
interleave_dest: (1, 1),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TransferRegion {
|
|
pub fn get_source_wells(&self) -> Vec<Well> {
|
|
match &self.source_region {
|
|
Region::Rect(c1, c2) => {
|
|
let mut wells = Vec::<Well>::new();
|
|
let (ul, br) = standardize_rectangle(c1, c2);
|
|
let (interleave_i, interleave_j) = self.interleave_source;
|
|
// NOTE: This will panic if either is 0!
|
|
// We'll reassign these values (still not mutable) just in case.
|
|
// This behaviour shouldn't be replicated for destination wells
|
|
// because a zero step permits pooling.
|
|
let (interleave_i, interleave_j) =
|
|
(i8::max(interleave_i, 1), i8::max(interleave_j, 1));
|
|
|
|
for i in (ul.row..=br.row).step_by(i8::abs(interleave_i) as usize) {
|
|
for j in (ul.col..=br.col).step_by(i8::abs(interleave_j) as usize) {
|
|
// NOTE: It looks like we're ignoring negative interleaves,
|
|
// because it wouldn't make a difference here---the same
|
|
// wells will still be involved in the transfer.
|
|
wells.push(Well { row: i, col: j })
|
|
}
|
|
}
|
|
wells
|
|
}
|
|
Region::Point(p) => vec![*p],
|
|
Region::Custom(c) => c.src.clone(),
|
|
}
|
|
}
|
|
|
|
pub fn get_destination_wells(&self) -> Vec<Well> {
|
|
match &self.source_region {
|
|
Region::Custom(c) => c.dest.clone(),
|
|
_ => {
|
|
let map = self.calculate_map();
|
|
let source_wells = self.get_source_wells();
|
|
|
|
let mut wells = Vec::<Well>::new();
|
|
|
|
for well in source_wells {
|
|
if let Some(mut dest_wells) = map(well) {
|
|
wells.append(&mut dest_wells);
|
|
}
|
|
}
|
|
|
|
wells
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::type_complexity)] // Resolving gives inherent associated type error
|
|
pub fn calculate_map(&self) -> Box<dyn Fn(Well) -> Option<Vec<Well>> + '_> {
|
|
// By validating first, we have a stronger guarantee that
|
|
// this function will not panic. :)
|
|
if let Err(msg) = self.validate() {
|
|
log::error!("{}\nThis transfer will be empty.", msg);
|
|
return Box::new(|_| None);
|
|
}
|
|
|
|
// log::debug!("What is ild? {:?}", self);
|
|
let source_wells = self.get_source_wells();
|
|
let il_dest = self.interleave_dest;
|
|
let il_source = self.interleave_source;
|
|
|
|
let source_corners: (Well, Well) = match self.source_region {
|
|
Region::Point(w) => (w, w),
|
|
Region::Rect(c1, c2) => (c1, c2),
|
|
Region::Custom(_) => (Well { row: 0, col: 0 }, Well { row: 0, col: 0 }),
|
|
};
|
|
let (source_ul, _) = standardize_rectangle(&source_corners.0, &source_corners.1);
|
|
// This map is not necessarily injective or surjective,
|
|
// but we will have these properties in certain cases.
|
|
// If the transfer is not a pooling transfer (interleave == 0)
|
|
// and simple then we *will* have injectivity.
|
|
|
|
// Non-replicate transfers:
|
|
match &self.dest_region {
|
|
Region::Point(dest_point) => {
|
|
// Breaking from form somewhat, we really should return an entirely different
|
|
// function if a point-dest can't fit the whole source.
|
|
// If the bottom-right well of the source won't fit in the dest,
|
|
// we can abort.
|
|
let source_bottom_right = match self.source_region {
|
|
Region::Point(x) => x,
|
|
Region::Rect(w1, w2) => standardize_rectangle(&w1, &w2).1,
|
|
Region::Custom(_) => unreachable!("A point destination region cannot be paired with a custom source destination?"),
|
|
};
|
|
let bottom_right_mapped = Self::point_destination_region_calc(
|
|
source_bottom_right,
|
|
source_ul,
|
|
il_source,
|
|
il_dest,
|
|
*dest_point,
|
|
);
|
|
if bottom_right_mapped.row > self.dest_plate.plate_format.rows()
|
|
|| bottom_right_mapped.col > self.dest_plate.plate_format.columns()
|
|
{
|
|
return Box::new(|_| None);
|
|
}
|
|
|
|
Box::new(move |input| {
|
|
if source_wells.contains(&input) {
|
|
// Validity here already checked by self.validate()
|
|
Some(vec![Self::point_destination_region_calc(
|
|
input,
|
|
source_ul,
|
|
il_source,
|
|
il_dest,
|
|
*dest_point,
|
|
)])
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
}
|
|
Region::Rect(c1, c2) => {
|
|
Box::new(move |w| {
|
|
let Well { row: i, col: j } = w;
|
|
if source_wells.contains(&w) {
|
|
let possible_destination_wells = create_dense_rectangle(c1, c2);
|
|
let (d_ul, d_br) = standardize_rectangle(c1, c2);
|
|
let (s_ul, s_br) =
|
|
standardize_rectangle(&source_corners.0, &source_corners.1);
|
|
let s_dims = (
|
|
s_br.row.checked_sub(s_ul.row).unwrap() + 1,
|
|
s_br.col.checked_sub(s_ul.col).unwrap() + 1,
|
|
);
|
|
let d_dims = (
|
|
d_br.row.checked_sub(d_ul.row).unwrap() + 1,
|
|
d_br.col.checked_sub(d_ul.col).unwrap() + 1,
|
|
);
|
|
let number_used_src_wells = (
|
|
// Number of used source wells
|
|
(s_dims.0 + il_source.0.unsigned_abs() - 1)
|
|
.div_euclid(il_source.0.unsigned_abs()),
|
|
(s_dims.1 + il_source.1.unsigned_abs() - 1)
|
|
.div_euclid(il_source.1.unsigned_abs()),
|
|
);
|
|
let count = (
|
|
// How many times can we replicate?
|
|
if il_dest.0.unsigned_abs() == 0 {
|
|
1
|
|
} else {
|
|
(1..)
|
|
.position(|n| {
|
|
(n * number_used_src_wells.0 * il_dest.0.unsigned_abs())
|
|
.saturating_sub(il_dest.0.unsigned_abs())
|
|
+ 1
|
|
> d_dims.0
|
|
})
|
|
.unwrap() as u8
|
|
},
|
|
if il_dest.1.unsigned_abs() == 0 {
|
|
1
|
|
} else {
|
|
(1..)
|
|
.position(|n| {
|
|
(n * number_used_src_wells.1 * il_dest.1.unsigned_abs())
|
|
.saturating_sub(il_dest.1.unsigned_abs())
|
|
+ 1
|
|
> d_dims.1
|
|
})
|
|
.unwrap() as u8
|
|
},
|
|
);
|
|
let i = i
|
|
.saturating_sub(s_ul.row)
|
|
.saturating_div(il_source.0.unsigned_abs());
|
|
let j = j
|
|
.saturating_sub(s_ul.col)
|
|
.saturating_div(il_source.1.unsigned_abs());
|
|
let checked_il_dest = (
|
|
u8::max(il_dest.0.unsigned_abs(), 1u8),
|
|
u8::max(il_dest.1.unsigned_abs(), 1u8),
|
|
);
|
|
let row_modulus = number_used_src_wells.0 * checked_il_dest.0;
|
|
let column_modulus = number_used_src_wells.1 * checked_il_dest.1;
|
|
|
|
Some(
|
|
possible_destination_wells
|
|
.into_iter()
|
|
.filter(|Well { row: x, .. }| {
|
|
x.checked_sub(d_ul.row).unwrap()
|
|
% row_modulus // Counter along x
|
|
== (il_dest.0.unsigned_abs() *i)
|
|
% row_modulus
|
|
})
|
|
.filter(|Well { col: y, .. }| {
|
|
y.checked_sub(d_ul.col).unwrap()
|
|
% column_modulus // Counter along u
|
|
== (il_dest.1.unsigned_abs() *j)
|
|
% column_modulus
|
|
})
|
|
.filter(|Well { row: x, col: y }| {
|
|
// How many times have we replicated? < How many are we allowed
|
|
// to replicate?
|
|
x.checked_sub(d_ul.row).unwrap().div_euclid(row_modulus)
|
|
< count.0
|
|
&& y.checked_sub(d_ul.col)
|
|
.unwrap()
|
|
.div_euclid(column_modulus)
|
|
< count.1
|
|
})
|
|
.collect(),
|
|
)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
}
|
|
Region::Custom(c) => Box::new(move |Well { row: i, col: j }| {
|
|
let src = c.src.clone();
|
|
let dest = c.dest.clone();
|
|
|
|
let points: Vec<Well> = src
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(_index, Well { row: x, col: y })| *x == i && *y == j)
|
|
.map(|(index, _)| dest[index])
|
|
.collect();
|
|
if points.is_empty() {
|
|
None
|
|
} else {
|
|
Some(points)
|
|
}
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn point_destination_region_calc(
|
|
input: Well,
|
|
source_ul: Well,
|
|
il_source: (i8, i8),
|
|
il_dest: (i8, i8),
|
|
dest_point: Well,
|
|
) -> Well {
|
|
Well {
|
|
row: dest_point.row
|
|
+ input
|
|
.row
|
|
.checked_sub(source_ul.row)
|
|
.expect("Point cannot have been less than UL")
|
|
.checked_div(il_source.0.unsigned_abs())
|
|
.expect("Source interleave cannot be 0")
|
|
.mul(il_dest.0.unsigned_abs()),
|
|
col: dest_point.col
|
|
+ input
|
|
.col
|
|
.checked_sub(source_ul.col)
|
|
.expect("Point cannot have been less than UL")
|
|
.checked_div(il_source.1.unsigned_abs())
|
|
.expect("Source interleave cannot be 0")
|
|
.mul(il_dest.1.unsigned_abs()),
|
|
}
|
|
}
|
|
|
|
pub fn validate(&self) -> Result<(), &'static str> {
|
|
// Checks if the region does anything suspect
|
|
//
|
|
// If validation fails, we pass a string to show to the user.
|
|
//
|
|
// We check:
|
|
// - Are the wells in the source really there?
|
|
// - In a replication region, do the source lengths divide the destination lengths?
|
|
// - Are the interleaves valid?
|
|
let il_source = self.interleave_source;
|
|
let il_dest = self.interleave_dest;
|
|
|
|
match self.source_region {
|
|
/*
|
|
* Note 04Jan2025:
|
|
* I genuinely cannot think of a reason why we should need to validate a source
|
|
* point region???
|
|
* Like, why would it *not* be in the plate?
|
|
*/
|
|
Region::Point(_) => return Ok(()), // Should make sure it's actually in the plate, leave for
|
|
// later
|
|
Region::Rect(s1, s2) => {
|
|
// Check if all source wells exist:
|
|
if s1.row == 0 || s1.col == 0 || s2.row == 0 || s2.col == 0 {
|
|
return Err("Source region is out-of-bounds! (Too small)");
|
|
}
|
|
// Sufficient to check if the corners are in-bounds
|
|
let source_max = self.source_plate.size();
|
|
if s1.row > source_max.0 || s2.row > source_max.0 {
|
|
return Err("Source region is out-of-bounds! (Too tall)");
|
|
}
|
|
if s1.col > source_max.1 || s2.col > source_max.1 {
|
|
// log::debug!("s1.1: {}, max.1: {}", s1.1, source_max.1);
|
|
return Err("Source region is out-of-bounds! (Too wide)");
|
|
}
|
|
|
|
if il_dest == (0, 0) {
|
|
return Err("Refusing to pool both dimensions in a rectangular transfer!\nPlease select a point in the destination plate.");
|
|
}
|
|
}
|
|
Region::Custom(_) => return Ok(()),
|
|
}
|
|
|
|
if il_source.0 == 0 || il_source.1 == 0 {
|
|
return Err("Source interleave cannot be zero!");
|
|
}
|
|
|
|
// Check if all destination wells exist:
|
|
// NOT IMPLEMENTED
|
|
// Should *not* happen in this function---otherwise
|
|
// we'd get a nasty recursive loop.
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn create_dense_rectangle(c1: &Well, c2: &Well) -> Vec<Well> {
|
|
// Creates a vector of every point between two corners
|
|
let (c1, c2) = standardize_rectangle(c1, c2);
|
|
|
|
let mut points = Vec::<Well>::new();
|
|
for i in c1.row..=c2.row {
|
|
for j in c1.col..=c2.col {
|
|
points.push(Well { row: i, col: j });
|
|
}
|
|
}
|
|
|
|
points
|
|
}
|
|
|
|
fn standardize_rectangle(c1: &Well, c2: &Well) -> (Well, Well) {
|
|
let upper_left_i = u8::min(c1.row, c2.row);
|
|
let upper_left_j = u8::min(c1.col, c2.col);
|
|
let bottom_right_i = u8::max(c1.row, c2.row);
|
|
let bottom_right_j = u8::max(c1.col, c2.col);
|
|
(
|
|
Well {
|
|
row: upper_left_i,
|
|
col: upper_left_j,
|
|
},
|
|
Well {
|
|
row: bottom_right_i,
|
|
col: bottom_right_j,
|
|
},
|
|
)
|
|
}
|
|
|
|
#[cfg(debug_assertions)]
|
|
use std::fmt;
|
|
use std::{fmt::Display, ops::Mul};
|
|
|
|
#[cfg(debug_assertions)] // There should be no reason to print a transfer otherwise
|
|
impl fmt::Display for TransferRegion {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
writeln!(f, "Source Plate:")?;
|
|
let source_dims = self.source_plate.size();
|
|
let source_wells = self.get_source_wells();
|
|
let mut source_string = String::new();
|
|
for i in 1..=source_dims.0 {
|
|
for j in 1..=source_dims.1 {
|
|
if source_wells.contains(&Well { row: i, col: j }) {
|
|
source_string.push('x')
|
|
} else {
|
|
source_string.push('.')
|
|
}
|
|
}
|
|
source_string.push('\n');
|
|
}
|
|
write!(f, "{}", source_string)?;
|
|
|
|
writeln!(f, "Dest Plate:")?;
|
|
let dest_dims = self.dest_plate.size();
|
|
let dest_wells = self.get_destination_wells();
|
|
let mut dest_string = String::new();
|
|
for i in 1..=dest_dims.0 {
|
|
for j in 1..=dest_dims.1 {
|
|
if dest_wells.contains(&Well { row: i, col: j }) {
|
|
dest_string.push('x')
|
|
} else {
|
|
dest_string.push('.')
|
|
}
|
|
}
|
|
dest_string.push('\n');
|
|
}
|
|
write!(f, "{}", dest_string)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::plate::*;
|
|
use crate::transfer_region::*;
|
|
|
|
#[test]
|
|
fn test_simple_transfer() {
|
|
let source = Plate::new(PlateType::Source, PlateFormat::W96);
|
|
let destination = Plate::new(PlateType::Destination, PlateFormat::W384);
|
|
|
|
let transfer1 = TransferRegion {
|
|
source_plate: source,
|
|
source_region: Region::Rect(Well { row: 1, col: 1 }, Well { row: 1, col: 1 }),
|
|
dest_plate: destination,
|
|
dest_region: Region::Point(Well { row: 3, col: 3 }),
|
|
interleave_source: (1, 1),
|
|
interleave_dest: (1, 1),
|
|
};
|
|
let transfer1_map = transfer1.calculate_map();
|
|
assert_eq!(
|
|
transfer1_map(Well { row: 1, col: 1 }),
|
|
Some(vec! {Well {row: 3, col: 3}}),
|
|
"Failed basic shift transfer 1"
|
|
);
|
|
assert_eq!(
|
|
transfer1_map(Well { row: 1, col: 2 }),
|
|
Some(vec! {Well{ row: 3, col: 4}}),
|
|
"Failed basic shift transfer 2"
|
|
);
|
|
assert_eq!(
|
|
transfer1_map(Well { row: 2, col: 2 }),
|
|
Some(vec! {Well{ row: 4, col: 4}}),
|
|
"Failed basic shift transfer 3"
|
|
);
|
|
|
|
let transfer2 = TransferRegion {
|
|
source_plate: source,
|
|
source_region: Region::Rect(Well { row: 1, col: 1 }, Well { row: 3, col: 3 }),
|
|
dest_plate: destination,
|
|
dest_region: Region::Point(Well { row: 3, col: 3 }),
|
|
interleave_source: (2, 2),
|
|
interleave_dest: (1, 1),
|
|
};
|
|
let transfer2_map = transfer2.calculate_map();
|
|
assert_eq!(
|
|
transfer2_map(Well { row: 1, col: 1 }),
|
|
Some(vec! {Well{ row: 3, col: 3}}),
|
|
"Failed source interleave, type simple 1"
|
|
);
|
|
assert_eq!(
|
|
transfer2_map(Well { row: 1, col: 2 }),
|
|
None,
|
|
"Failed source interleave, type simple 2"
|
|
);
|
|
assert_eq!(
|
|
transfer2_map(Well { row: 2, col: 2 }),
|
|
None,
|
|
"Failed source interleave, type simple 3"
|
|
);
|
|
assert_eq!(
|
|
transfer2_map(Well { row: 3, col: 3 }),
|
|
Some(vec! {Well{ row: 4, col: 4}}),
|
|
"Failed source interleave, type simple 4"
|
|
);
|
|
|
|
let transfer3 = TransferRegion {
|
|
source_plate: source,
|
|
source_region: Region::Rect(Well { row: 1, col: 1 }, Well { row: 3, col: 3 }),
|
|
dest_plate: destination,
|
|
dest_region: Region::Point(Well { row: 3, col: 3 }),
|
|
interleave_source: (1, 1),
|
|
interleave_dest: (2, 3),
|
|
};
|
|
let transfer3_map = transfer3.calculate_map();
|
|
assert_eq!(
|
|
transfer3_map(Well { row: 1, col: 1 }),
|
|
Some(vec! {Well{ row: 3, col: 3}}),
|
|
"Failed destination interleave, type simple 1"
|
|
);
|
|
assert_eq!(
|
|
transfer3_map(Well { row: 2, col: 1 }),
|
|
Some(vec! {Well{ row: 5, col: 3}}),
|
|
"Failed destination interleave, type simple 2"
|
|
);
|
|
assert_eq!(
|
|
transfer3_map(Well { row: 1, col: 2 }),
|
|
Some(vec! {Well{ row: 3, col: 6}}),
|
|
"Failed destination interleave, type simple 3"
|
|
);
|
|
assert_eq!(
|
|
transfer3_map(Well { row: 2, col: 2 }),
|
|
Some(vec! {Well{ row: 5, col: 6}}),
|
|
"Failed destination interleave, type simple 4"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_replicate_transfer() {
|
|
let source = Plate::new(PlateType::Source, PlateFormat::W96);
|
|
let destination = Plate::new(PlateType::Destination, PlateFormat::W384);
|
|
|
|
let transfer1 = TransferRegion {
|
|
source_plate: source,
|
|
source_region: Region::Rect(Well { row: 1, col: 1 }, Well { row: 2, col: 2 }),
|
|
dest_plate: destination,
|
|
dest_region: Region::Rect(Well { row: 2, col: 2 }, Well { row: 11, col: 11 }),
|
|
interleave_source: (1, 1),
|
|
interleave_dest: (3, 3),
|
|
};
|
|
let transfer1_map = transfer1.calculate_map();
|
|
assert_eq!(
|
|
transfer1_map(Well { row: 1, col: 1 }),
|
|
Some(
|
|
vec! {Well{ row: 2, col: 2}, Well{ row: 2, col: 8}, Well{ row: 8, col: 2}, Well{ row: 8, col: 8}}
|
|
),
|
|
"Failed type replicate 1"
|
|
);
|
|
assert_eq!(
|
|
transfer1_map(Well { row: 2, col: 1 }),
|
|
Some(
|
|
vec! {Well{ row: 5, col: 2}, Well{ row: 5, col: 8}, Well{ row: 11, col: 2}, Well{ row: 11, col: 8}}
|
|
),
|
|
"Failed type replicate 1"
|
|
);
|
|
|
|
let transfer2 = TransferRegion {
|
|
source_plate: Plate::new(PlateType::Source, PlateFormat::W384),
|
|
dest_plate: Plate::new(PlateType::Destination, PlateFormat::W384),
|
|
source_region: Region::Rect(Well { row: 1, col: 1 }, Well { row: 2, col: 3 }),
|
|
dest_region: Region::Rect(Well { row: 2, col: 2 }, Well { row: 11, col: 16 }),
|
|
interleave_source: (1, 1),
|
|
interleave_dest: (2, 2),
|
|
};
|
|
let transfer2_source = transfer2.get_source_wells();
|
|
let transfer2_dest = transfer2.get_destination_wells();
|
|
assert_eq!(
|
|
transfer2_source,
|
|
vec![
|
|
Well { row: 1, col: 1 },
|
|
Well { row: 1, col: 2 },
|
|
Well { row: 1, col: 3 },
|
|
Well { row: 2, col: 1 },
|
|
Well { row: 2, col: 2 },
|
|
Well { row: 2, col: 3 }
|
|
],
|
|
"Failed type replicate 2 source"
|
|
);
|
|
assert_eq!(
|
|
transfer2_dest,
|
|
vec![
|
|
Well { row: 2, col: 2 },
|
|
Well { row: 2, col: 8 },
|
|
Well { row: 6, col: 2 },
|
|
Well { row: 6, col: 8 },
|
|
Well { row: 2, col: 4 },
|
|
Well { row: 2, col: 10 },
|
|
Well { row: 6, col: 4 },
|
|
Well { row: 6, col: 10 },
|
|
Well { row: 2, col: 6 },
|
|
Well { row: 2, col: 12 },
|
|
Well { row: 6, col: 6 },
|
|
Well { row: 6, col: 12 },
|
|
Well { row: 4, col: 2 },
|
|
Well { row: 4, col: 8 },
|
|
Well { row: 8, col: 2 },
|
|
Well { row: 8, col: 8 },
|
|
Well { row: 4, col: 4 },
|
|
Well { row: 4, col: 10 },
|
|
Well { row: 8, col: 4 },
|
|
Well { row: 8, col: 10 },
|
|
Well { row: 4, col: 6 },
|
|
Well { row: 4, col: 12 },
|
|
Well { row: 8, col: 6 },
|
|
Well { row: 8, col: 12 }
|
|
],
|
|
"Failed type replicate 2 destination"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_pooling_transfer() {
|
|
use std::collections::HashSet;
|
|
let transfer1 = TransferRegion {
|
|
source_plate: Plate::new(PlateType::Source, PlateFormat::W384),
|
|
dest_plate: Plate::new(PlateType::Destination, PlateFormat::W384),
|
|
source_region: Region::Rect(Well { row: 1, col: 4 }, Well { row: 3, col: 7 }),
|
|
dest_region: Region::Point(Well { row: 1, col: 9 }),
|
|
interleave_source: (1, 1),
|
|
interleave_dest: (0, 2),
|
|
};
|
|
//let transfer1_source = transfer1.get_source_wells();
|
|
let transfer1_dest: HashSet<Well> = transfer1.get_destination_wells().into_iter().collect();
|
|
let transfer1_map = transfer1.calculate_map();
|
|
// Skipping source check---it's just 12 wells.
|
|
assert_eq!(
|
|
transfer1_dest,
|
|
vec![
|
|
Well { row: 1, col: 9 },
|
|
Well { row: 1, col: 11 },
|
|
Well { row: 1, col: 13 },
|
|
Well { row: 1, col: 15 }
|
|
]
|
|
.into_iter()
|
|
.collect(),
|
|
"Failed type pool 1 dest"
|
|
);
|
|
assert_eq!(
|
|
transfer1_map(Well { row: 2, col: 6 }),
|
|
Some(vec![Well { row: 1, col: 13 }]),
|
|
"Failed type pool 1 map 1"
|
|
);
|
|
assert_eq!(
|
|
transfer1_map(Well { row: 3, col: 7 }),
|
|
Some(vec![Well { row: 1, col: 15 }]),
|
|
"Failed type pool 1 map 2"
|
|
);
|
|
}
|
|
}
|