def main(): length = 16 helices = [sc.Helix(max_offset=length, grid_position=(h, v, 0)) for v in range(-4, 6) for h in range(-4, 6)] design = sc.DNADesign(helices=helices, strands=[], grid=sc.hexagonal) return design
def main(): # helices helices = [sc.Helix(max_offset=48), sc.Helix(max_offset=48)] # left staple stap_left_ss1 = sc.Domain(helix=1, forward=True, start=8, end=24) stap_left_ss0 = sc.Domain(helix=0, forward=False, start=8, end=24) stap_left = sc.Strand(domains=[stap_left_ss1, stap_left_ss0]) # right staple stap_right_ss0 = sc.Domain(helix=0, forward=False, start=24, end=40) stap_right_ss1 = sc.Domain(helix=1, forward=True, start=24, end=40) stap_right = sc.Strand(domains=[stap_right_ss0, stap_right_ss1]) stap_right.set_modification_5p(mod.biotin_5p) # scaffold scaf_ss1_left = sc.Domain(helix=1, forward=False, start=8, end=24) scaf_ss0 = sc.Domain(helix=0, forward=True, start=8, end=40) loopout = sc.Loopout(length=3) scaf_ss1_right = sc.Domain(helix=1, forward=False, start=24, end=40) scaf = sc.Strand(domains=[scaf_ss1_left, scaf_ss0, loopout, scaf_ss1_right], is_scaffold=True) # whole design design = sc.DNADesign(helices=helices, strands=[scaf, stap_left, stap_right], grid=sc.square) # deletions and insertions added to design are added to both strands on a helix design.add_deletion(helix=1, offset=20) design.add_insertion(helix=0, offset=14, length=1) design.add_insertion(helix=0, offset=26, length=2) # also assigns complement to strands other than scaf bound to it design.assign_dna(scaf, 'AACGT' * 18) return design
def main(): length = 16 helices = [ sc.Helix(major_tick_distance=4, max_offset=length, position=sc.Position3D(x=0, y=0, z=0), min_offset=0), sc.Helix(major_tick_distance=4, max_offset=length, position=sc.Position3D(x=0, y=3, z=3), min_offset=8), sc.Helix(major_tick_distance=4, max_offset=length, position=sc.Position3D(x=2.5, y=-3, z=8), min_offset=0), sc.Helix(major_tick_distance=4, max_offset=length, position=sc.Position3D(x=2.5, y=1, z=11), min_offset=8), ] design = sc.DNADesign(helices=helices, strands=[ sc.Strand([sc.Domain(0, True, 0, length)]), sc.Strand([sc.Domain(1, True, 8, length)]), sc.Strand([sc.Domain(2, True, 0, length)]), sc.Strand([sc.Domain(3, True, 8, length)]), ], grid=sc.Grid.none) return design
def main(): length = 10 helices = [ sc.Helix(max_offset=length, position=sc.Position3D(x=2.5, y=0, z=0), pitch=0, roll=0, yaw=0), sc.Helix(max_offset=length, position=sc.Position3D(x=0, y=3, z=3), pitch=0, roll=0, yaw=0), sc.Helix(max_offset=length, position=sc.Position3D(x=0, y=-3, z=8), pitch=0, roll=0, yaw=0), sc.Helix(max_offset=length, position=sc.Position3D(x=0, y=1, z=11), pitch=0, roll=0, yaw=0), ] stap_ss = sc.Domain(0, True, 0, length) scaf_ss = sc.Domain(0, False, 0, length) stap = sc.Strand([stap_ss]) scaf = sc.Strand([scaf_ss], color=sc.default_scaffold_color) strands = [stap, scaf] design = sc.DNADesign(helices=helices, strands=strands, grid=sc.Grid.none) return design
def main(): blue = sc.Color(r=0, g=0, b=255) black = sc.Color(r=0, g=0, b=0) red = sc.Color(r=255, g=0, b=0) green = sc.Color(r=0, g=150, b=0) cols = 8 rows = 8 # helices = [sc.Helix(major_tick_distance=10) for _ in range(rows+1)] strands = [] for col in range(cols): for row in range(rows): helix = row forward = row % 2 == 0 if forward: offset = col * 20 ss1 = sc.Domain(helix, forward, offset, offset + 20) ss2 = sc.Domain(helix + 1, forward, offset + 20, offset + 40) else: offset = col * 20 ss1 = sc.Domain(helix, forward, offset + 30, offset + 50) ss2 = sc.Domain(helix + 1, forward, offset + 10, offset + 30) if forward: color = blue if col % 2 == 0 else black else: color = red if col % 2 == 0 else green strand = sc.Strand([ss1, ss2], color=color) strands.append(strand) # design = sc.DNADesign(helices=helices, strands=strands, grid=sc.square) design = sc.DNADesign(major_tick_distance=10, strands=strands, grid=sc.square) return design
def main(): num_helices = 16 bases = 48 helices = [sc.Helix() for _ in range(num_helices)] strands = [] for bot in range(num_helices // 2): top = num_helices - bot - 1 helix_top = helices[bot] helix_bot = helices[top] stap_left_ss_top = sc.Domain(top, sc.forward, 0, bases // 3) stap_left_ss_bot = sc.Domain(bot, sc.reverse, 0, bases // 3) stap_mid_ss_bot = sc.Domain(bot, sc.reverse, bases // 3, bases * 2 // 3) stap_mid_ss_top = sc.Domain(top, sc.forward, bases // 3, bases * 2 // 3) stap_right_ss_top = sc.Domain(top, sc.forward, bases * 2 // 3, bases) stap_right_ss_bot = sc.Domain(bot, sc.reverse, bases * 2 // 3, bases) stap_left = sc.Strand([stap_left_ss_bot, stap_left_ss_top]) stap_mid = sc.Strand([stap_mid_ss_top, stap_mid_ss_bot]) stap_right = sc.Strand([stap_right_ss_bot, stap_right_ss_top]) strands.append(stap_left) strands.append(stap_mid) strands.append(stap_right) design = sc.DNADesign(helices=helices, strands=strands, grid=sc.square) return design
def main(): helices = [] num_helices, max_bases = 30, 2000 for _ in range(num_helices): helices.append(sc.Helix(max_bases)) design = sc.DNADesign(helices=helices, strands=[], grid=sc.square) return design
def precursor_scaffolds() -> sc.DNADesign: helices = [sc.Helix(max_offset=304) for _ in range(24)] scaffolds = [ sc.Strand( [sc.Domain(helix=helix, forward=helix % 2 == 0, start=8, end=296)]) for helix in range(24) ] return sc.DNADesign(helices=helices, strands=scaffolds, grid=sc.square)
def main(): ss_f = sc.Domain(helix=0, forward=True, start=0, end=10) loop = sc.Loopout(length=5) ss_r = sc.Domain(helix=0, forward=False, start=0, end=10) hairpin = sc.Strand([ss_f, loop, ss_r]) design = sc.DNADesign(strands=[hairpin], grid=sc.square) design.assign_dna(hairpin, 'AAAAACCCCCTGCAT') return design
def main(): helices = [ sc.Helix(idx=2, max_offset=20), sc.Helix(idx=3, max_offset=20), sc.Helix(idx=5, max_offset=20), sc.Helix(idx=7, max_offset=20), sc.Helix(idx=11, max_offset=20), ] design = sc.DNADesign(helices=helices, strands=[]) # design.set_helices_view_order([5, 2, 11, 3, 7]) return design
def main(): length = 9 helices = [sc.Helix(max_offset=length, major_ticks=[2, 5])] stap_ss = sc.Domain(0, True, 0, length) scaf_ss = sc.Domain(0, False, 0, length) stap = sc.Strand([stap_ss]) scaf = sc.Strand([scaf_ss], color=sc.default_scaffold_color) strands = [stap, scaf] design = sc.DNADesign(helices=helices, strands=strands, grid=sc.square) design.assign_dna(scaf, 'AACT' * (length // 4)) return design
def main(): length = 9 helices = [sc.Helix(max_offset=length, rotation=math.pi/2, rotation_anchor=2)] stap_ss = sc.Domain(0, sc.forward, 0, length) scaf_ss = sc.Domain(0, sc.reverse, 0, length) stap = sc.Strand([stap_ss]) scaf = sc.Strand([scaf_ss], color=sc.default_scaffold_color) strands = [stap, scaf] design = sc.DNADesign(helices=helices, strands=strands, grid=sc.square) design.assign_dna(scaf, 'AACT' * (length // 4)) return design
def main(): length = 10 stap_ss = sc.Domain(0, True, 0, length) scaf_ss = sc.Domain(0, False, 0, length) stap = sc.Strand([stap_ss]) scaf = sc.Strand([scaf_ss], color=sc.default_scaffold_color) strands = [stap, scaf] design = sc.DNADesign(strands=strands, grid=sc.square) insertion_length = 4 design.add_insertion(helix=0, offset=2, length=insertion_length) design.add_insertion(helix=0, offset=8, length=insertion_length) scaf.set_dna_sequence('AG' + 'A' * (length + 2*insertion_length - 2)) stap.set_dna_sequence('ATTCTCTTGCTTTTTTCA') return design
def main(): # multiple-domain ss0_1 = sc.Domain(helix=0, forward=False, start=0, end=4) ss1 = sc.Domain(helix=1, forward=True, start=0, end=8) ss0_2 = sc.Domain(helix=0, forward=False, start=4, end=8) strand_multi = sc.Strand(domains=[ss0_1, ss1, ss0_2]) # single domain ss0_single = sc.Domain(helix=0, forward=True, start=0, end=8) strand_single = sc.Strand(domains=[ss0_single]) # whole design design = sc.DNADesign(strands=[strand_multi, strand_single], grid=sc.square) return design
def main(): length = 9 helices = [ sc.Helix(max_offset=length, major_ticks=[2, 5], position3d=sc.Position3D(x=3, y=2, z=1), pitch=90) ] stap_ss = sc.Domain(0, sc.forward, 0, length) scaf_ss = sc.Domain(0, sc.reverse, 0, length) stap = sc.Strand([stap_ss]) scaf = sc.Strand([scaf_ss], color=sc.default_scaffold_color) strands = [stap, scaf] design = sc.DNADesign(helices=helices, strands=strands, grid=sc.square) design.assign_dna(scaf, 'AACT' * (length // 4)) return design
def main(): stap_left_ss1 = sc.Domain(1, True, 0, 16) stap_left_ss0 = sc.Domain(0, False, 0, 16) stap_right_ss0 = sc.Domain(0, False, 16, 32) stap_right_ss1 = sc.Domain(1, True, 16, 32) scaf_ss1_left = sc.Domain(1, False, 0, 16) scaf_ss0 = sc.Domain(0, True, 0, 32) scaf_ss1_right = sc.Domain(1, False, 16, 32) stap_left = sc.Strand([stap_left_ss1, stap_left_ss0]) stap_right = sc.Strand([stap_right_ss0, stap_right_ss1]) scaf = sc.Strand([scaf_ss1_left, scaf_ss0, scaf_ss1_right], color=sc.default_scaffold_color) strands = [scaf, stap_left, stap_right] design = sc.DNADesign(strands=strands, grid=sc.square) design.add_deletion(helix=0, offset=11) design.add_deletion(helix=0, offset=12) design.add_deletion(helix=0, offset=24) design.add_deletion(helix=1, offset=12) design.add_deletion(helix=1, offset=24) design.add_insertion(helix=0, offset=29, length=1) design.add_insertion(helix=1, offset=2, length=1) design.assign_dna(scaf, 'AACT' * 16) # biotin_mod_5p = dataclasses.replace(mod.biotin_5p, font_size=30) # cy3_mod_3p = dataclasses.replace(mod.cy3_3p, font_size=30) stap_left.set_modification_5p(mod.biotin_5p) stap_left.set_modification_3p(mod.cy3_3p) stap_left.set_modification_internal(9, mod.cy3_int) stap_left.set_modification_internal(10, mod.biotin_int) stap_left.set_modification_internal(11, mod.cy3_int) stap_left.set_modification_internal(12, mod.cy5_int) stap_left.set_modification_internal(4, mod.cy3_int) stap_left.set_modification_internal(26, mod.cy5_int) stap_right.set_modification_5p(mod.cy5_5p) stap_right.set_modification_internal(5, mod.cy3_int) stap_right.set_modification_3p(mod.biotin_3p) scaf.set_modification_5p(mod.biotin_5p) scaf.set_modification_3p(mod.cy3_3p) scaf.set_modification_internal(5, mod.cy5_int) scaf.set_modification_internal(32, mod.cy3_int) return design
def main(): ss1_r = sc.Domain(0, True, 0, 4) ss2_r = sc.Domain(0, True, 4, 8) ss3_r = sc.Domain(0, True, 8, 12) ss_l = sc.Domain(0, False, 0, 12) s1_r = sc.Strand([ss1_r], idt=sc.IDTFields('s1_r')) s2_r = sc.Strand([ss2_r], idt=sc.IDTFields('s1_r')) s3_r = sc.Strand([ss3_r], idt=sc.IDTFields('s1_r')) s_l = sc.Strand([ss_l], idt=sc.IDTFields('s_l')) strands = [s1_r, s2_r, s3_r, s_l] design = sc.DNADesign(strands=strands, grid=sc.square) design.assign_dna(s_l, 'AGTT' * 3) return design
def main(): length = 30 helices = [ sc.Helix(min_offset=0, max_offset=length, grid_position=(0, 0)), sc.Helix(min_offset=1, max_offset=length, grid_position=(0, 1)), sc.Helix(min_offset=2, max_offset=length, grid_position=(0, 2)), sc.Helix(min_offset=3, max_offset=length, grid_position=(0, 3)), ] stap_ss = sc.Domain(0, True, 0, length - 1) scaf_ss = sc.Domain(0, False, 0, length - 1) stap = sc.Strand([stap_ss]) scaf = sc.Strand([scaf_ss], color=sc.default_scaffold_color) strands = [stap, scaf] design = sc.DNADesign(helices=helices, strands=strands, grid=sc.Grid.square) return design
def main(): # helices helices = [sc.Helix(max_offset=48), sc.Helix(max_offset=48)] # left staple stap_left_ss1 = sc.Domain(helix=1, forward=True, start=8, end=24) stap_left_ss0 = sc.Domain(helix=0, forward=False, start=8, end=24) stap_left = sc.Strand(domains=[stap_left_ss1, stap_left_ss0]) # right staple stap_right_ss0 = sc.Domain(helix=0, forward=False, start=24, end=40) stap_right_ss1 = sc.Domain(helix=1, forward=True, start=24, end=40) stap_right = sc.Strand(domains=[stap_right_ss0, stap_right_ss1]) # scaffold scaf_ss1_left = sc.Domain(helix=1, forward=False, start=8, end=24) scaf_ss0 = sc.Domain(helix=0, forward=True, start=8, end=40) loopout = sc.Loopout(length=3) scaf_ss1_right = sc.Domain(helix=1, forward=False, start=24, end=40) scaf = sc.Strand( domains=[scaf_ss1_left, scaf_ss0, loopout, scaf_ss1_right], is_scaffold=True) # geometry geometry = sc.Geometry(rise_per_base_pair=0.2, helix_radius=1.2, inter_helix_gap=1.0) # whole design design = sc.DNADesign(helices=helices, strands=[scaf, stap_left, stap_right], grid=sc.square, geometry=geometry) # deletions and insertions added to design are added to both strands on a helix design.add_deletion(helix=1, offset=20) design.add_insertion(helix=0, offset=14, length=1) design.add_insertion(helix=0, offset=26, length=2) # also assigns complement to strands other than scaf bound to it design.assign_dna(scaf, 'AACGT' * 18) return design
def main(): NUM_HELICES = 8 WIDTH = 16 doms = [sc.Domain(h, h % 2 == 0, 0, WIDTH) for h in range(NUM_HELICES)] strand = sc.Strand(doms) design = sc.DNADesign(strands=[strand], grid=sc.square) design.add_deletion(helix=0, offset=11) design.add_deletion(helix=0, offset=12) design.add_deletion(helix=1, offset=12) design.add_insertion(helix=1, offset=4, length=1) design.assign_dna(strand, 'T' * (NUM_HELICES * WIDTH)) strand.set_modification_5p(mod.biotin_5p) strand.set_modification_3p(mod.cy3_3p) for h in range(NUM_HELICES): strand.set_modification_internal(WIDTH * h + 5, mod.cy3_int) strand.set_modification_internal(WIDTH * h + 10, mod.biotin_int) return design
def main(): # helices helices = [sc.Helix(max_offset=48), sc.Helix(max_offset=48)] # whole design design = sc.DNADesign(helices=helices, strands=[], grid=sc.square) design.strand(1, 8).to(24).cross(0).to(8) # left staple design.strand(0, 40).to(24).cross(1).to(40).with_modification_5p(mod.biotin_5p) # right staple design.strand(1, 24).to(8).cross(0).to(40).loopout(1, 3).to(24).as_scaffold() # deletions and insertions added to design are added to both strands on a helix design.add_deletion(helix=1, offset=20) design.add_insertion(helix=0, offset=14, length=1) design.add_insertion(helix=0, offset=26, length=2) # also assigns complement to strands other than scaf bound to it design.assign_dna(design.scaffold, 'AACGT' * 18) return design
def main(): stap_left_ss1 = sc.Domain(1, True, 0, 16) stap_left_ss0 = sc.Domain(0, False, 0, 16) stap_right_ss0 = sc.Domain(0, False, 16, 32) stap_right_ss1 = sc.Domain(1, True, 16, 32) scaf_ss1_left = sc.Domain(1, False, 0, 16) scaf_ss0 = sc.Domain(0, True, 0, 32) scaf_ss1_right = sc.Domain(1, False, 16, 32) stap_left = sc.Strand([stap_left_ss1, stap_left_ss0]) stap_right = sc.Strand([stap_right_ss0, stap_right_ss1]) scaf = sc.Strand([scaf_ss1_left, scaf_ss0, scaf_ss1_right], color=sc.default_scaffold_color) strands = [stap_left, stap_right, scaf] design = sc.DNADesign(strands=strands, grid=sc.square) design.add_deletion(helix=0, offset=11) design.add_deletion(helix=0, offset=12) design.add_deletion(helix=0, offset=24) design.add_deletion(helix=1, offset=12) design.add_deletion(helix=1, offset=24) design.assign_dna(scaf, 'AACT' * 16) return design
def main(): num_strands = 208 start = 0 strands = [] plate = 1 row_idx = 0 col_idx = 0 for s in range(1, num_strands + 1): ss_f = sc.Domain(helix=0, forward=True, start=start, end=start + 10) ss_r = sc.Domain(helix=1, forward=False, start=start, end=start + 10) row = ROWS[row_idx] col = COLS[col_idx] well = f'{row}{col}' idt = sc.IDTFields(name=f"staple{s}", plate=f'plate{plate}', well=well) strand = sc.Strand(domains=[ss_f, ss_r], idt=idt) strands.append(strand) row_idx += 1 if row_idx == len(ROWS): row_idx = 0 col_idx += 1 if col_idx == len(COLS): col_idx = 0 plate += 1 start += 10 scaffold = sc.Strand([ sc.Domain(helix=0, forward=False, start=0, end=start), sc.Domain(helix=1, forward=True, start=0, end=start) ], is_scaffold=True) strands.append(scaffold) design = sc.DNADesign(strands=strands, grid=sc.square) design.assign_m13_to_scaffold() return design
def main(): ss_f0 = sc.Domain(helix=0, forward=True, start=0, end=8) hairpin0 = sc.Loopout(length=5) ss_r0 = sc.Domain(helix=0, forward=False, start=0, end=8) crossover_like_loopout = sc.Loopout(length=5) ss_f1 = sc.Domain(helix=1, forward=True, start=0, end=8) long_range_loopout = sc.Loopout(length=10) ss_r2 = sc.Domain(helix=2, forward=False, start=16, end=24) hairpin2 = sc.Loopout(length=20) ss_f2 = sc.Domain(helix=2, forward=True, start=16, end=32) hairpin2_2 = sc.Loopout(length=1) ss_r2_2 = sc.Domain(helix=2, forward=False, start=24, end=32) strand = sc.Strand([ ss_f0, hairpin0, ss_r0, crossover_like_loopout, ss_f1, long_range_loopout, ss_r2, hairpin2, ss_f2, hairpin2_2, ss_r2_2 ]) design = sc.DNADesign(strands=[strand], grid=sc.square) t5 = 'TTTAC' t10 = 'TTTACTTACG' t20 = 'TTTTTTTTTTACGTTGCAGG' design.assign_dna( strand, f'ACGACGAC ' f'{t5} ' f'???????? ' f'{t5} ' f'GACGACGA ' f'{t10} ' f'CACGACGA ' f'{t20} ' f'???????? ' f'ACGACGAC ' f'T') return design
def main(): width = 6 width_h = width // 2 stap_left_ss1 = sc.Domain(1, sc.forward, 0, width_h) stap_left_ss0 = sc.Domain(0, sc.reverse, 0, width_h) stap_right_ss0 = sc.Domain(0, sc.reverse, width_h, width) stap_right_ss1 = sc.Domain(1, sc.forward, width_h, width) scaf_ss1_left = sc.Domain(1, sc.reverse, 0, width_h) scaf_ss0 = sc.Domain(0, sc.forward, 0, width) scaf_ss1_right = sc.Domain(1, sc.reverse, width_h, width) stap_left = sc.Strand([stap_left_ss1, stap_left_ss0]) stap_right = sc.Strand([stap_right_ss0, stap_right_ss1]) scaf = sc.Strand([scaf_ss1_left, scaf_ss0, scaf_ss1_right], color=sc.default_scaffold_color) strands = [stap_left, stap_right, scaf] design = sc.DNADesign(strands=strands, grid=sc.square) design.add_deletion(helix=0, offset=1) design.add_deletion(helix=0, offset=4) design.add_deletion(helix=1, offset=1) design.add_deletion(helix=1, offset=4) design.assign_dna(scaf, 'AACATCGT') return design
def main(): # left staple stap_left_ss1 = sc.Domain(helix=1, forward=True, start=0, end=16) stap_left_ss0 = sc.Domain(helix=0, forward=False, start=0, end=16) stap_left = sc.Strand(domains=[stap_left_ss1, stap_left_ss0]) # right staple stap_right_ss0 = sc.Domain(helix=0, forward=False, start=16, end=32) stap_right_ss1 = sc.Domain(helix=1, forward=True, start=16, end=32) stap_right = sc.Strand(domains=[stap_right_ss0, stap_right_ss1]) # scaffold scaf_ss1_left = sc.Domain(helix=1, forward=False, start=0, end=16) scaf_ss0 = sc.Domain(helix=0, forward=True, start=0, end=32) loopout = sc.Loopout(length=3) scaf_ss1_right = sc.Domain(helix=1, forward=False, start=16, end=32) scaf = sc.Strand( domains=[scaf_ss1_left, scaf_ss0, loopout, scaf_ss1_right], is_scaffold=True) # whole design design = sc.DNADesign(strands=[scaf, stap_left, stap_right], grid=sc.square) # deletions and insertions added to design so they can be added to both strands on a helix design.add_deletion(helix=0, offset=11) design.add_deletion(helix=0, offset=12) design.add_deletion(helix=0, offset=24) design.add_deletion(helix=1, offset=12) design.add_deletion(helix=1, offset=24) design.add_insertion(helix=0, offset=6, length=1) design.add_insertion(helix=0, offset=18, length=2) design.add_insertion(helix=1, offset=6, length=3) design.add_insertion(helix=1, offset=18, length=4) return design
def main(): return sc.DNADesign(strands=[], grid=sc.square)
def initial_design(): max_offset = 1295 helices = [ # below uses cadnano honeycomb coordinates # https://github.com/UC-Davis-molecular-computing/scadnano-python-package/blob/master/misc/cadnano-format-specs/v2.txt sc.Helix(grid_position=(1, 1, 0), max_offset=max_offset), sc.Helix(grid_position=(0, 1, 0), max_offset=max_offset), sc.Helix(grid_position=(0, 2, 0), max_offset=max_offset), sc.Helix(grid_position=(1, 2, 0), max_offset=max_offset), sc.Helix(grid_position=(2, 2, 0), max_offset=max_offset), sc.Helix(grid_position=(2, 1, 0), max_offset=max_offset), # below uses original mistaken convention from mistaken cadnano specs # sc.Helix(grid_position=(1, 0, 0), max_offset=max_offset), # sc.Helix(grid_position=(0, 0, 0), max_offset=max_offset), # sc.Helix(grid_position=(0, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(1, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 0, 0), max_offset=max_offset), # # below uses odd-q coordinates: # sc.Helix(grid_position=(1, -1, 0), max_offset=max_offset), # sc.Helix(grid_position=(0, 0, 0), max_offset=max_offset), # sc.Helix(grid_position=(0, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(1, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 0, 0), max_offset=max_offset), # below uses even-q coordinates: # sc.Helix(grid_position=(1, 0, 0), max_offset=max_offset), # sc.Helix(grid_position=(0, 0, 0), max_offset=max_offset), # sc.Helix(grid_position=(0, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(1, 2, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 0, 0), max_offset=max_offset), # below uses odd-r coordinates: # sc.Helix(grid_position=(1, 0, 0), max_offset=max_offset), # sc.Helix(grid_position=(0, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(1, 2, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 2, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 1, 0), max_offset=max_offset), # sc.Helix(grid_position=(2, 0, 0), max_offset=max_offset), ] scafs = [ sc.Strand([sc.Domain(helix=0, forward=True, start=16, end=1276)]), sc.Strand([sc.Domain(helix=1, forward=False, start=16, end=1276)]), sc.Strand([sc.Domain(helix=2, forward=True, start=12, end=1272)]), sc.Strand([sc.Domain(helix=3, forward=False, start=12, end=1272)]), sc.Strand([sc.Domain(helix=4, forward=True, start=19, end=1279)]), sc.Strand([sc.Domain(helix=5, forward=False, start=19, end=1279)]), ] staps = [ sc.Strand([sc.Domain(helix=0, forward=False, start=42, end=1246)]), sc.Strand([sc.Domain(helix=1, forward=True, start=42, end=1246)]), sc.Strand([sc.Domain(helix=2, forward=False, start=42, end=1246)]), sc.Strand([sc.Domain(helix=3, forward=True, start=42, end=1246)]), sc.Strand([sc.Domain(helix=4, forward=False, start=42, end=1246)]), sc.Strand([sc.Domain(helix=5, forward=True, start=42, end=1246)]), ] strands = scafs + staps return sc.DNADesign(helices=helices, strands=strands, grid=sc.honeycomb)
def main(): design = sc.DNADesign(helices=[], strands=[], grid=sc.square) return design
def create(*, num_helices: int, num_cols: int, assign_seq: bool = True, seam_left_column=-1, nick_pattern: NickPattern = NickPattern.staggered, twist_correction_deletion_spacing: int = 0, twist_correction_start_col: int = 1, twist_correction_deletion_offset=-1, num_flanking_columns: int = 1, num_flanking_helices=0, custom_scaffold: str = None, edge_staples: bool = True, scaffold_nick_offset: int = -1, use_idt_defaults: bool = False) -> sc.DNADesign: """ Creates a DNA origami rectangle with a given number of helices and "columns" (16-base-wide region in each helix). The columns include the 16-base regions on the end where potential "edge staples" go, as well as the two-column-wide "seam" region in the middle. Below is an example diagram of the staples created by this function. Consider for example the function call ``create(num_helices=8, num_cols=10, nick_pattern=origami_rectangle.staggered)``. The scaffold strand resulting from this call is shown below: .. code-block:: none # C0 # C1 # C2 # C3 # C4 # C5 # C6 # C7 # C8 # C9 # H0 +--------------- ---------------- ---------------- ---------------- ---------------- ---------------- ---------------- ---------------- ---------------- ---------------+ | | H1 +--------------- ---------------- ---------------- ---------------- ---------------+ +--------------- ---------------- ---------------- ---------------- ---------------+ | | H2 +--------------- ---------------- ---------------- ---------------- ---------------+ +--------------- ---------------- ---------------- ---------------- ---------------+ | | H3 +--------------- ---------------- ---------------- ---------------- ---------------+ +--------------- ---------------- ---------------- ---------------- ---------------+ | | H4 +--------------- ---------------- ---------------- ---------------- ---------------+ +--------------- ---------------- ---------------- ---------------- ---------------+ | | H5 +--------------- ---------------- ---------------- ---------------- ---------------+ +--------------- ---------------- ---------------- ---------------- ---------------+ | | H6 +--------------- ---------------- ---------------- ---------------- ---------------+ +--------------- ---------------- ---------------- ---------------- ---------------+ | | H7 +--------------- ---------------- ---------------- ---------------- ---------------] <--------------- ---------------- ---------------- ---------------- ---------------+ Helix indices are labelled ``H0``, ``H1``, ... and column indices are labeled ``C0``, ``C1``, ... Each single symbol ``-``, ``+``, ``<``, ``>``, ``[``, ``]``, ``+`` represents one DNA base, so each column is 16 bases wide. The ``#`` is a visual delimiter between columns and does not represent any bases, nor do spaces between the base-representing symbols. The 5' end of a strand is indicated with ``[`` or ``]`` and the 3' end is indicated with ``>`` or ``<``. A crossover is indicated with .. code-block:: none + | + Below are the staples resulting from this same call. .. code-block:: none # C0 # C1 # C2 # C3 # C4 # C5 # C6 # C7 # C8 # C9 # H0 <--------------+ +--------------- -------]<------+ +--------------- -------]<------+ +--------------- -------]<------+ +--------------- -------]<------+ +--------------] | | | | | | | | H1 [--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +--------------> | | | | | | | | H2 <--------------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------] | | | | | | | | H3 [--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +--------------> | | | | | | | | H4 <--------------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------] | | | | | | | | H5 [--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +------>[------+ +--------------+ +--------------> | | | | | | | | H6 <--------------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------+ +------]<------+ +--------------] | | | | | | | | H7 [--------------+ +------>[------- ---------------+ +------>[------- ---------------+ +------>[------- ---------------+ +------>[------- ---------------+ +--------------> The seam crosses columns ``C4`` and ``C5``. The left and right edge staples respectively are in columns ``C0`` and ``C9``. Prints warning if number of bases exceeds 7249 (length of standard M13 scaffold strand), but does not otherwise cause an error. `num_cols` must be even and at least 4. `seam_left_column` specifies the location of the seam. (i.e., scaffold crossovers in the middle of the origami.) If positive, the seam occupies two columns, and `seam_left_column` specifies the column on the left. To make the crossover geometry work out, a nonnegative `seam_left_column` must be even, greater than 0, and less than `num_helices` - 2. If negative, it is calculated automatically to be roughly in the middle. If `twist_correction_deletion_spacing` > 0, adds deletions between crossovers in one out of every `twist_correction_deletion_spacing` columns. (TODO: cite Sungwook's paper) `twist_correction_start_col` is ignored if `twist_correction_deletion_spacing` <= 0, otherwise it indicates the column at which to put the first deletions. Default = 1. `twist_correction_deletion_offset` is the *relative* offset of the deletion, relative to the left side of the column. `num_flanking_columns` is the number of empty columns on the helix on each side of the origami. `num_flanking_helices` is the number of empty helices above and below the origami. `nick_pattern` describes whether nicks between staples should be "staggered" or not. See :class:`origami_rectangle.NickPattern` for details. `custom_scaffold` is the scaffold sequence to use. If set to ``None``, the standard 7249-base M13 is used: :py:func:`scadnano.m13`. `edge_staples` indicates whether to include the edge staples. (Leaving them out prevents multiple origami rectangles from polymerizing in solution due to base stacking interactions on the left and right edges of the origami rectangle.) `scaffold_nick_offset` is the position of the "nick" on the scaffold (the M13 scaffold is circular, so for such a scaffold this really represents where any unused and undepicted bases of the scaffold will form a loop-out). If negative (default value) then it will be chosen to be along the origami seam. `use_idt_defaults`, if ``True``, creates an :py:class:`IDTFields` in each staple strand suitable for calling :py:meth:`DNADesign.write_idt_file` or :py:meth:`DNADesign.write_idt_plate_excel_file` . Here's an example of using :any:`origami_rectangle.create` to create a design for a 16-helix rectangle and write it to a file readable by scadnano. (By default the output file name is the same as the script calling :py:meth:`DNADesign.write_scadnano_file` but with the extension ``.py`` changed to ``.dna``.) .. code-block:: Python import origami_rectangle as rect # XXX: ensure num_cols is even since we divide it by 2 design = rect.create(num_helices=16, num_cols=24, nick_pattern=rect.staggered) design.write_scadnano_file() However, we caution that :py:func:`create` is not intended to be very extensible for creating many different types of DNA origami. It is more intended as an example whose source code can be an efficient reference to learn the :mod:`scadnano` API. """ # noqa (This line is here to suppress a PEP warning about long lines in the source code) if num_cols < 4: raise ValueError(f'num_cols must be at least 4 but is {num_cols}') # if num_cols % 4 != 2: # raise ValueError(f'num_cols must be congruent to 2 mod 4 (6, 10, 14, 18, 22, ...) but is {num_cols}') if num_cols % 2 != 0: raise ValueError(f'num_cols must be even, but is {num_cols}') if num_helices % 2 != 0: raise ValueError(f'num_helices must be even but is {num_helices}') if num_cols * num_helices * BASES_PER_COLUMN > 7249: print(f'WARNING: you chose {num_cols} columns and {num_helices} helices, ' f'which requires {num_cols * num_helices * BASES_PER_COLUMN} bases, ' f'greater than the 7249 available in standard M13.') if seam_left_column < 0: seam_left_column = num_cols // 2 - 1 if seam_left_column % 2 == 1: seam_left_column += 1 if seam_left_column % 2 == 1: raise ValueError(f'seam_left_column must be even but is {seam_left_column}') # allow empty "flanking" columns on each side num_bases_per_helix = BASES_PER_COLUMN * (num_cols + 2 * num_flanking_columns) # leftmost x offset offset_start = BASES_PER_COLUMN * num_flanking_columns # rightmost x offset offset_end = offset_start + BASES_PER_COLUMN * num_cols # x offset just to left of seam offset_mid = offset_start + BASES_PER_COLUMN * (seam_left_column + 1) helices = _create_helices(num_helices + 2 * num_flanking_helices, num_bases_per_helix) scaffold = _create_scaffold(offset_start, offset_end, offset_mid, num_helices, num_flanking_helices, scaffold_nick_offset) staples = _create_staples(offset_start, offset_end, offset_mid, num_helices, num_flanking_helices, num_cols, nick_pattern, edge_staples, use_idt_defaults) design = sc.DNADesign(helices=helices, strands=[scaffold] + staples, grid=sc.square) if twist_correction_deletion_spacing > 0: add_twist_correction_deletions(design=design, offset_start=offset_start, deletion_spacing=twist_correction_deletion_spacing, deletion_start_col=twist_correction_start_col, deletion_offset=twist_correction_deletion_offset, num_helices=num_helices, num_cols=num_cols, num_flanking_helices=num_flanking_helices) if assign_seq: scaffold_seq = sc.m13() if custom_scaffold is None else custom_scaffold design.assign_dna(scaffold, scaffold_seq) if use_idt_defaults: design.set_default_idt(True) scaffold.set_default_idt(False) return design