Struct codenano::Design

pub struct Design<StrandLabel, DomainLabel> {
    pub version: String,
    pub helices: Vec<Helix>,
    pub strands: Vec<Strand<StrandLabel, DomainLabel>>,
    pub parameters: Option<Parameters>,
}

The main type of this crate, describing a DNA design.

Fields

version: String

Version of this format.

helices: Vec<Helix>

The vector of all helices used in this design. Helices have a position and an orientation in 3D.

strands: Vec<Strand<StrandLabel, DomainLabel>>

The vector of strands.

parameters: Option<Parameters>

Parameters of DNA geometry. This can be skipped (in JSON), or set to None in Rust, in which case a default set of parameters from the literature is used.

Methods

impl<StrandLabel, DomainLabel> Design<StrandLabel, DomainLabel>

pub fn to_cadnano<W: Write>(&self, w: W) -> Result<(), Error>

Output a design in Cadnano format.

impl<StrandLabel: Serialize, DomainLabel: Serialize> Design<StrandLabel, DomainLabel>

pub fn new() -> Self

Initiates a design.

pub fn square_grid_helix(&self, h: isize, v: isize) -> Helix

Creates a flat helix (in the z = 0 plane).

pub fn adjusted_grid_helix(&self, h: isize, v: isize) -> Helix

Creates a flat helix in the z = 0 plane with adjusted roll.

pub fn with_parameters(parameters: Parameters) -> Self

Initiates a design with the given geometric parameters.

pub fn add_grid_helix(&mut self, h: isize, v: isize) -> HelixId

Add a helix created by Self::square_grid_helix.

pub fn add_adjusted_grid_helix(&mut self, h: isize, v: isize) -> HelixId

Add a helix created by Self::add_grid_helix.

pub fn add_helix(
    &mut self,
    x: f64,
    y: f64,
    z: f64,
    roll: f64,
    pitch: f64,
    yaw: f64
) -> HelixId

Add an arbitrary helix. Parameters x,y,z are in nanometers and are the 3D coordinates of the centre of the helix. roll,pitch,yaw are in radians.

pub fn strand<H: Into<HelixId>>(
    &mut self,
    helix: H,
    start: isize
) -> StrandRef<StrandLabel, DomainLabel>

Start a strand, placing the first base at the position given by helix and start.

pub fn empty_strand(&mut self) -> StrandRef<StrandLabel, DomainLabel>

Create a strand with no initial domain. Useful for adding custom domains, for example domains obtained by geometric operations from other domains.

pub fn get_strand_ref(
    &mut self,
    strand_id: usize
) -> StrandRef<StrandLabel, DomainLabel>

Return a StrandRef that can build the strand strand_id

pub fn write(&self) -> Result<(), Error>

Write this design to the standard output.

pub fn write_to<P: AsRef<Path>>(&self, p: P) -> Result<(), Error>

Write this design to a file. If the REMOTE environment variable is set, write it to the standard output instead.

pub fn unique_positions(&self) -> Option<(isize, isize, bool, usize, usize)>

Tests whether all bases have different positions, and returns an offending strand else. The return format is (helix, position, orientation, i, j), where i and j are the indices of two strands sharing this position. Bases that are the start/end of a cycle are not detected and do not cause their strand to be offending

pub fn check_and_write_to<P: AsRef<Path>>(&self, p: P) -> Result<(), Error>

Tests whether all bases have different positions, and warns the user otherwise. Write this design to a file. If the REMOTE environment variable is set, write it to the standard output instead.

pub fn adjust_helix(&mut self, h1: usize, h2: usize)

Adjust the roll of two helices to minimize the distance at crossing overs

impl<StrandLabel, DomainLabel> Design<StrandLabel, DomainLabel>

pub fn sequences(&self) -> Vec<String>

Output all the sequences of the strands whose sequence has not been forced.

impl<StrandLabel: Ord + Display, DomainLabel> Design<StrandLabel, DomainLabel>

pub fn make_plates_96<H: FnMut(&Strand<StrandLabel, DomainLabel>) -> usize, F: FnMut(&Strand<StrandLabel, DomainLabel>) -> Option<bool>, G: FnMut(usize) -> String>(
    &mut self,
    file: &str,
    seq_class: H,
    filter: F,
    format: G
)

Output plates with the sequences, ordered by label, as an Excel spreadsheet that can be ordered from the IDT website.

All strands s such that filter(s).is_some() are included, and only those. Moreover, if filter(s) == Some(true), a new plate is started if the current plate is nonempty.

Moreover, strands are ran through the filter function in the same order as they are in self.

Trait Implementations

impl<'de, StrandLabel, DomainLabel> Deserialize<'de> for Design<StrandLabel, DomainLabel> where
    StrandLabel: Deserialize<'de>,
    DomainLabel: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<StrandLabel, DomainLabel> Serialize for Design<StrandLabel, DomainLabel> where
    StrandLabel: Serialize,
    DomainLabel: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.