def initial_design() -> sc.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), max_offset=max_offset),
sc.Helix(grid_position=(0, 1), max_offset=max_offset),
sc.Helix(grid_position=(0, 2), max_offset=max_offset),
sc.Helix(grid_position=(1, 2), max_offset=max_offset),
sc.Helix(grid_position=(2, 2), max_offset=max_offset),
sc.Helix(grid_position=(2, 1), 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.Design(helices=helices, strands=strands, grid=sc.honeycomb)
def create_design() -> sc.Design:
length = 16
helices = [sc.Helix(max_offset=length, grid_position=(h, v))
for v in range(-4, 6) for h in range(-4, 6)]
design = sc.Design(helices=helices, strands=[], grid=sc.honeycomb)
return design
def create_design():
length = 10
helices = [
sc.Helix(max_offset=length,
position=sc.Position3D(x=0, y=0, z=2.5),
pitch=0,
roll=0,
yaw=0),
sc.Helix(max_offset=length,
position=sc.Position3D(x=3, y=3, z=0),
pitch=0,
roll=0,
yaw=0),
sc.Helix(max_offset=length,
position=sc.Position3D(x=8, y=-3, z=0),
pitch=0,
roll=0,
yaw=0),
sc.Helix(max_offset=length,
position=sc.Position3D(x=11, y=1, z=0),
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.Design(helices=helices, strands=strands, grid=sc.Grid.none)
return design
def create_design() -> sc.Design:
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
ss2 = sc.Domain(helix, forward, offset + 10, offset + 30)
ss1 = sc.Domain(helix + 1, forward, offset + 30, offset + 50)
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.Design(helices=helices, strands=strands, grid=sc.square)
return design
def create_design():
# 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.Design(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 create_design():
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, True, 0, bases // 3)
stap_left_ss_bot = sc.Domain(bot, False, 0, bases // 3)
stap_mid_ss_bot = sc.Domain(bot, False, bases // 3, bases * 2 // 3)
stap_mid_ss_top = sc.Domain(top, True, bases // 3, bases * 2 // 3)
stap_right_ss_top = sc.Domain(top, True, bases * 2 // 3, bases)
stap_right_ss_bot = sc.Domain(bot, False, 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.Design(helices=helices, strands=strands, grid=sc.square)
return design
def precursor_scaffolds() -> sc.Design:
#2D design has to be topologically a circle
helices = [sc.Helix(max_offset=int(block * cmax)) for _ in range(maxhelix)]
scaffolds = []
for helix in range(len(img)):
if (1 in img[helix]):
for dom in range(len(img[helix])):
if (img[helix][dom] == 1) and (img[helix][dom - 1] == 0):
start = block * dom
if (img[helix][dom] == 0) and (img[helix][dom - 1] == 1):
end = block * dom
scaffolds.append(
sc.Strand([
sc.Domain(helix=2 * helix,
forward=((2 * helix) % 2 == 0),
start=start,
end=end)
]))
scaffolds.append(
sc.Strand([
sc.Domain(helix=(2 * helix) + 1,
forward=((2 * helix + 1) % 2 == 0),
start=start,
end=end)
]))
return sc.Design(helices=helices, strands=scaffolds, grid=sc.square)
def create_design() -> sc.Design:
helices = []
num_helices, max_bases = 30, 2000
for _ in range(num_helices):
helices.append(sc.Helix(max_bases))
design = sc.Design(helices=helices, strands=[], grid=sc.square)
return design
def create_design():
length = 16
helices = [
sc.Helix(max_offset=length, grid_position=(h, v)) for v in range(10)
for h in range(10)
]
design = sc.Design(helices=helices, strands=[], grid=sc.hexagonal)
return design
def create_design() -> sc.Design:
helices = [sc.Helix(max_offset=24) for _ in range(2)]
design = sc.Design(helices=helices, grid=sc.square)
design.strand(0, 0).move(8).cross(1).move(-8).as_circular()
design.strand(0, 8).move(8).loopout(1, 5).move(-8).as_circular()
design.strand(0, 16).move(8).cross(1).move(-8)
return design
def create_design() -> sc.Design:
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.Design(strands=[hairpin], grid=sc.square)
design.assign_dna(hairpin, 'AAAAACCCCCTGCAT')
return design
def create_design() -> sc.Design:
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.Design(helices=helices, strands=[])
# design.set_helices_view_order([5, 2, 11, 3, 7])
return design
def create_design():
length = 9
helices = [sc.Helix(max_offset=length, roll=90)]
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.Design(helices=helices, strands=strands, grid=sc.square)
design.assign_dna(scaf, 'AACT' * (length // 4))
return design
def create_design() -> sc.Design:
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.Design(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 create_design() -> sc.Design:
# 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.Design(strands=[strand_multi, strand_single], grid=sc.square)
return design
def create_design() -> sc.Design:
helices = [sc.Helix(max_offset=288) for _ in range(24)]
design = sc.Design(helices=helices, grid=sc.square)
add_scaffold_precursors(design)
add_scaffold_crossovers(design)
add_staple_precursors(design)
add_staple_crossovers(design)
add_staple_nicks(design)
add_twist_correction_deletions(design)
design.assign_m13_to_scaffold()
return design
def main():
helices = [sc.Helix(0, 25), sc.Helix(1, 25)]
s1_left_ss0 = sc.Domain(0, sc.reverse, 0, 5)
s1_ss1 = sc.Domain(0, sc.forward, 0, 15)
s1_right_ss0 = sc.Domain(0, sc.reverse, 5, 15)
s1 = sc.Strand([s1_left_ss0, s1_ss1, s1_right_ss0])
s2_ss1 = sc.Domain(0, sc.forward, 10, 20)
s2_ss0 = sc.Domain(0, sc.reverse, 10, 20)
s2 = sc.Strand([s2_ss1, s2_ss0])
strands = [s1, s2]
design = sc.Design(helices=helices, strands=strands, grid=sc.square)
return design
def create_design():
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.Design(helices=helices, strands=strands, grid=sc.Grid.square)
return design
def create_design():
length = 9
helices = [
sc.Helix(max_offset=length,
major_ticks=[2, 5],
position=sc.Position3D(x=1, y=2, z=3),
pitch=90)
]
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.Design(helices=helices, strands=strands, grid=sc.Grid.none)
design.assign_dna(scaf, 'AACT' * (length // 4))
return design
def create_design():
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.Design(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 create_design() -> sc.Design:
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(), name='s1_r')
s2_r = sc.Strand([ss2_r], idt=sc.IDTFields(), name='s1_r')
s3_r = sc.Strand([ss3_r], idt=sc.IDTFields(), name='s1_r')
s_l = sc.Strand([ss_l], idt=sc.IDTFields(), name='s_l')
strands = [s1_r, s2_r, s3_r, s_l]
design = sc.Design(strands=strands, grid=sc.square)
design.assign_dna(s_l, 'AGTT'*3)
return design
def create_helices(shape_outline, lattice, hex_or_square) -> sc.Design:
"""Given the outline, complete lattice, and if the lattice is hex or square, creates the base helices without any strands"""
if hex_or_square == 'hex':
grid_type = sc.hexagonal
elif hex_or_square == 'square':
grid_type = sc.square
else:
raise Exception("Error in create_helices(), input for hex_or_square must be eihter 'hex' or 'square'")
max_offset = sc_general.find_max(shape_outline)
size = len(lattice)
helices = []
for i in range(size):
position = lattice[i]
helices.append(sc.Helix(max_offset = max_offset, grid_position = position))
design = sc.Design(helices = helices, strands = [], grid = grid_type)
return design
def create_design() -> sc.Design:
num_domains = 9
helices = [sc.Helix(max_offset=(num_domains) * 8)]
design: sc.Design = sc.Design(helices=helices, strands=[], grid=sc.square)
design.strand(0, (num_domains - 1) * 8) \
.move(-8).with_domain_name('domain 8*') \
.move(-8).with_domain_name('domain 7*') \
.move(-8).with_domain_name('domain 6*') \
.move(-8).with_domain_name('domain 5*') \
.move(-8).with_domain_name('domain 4*') \
.move(-8).with_domain_name('domain 3*') \
.move(-8).with_domain_name('domain 2*') \
.move(-8).with_domain_name('domain 1*') \
.with_name('bottom strand')
# domain names match
design.strand(
0, 0).move(8).with_domain_name('domain 1').with_name('top strand 1')
# domains are aligns but names mismatch
design.strand(
0, 8).move(8).with_domain_name('domain 50').with_name('top strand 2')
# domain names match
design.strand(
0, 16).move(8).with_domain_name('domain 3').with_name('top strand 3')
# domain names are the same, not complementary
design.strand(
0, 24).move(8).with_domain_name('domain 4*').with_name('top strand 4')
# domain names match but domains are mis-aligned
design.strand(
0, 32).move(9).with_domain_name('domain 5').with_name('top strand 5')
# domain names match but domains are mis-aligned
design.strand(
0, 48).move(7).with_domain_name('domain 7').with_name('top strand 7')
# no overlap so no mismatch
design.strand(
0, 64).move(8).with_domain_name('domain 9').with_name('top strand 9')
return design
def create_design():
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.Design(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 create_design() -> sc.Design:
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=3, y=3, z=0),
min_offset=8),
sc.Helix(major_tick_distance=4, max_offset=length, position=sc.Position3D(x=8, y=-3, z=2.5),
min_offset=0),
sc.Helix(major_tick_distance=4, max_offset=length, position=sc.Position3D(x=11, y=1, z=2.5),
min_offset=8),
]
design = sc.Design(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 create_design() -> sc.Design:
# helices
helices = [sc.Helix(max_offset=48), sc.Helix(max_offset=48)]
# whole design
design = sc.Design(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 create_design():
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.Design(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 create_design():
# 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],
label='left staple')
# 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],
label='right staple')
# 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,
label='scaffold label')
# whole design
design = sc.Design(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 create_design() -> sc.Design:
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(plate=f'plate{plate}', well=well)
strand = sc.Strand(domains=[ss_f, ss_r], idt=idt, name=f'staple{s}')
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.Design(strands=strands, grid=sc.square)
design.assign_m13_to_scaffold()
return design
def create_design() -> sc.Design:
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.Design(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