def bases_are_stacked(bases):
"""
Say whether two Base5_recognizers' bases are in helices, and stacked (one to the other).
For now, this means they have Ax (axis) pseudoatoms which are directly bonded (but not the same atom).
@warning: This is not a sufficient condition, since it doesn't say whether they're on the same "side" of the helix!
Unfortunately that is not easy to tell (or even define, in the present model)
since it does not necessarily mean the same strand (in the case of a crossover at that point).
I [bruce 070604] think there is no local definition of this property which handles that case.
I'm not sure whether this leads to any problems with when to offer Make or Remove Crossover --
maybe the overall conditions end up being sufficient; this needs review.
Also, I'm not yet sure how big a deficiency it is in our model.
"""
try:
len(bases)
except:
print "following exception concerns bases == %r" % (bases, )
assert len(
bases) == 2, "bases == %r should be a sequence of length 2" % (bases, )
for b in bases:
assert isinstance(b, Base5_recognizer)
for b in bases:
if not b.in_helix: # i.e. b.axis_atom is not None
return False
b1, b2 = bases
return b1.axis_atom is not b2.axis_atom and atoms_are_bonded(
b1.axis_atom, b2.axis_atom)
def align_to_basepair(self, other, guess_from_geometry=True, axis_unbonded_ok=False):
"""
Switch our strands if necessary so as to align them
to the given other BasePair (which must be stacked to us by an axis bond),
in terms of backbone bonding.
@param other: another basepair. We modify self, not other, to do the alignment.
@type other: BasePair (same class as self)
@param guess_from_geometry: If there is no backbone bonding, this option (when true, the default)
permits us to use geometric info to
guess strand correspondence for doing the alignment. Our return value will be True if we did that.
(If we have to but can't, we raise DnaGeometryError.)
@param axis_unbonded_ok: default False; if true, permits axis atoms
to be unbonded. We pretend they are going to become bonded in order
to do our work, but don't change them.
@return: whether we had to guess from geometry, and did so successfully.
"""
if not axis_unbonded_ok:
assert atoms_are_bonded(self.axis_atom, other.axis_atom)
# TODO: just look for bonds (direct or via Pl) between the 4 involved strand atoms;
# exception if anything is inconsistent.
assert 0 # nim
def align_to_basepair(self, other, guess_from_geometry = True, axis_unbonded_ok = False):
"""
Switch our strands if necessary so as to align them
to the given other BasePair (which must be stacked to us by an axis bond),
in terms of backbone bonding.
@param other: another basepair. We modify self, not other, to do the alignment.
@type other: BasePair (same class as self)
@param guess_from_geometry: If there is no backbone bonding, this option (when true, the default)
permits us to use geometric info to
guess strand correspondence for doing the alignment. Our return value will be True if we did that.
(If we have to but can't, we raise DnaGeometryError.)
@param axis_unbonded_ok: default False; if true, permits axis atoms
to be unbonded. We pretend they are going to become bonded in order
to do our work, but don't change them.
@return: whether we had to guess from geometry, and did so successfully.
"""
if not axis_unbonded_ok:
assert atoms_are_bonded( self.axis_atom, other.axis_atom )
# TODO: just look for bonds (direct or via Pl) between the 4 involved strand atoms;
# exception if anything is inconsistent.
assert 0 # nim
def bases_are_stacked(bases):
"""
Say whether two Base5_recognizers' bases are in helices, and stacked (one to the other).
For now, this means they have Ax (axis) pseudoatoms which are directly bonded (but not the same atom).
@warning: This is not a sufficient condition, since it doesn't say whether they're on the same "side" of the helix!
Unfortunately that is not easy to tell (or even define, in the present model)
since it does not necessarily mean the same strand (in the case of a crossover at that point).
I [bruce 070604] think there is no local definition of this property which handles that case.
I'm not sure whether this leads to any problems with when to offer Make or Remove Crossover --
maybe the overall conditions end up being sufficient; this needs review.
Also, I'm not yet sure how big a deficiency it is in our model.
"""
try:
len(bases)
except:
print "following exception concerns bases == %r" % (bases,)
assert len(bases) == 2, "bases == %r should be a sequence of length 2" % (bases,)
for b in bases:
assert isinstance(b, Base5_recognizer)
for b in bases:
if not b.in_helix: # i.e. b.axis_atom is not None
return False
b1, b2 = bases
return b1.axis_atom is not b2.axis_atom and atoms_are_bonded(b1.axis_atom, b2.axis_atom)
def bond_cost(atm1, atm2):
"""
Return total cost of hypothetical new bond between two atoms, or None if bond is not permitted or already there
"""
if not (bondable_atm(atm1) and bondable_atm(atm2)): # check valence of existing bonds
return None
if atoms_are_bonded(atm1, atm2): # already bonded? (redundant after list-potential-bonds) ###
return None
distance = atm_distance(atm1, atm2)
# note the assumption that we are talking about SINGLE bonds, which runs throughout this code
# some day we should consider the possibility of higher-order bonds; a stab in this direction
# is the bondtyp argument in make_bonds(), but that's really a kludge
best_dist = idealBondLength(atm1, atm2)
# previously: best_dist = covalent_radius(atm1) + covalent_radius(atm2)
if not best_dist:
return None # avoid ZeroDivision exception from pondering a He-He bond
ratio = distance / best_dist # best_dist is always a float, so this is never "integer division"
dc = atm_distance_cost(atm1, atm2, ratio)
if dc is None:
return None
ac = atm_angle_cost(atm1, atm2, ratio)
if ac is None:
return None
ec = bond_element_cost(atm1, atm2)
return ac + dc + ec
def make_or_remove_crossover(twoPls, make=True, cmdname=None):
"""
Make or Remove (according to make option) a crossover, given Pl5_recognizers for its two Pl atoms.
"""
# What we are doing is recognizing one local structure and replacing it with another
# made from the same atoms. It'd sure be easier if I could do the manipulation in an mmp file,
# save that somewhere, and read those to generate the operation! I'd have two sets of atoms, before and after,
# and see how bonds and atomtypes got changed.
# In this case it's not too hard to hand-code... I guess only the Pl atoms and their bonds are affected.
# We probably do have to look at strand directions -- hmm, probably we should require them to exist before saying it's ok!
# Or maybe better to give history error message when the command is chosen, saying you need to set them (or repair them) first...
# Then we have to move the new/moved Pl atoms into a good position...
# Note: Pl.ordered_bases are ordered by bond direction, to make this easier...
# but if we want to patch up the directions in the end, do we need to care exactly which ones were defined?
# or only "per-Pl"? hmm... it's per-Pl for now
assert cmdname
for pl in twoPls:
if pl.ordered_bases is None: # should no longer be possible -- now checked before menu commands are offered [bruce 070604]
###BUG: this could have various causes, not only the one reported below! Somehow we need access to the
# message supplied to the RecognizerError, for use here.
###REVIEW: Does that mean it should pass through compute methods (probably in a controlled way)
# rather than making computed values None?
# Or, should the value not be None, but a "frozen" examinable and reraisable version of the error exception??
msg = "%s: Error: bond direction is locally undefined or inconsistent around %s" % (
cmdname, pl.atom) ###UNTESTED
print "should no longer be possible:", msg #bruce 070604
env.history.message(redmsg(quote_html(msg)))
return
Pl1, Pl2 = twoPls
a, b = Pl1.ordered_bases
d, c = Pl2.ordered_bases # note: we use d,c rather than c,d so that the atom arrangement is as shown in the diagram below.
# Note: for either the Make or Remove operation, the geometric arrangement is initially:
#
# c <-- Pl2 <-- d
#
# a --> Pl1 --> b
#
# and it ends up being (where dots indicate arrowheads, to show bond direction):
#
# c d
# . /
# \ .
# Pl1 Pl2
# . \
# / .
# a b
#
# Note: Pl1 stays attached to a, and Pl2 to d. Which two opposite bonds to preserve like that
# is an arbitrary choice -- as long as Make and Remove make the same choice about that,
# they'll reverse each other's effects precisely (assuming the sugars were initially correct as Ss or Sj).
# break the bonds we no longer want
for obj1, obj2 in [(Pl1, b), (Pl2, c)]:
bond = find_bond(obj1.atom, obj2.atom)
bond.bust(make_bondpoints=False)
# make the bonds we want and didn't already have
for obj1, obj2 in [(Pl1, c), (Pl2, b)]:
assert not atoms_are_bonded(obj1.atom, obj2.atom)
###e we should make bond_atoms do this assert itself, or maybe tolerate it (or does it already??)
bond_atoms_faster(obj1.atom, obj2.atom, V_SINGLE)
# set directions of all 4 bonds (even the preserved ones -- it's possible they were not set before,
# if some but not all bonds had directions set in the part of a strand whose directions we look at.)
for obj1, obj2 in [(a, Pl1), (Pl1, c), (d, Pl2), (Pl2, b)]:
bond = find_bond(obj1.atom, obj2.atom)
bond.set_bond_direction_from(obj1.atom, 1)
# WARNING: after that bond rearrangement, don't use our Pl5_recognizers in ways that depend on Pl bonding,
# since it's not well defined whether they think about the old or new bonding to give their answers.
Pl_atoms = Pl1.atom, Pl2.atom
del Pl1, Pl2, twoPls
# transmute base sugars to Sj or Ss as appropriate
if dna_updater_is_enabled():
want = Element_Ss5 #bruce 080320 bugfix
else:
want = make and Element_Sj5 or Element_Ss5
for obj in (a, b, c, d):
obj.atom.Transmute(want)
# Note: we do this after the bond making/breaking so it doesn't add singlets which mess us up.
# move Pl atoms into better positions
# (someday, consider using local minimize; for now, just place them directly between their new neighbor atoms,
# hopefully we leave them selected so user can easily do their own local minimize.)
for pl in Pl_atoms:
pl.setposn(
average_value(map(lambda neighbor: neighbor.posn(),
pl.neighbors())))
env.history.message(
greenmsg(cmdname + ": ") + quote_html("(%s - %s)" % tuple(Pl_atoms)))
#e need assy.changed()? evidently not.
return # from make_or_remove_crossover
def populate(self, mol, length, bn_members = False):
def add(element, x, y, z, atomtype='sp2'):
atm = Atom(element, V(x, y, z), mol)
atm.set_atomtype_but_dont_revise_singlets(atomtype)
return atm
evenAtomDict = { }
oddAtomDict = { }
bondDict = { }
mfirst = [ ]
mlast = [ ]
for n in range(self.n):
mmin, mmax = self.mlimits(-.5 * length, .5 * length, n)
mfirst.append(mmin)
mlast.append(mmax)
for m in range(mmin, mmax+1):
x, y, z = self.xyz(n, m)
if bn_members:
atm = add("B", x, y, z)
else:
atm = add("C", x, y, z)
evenAtomDict[(n,m)] = atm
bondDict[atm] = [(n,m)]
x, y, z = self.xyz(n+1./3, m+1./3)
if bn_members:
atm = add("N", x, y, z, 'sp3')
else:
atm = add("C", x, y, z)
oddAtomDict[(n,m)] = atm
bondDict[atm] = [(n+1, m), (n, m+1)]
# m goes axially along the nanotube, n spirals around the tube
# like a barber pole, with slope depending on chirality. If we
# stopped making bonds now, there'd be a spiral strip of
# missing bonds between the n=self.n-1 row and the n=0 row.
# So we need to connect those. We don't know how the m values
# will line up, so the first time, we need to just hunt for the
# m offset. But then we can apply that constant m offset to the
# remaining atoms along the strip.
n = self.n - 1
mmid = (mfirst[n] + mlast[n]) / 2
atm = oddAtomDict[(n, mmid)]
class FoundMOffset(Exception): pass
try:
for m2 in range(mfirst[0], mlast[0] + 1):
atm2 = evenAtomDict[(0, m2)]
diff = atm.posn() - atm2.posn()
if dot(diff, diff) < self.maxlensq:
moffset = m2 - mmid
# Given the offset, zipping up the rows is easy.
for m in range(mfirst[n], mlast[n]+1):
atm = oddAtomDict[(n, m)]
bondDict[atm].append((0, m + moffset))
raise FoundMOffset()
# If we get to this point, we never found m offset.
# If this ever happens, it indicates a bug.
raise Exception, "can't find m offset"
except FoundMOffset:
pass
# Use the bond information to bond the atoms
for (dict1, dict2) in [(evenAtomDict, oddAtomDict),
(oddAtomDict, evenAtomDict)]:
for n, m in dict1.keys():
atm = dict1[(n, m)]
for n2, m2 in bondDict[atm]:
try:
atm2 = dict2[(n2, m2)]
if not atoms_are_bonded(atm, atm2):
if bn_members:
bond_atoms(atm, atm2, V_SINGLE)
else:
bond_atoms(atm, atm2, V_GRAPHITE)
except KeyError:
pass
def _f_update_neighbor_baseatoms(self):
"""
[friend method for dna updater]
This must be called at least once per ladder rail chain
(i.e. _DnaChainFragment object, I think, 080116),
during each dna updater run which encounters it (whether as a
new or preexisting rail chain).
It computes or recomputes whichever attributes carry info about
the neighboring baseatoms in neighboring rail chains (which
connect to self at the ends), based on current bonding.
Specifically, it sets self.neighbor_baseatoms[end] for end in LADDER_ENDS
to either None (if this chain ends on that ladder-end) or to the
next atom in the next chain (if it doesn't end). (Atoms with
_dna_updater__error set are not allowed as "next atoms" -- None will
be set instead.)
For end atom order (used as index in self.neighbor_baseatoms),
it uses whatever order has been established by the DnaLadder
we're in, which may or may not have reversed our order. (Ladders
have been made, finished, and merged, before we're called.)
For strands, it finds neighbors using bond direction, and knows
about skipping Pl atoms; for axes, in the ambiguous length==1 case,
it uses an arbitrary order, but
makes sure this is consistent with strands when at least one strand
has no nick at one end of this chain's ladder. [#todo: explain better]
If this doesn't force an order, then if this had already been set
before this call and either of the same non-None atoms are still
in it now, preserve their position.
The attrs we set are subsequently reversed by our methods
_f_reverse_arbitrary_bond_direction and reverse_baseatoms.
[###REVIEW whether it's correct in _f_reverse_arbitrary_bond_direction;
see comment there.]
@note: the ordering/reversal scheme described above may need
revision. The special case for length==1 axis described above is
meant to ensure
that axis and strand order correspond between two ladders which
are connected on the axis and one strand, but not the other strand
(i.e. which have an ordinary nick), if the ladder we're on has length 1
(i.e. if there are two nicks in a row, on the same or opposite strands).
If this ever matters, we might need to straighten out this order
in DnaLadder.finished() for length==1 ladders. The ladders are already
made and merged by the time we're called, so whatever reversals they'll
do are already done. [update, 080602: this was implemented today,
to fix a bug; no change to DnaLadder.finished() seemed to be needed.]
"""
assert self.strandQ in (False, True)
self.neighbor_baseatoms = list(self.neighbor_baseatoms)
# do most atoms one end at a time...
for end in LADDER_ENDS: # end_baseatoms needs ladder end, not chain end
next_atom = -1 # will be set to None or an atom, if possible
if self.strandQ:
# similar to code in DnaLadder._can_merge_at_end
end_atom = self.end_baseatoms()[end]
assert self._bond_direction
# relative to LADDER_ENDS directions
# (since that's in the same direction as our baseatoms array)
# (review: not 100% sure this is set yet;
# but the assert is now old and has never failed)
if end == LADDER_END0:
arrayindex_dir_to_neighbor = -1
else:
arrayindex_dir_to_neighbor = 1
bond_dir_to_neighbor = self._bond_direction * arrayindex_dir_to_neighbor
next_atom = end_atom.strand_next_baseatom(
bond_direction=bond_dir_to_neighbor)
assert next_atom is None or next_atom.element.role == 'strand'
# (note: strand_next_baseatom returns None if end_atom or the atom it
# might return has ._dna_updater__error set.)
# store next_atom at end of loop
if len(self.baseatoms) > 1: #080602 debug code
if arrayindex_dir_to_neighbor == 1:
next_interior_atom = self.baseatoms[1]
else:
next_interior_atom = self.baseatoms[-2]
if next_interior_atom is next_atom:
print "\n*** PROBABLE BUG: next_interior_atom is next_atom %r for end_atom %r in %r" % \
(next_atom, end_atom, self)
pass
else:
# do axis atoms in this per-end loop, only if chain length > 1;
# otherwise do them both at once, after this loop.
if len(self.baseatoms) > 1:
# easy case - unambiguous other-chain neighbor atom
# (Note: length-2 axis ring is not possible, since it would
# require two bonds between the same two Ax pseudoatoms.
# It's also not physically possible, so that's fine.)
end_atom = self.end_baseatoms()[end]
next_atom_candidates = end_atom.axis_neighbors(
) # len 1 or 2,
# and one should always be the next one in this chain
# (I guess it can't have _dna_updater__error set,
# since such atoms are not made into chains;
# so I assert this, 080206);
# the other one (if present) might have it set
if end == LADDER_END0:
next_to_end_index = 1
else:
next_to_end_index = -2
not_this_atom = self.baseatoms[next_to_end_index]
assert not not_this_atom._dna_updater__error # 080206
next_atom_candidates.remove(not_this_atom)
# it has to be there, so we don't mind raising an
# exception when it's not
assert len(next_atom_candidates) <= 1, \
"too many candidates: %r" % (next_atom_candidates,)
# Note: got exception here when lots of Ss had two
# Ax neighbors due to errors in an mmp file;
# assertion message untested [080304]
if next_atom_candidates:
next_atom = next_atom_candidates[0]
if next_atom._dna_updater__error:
## print "avoiding bug 080206 by not seeing next axis atom with error", next_atom
next_atom = None
else:
next_atom = None
pass
pass
if next_atom != -1:
self.neighbor_baseatoms[end] = next_atom # None or an atom
assert next_atom is None or not next_atom._dna_updater__error # 080206
if DEBUG_NEIGHBOR_BASEATOMS:
msg = "set %r.neighbor_baseatoms[%r] = %r, whole list is now %r" % \
(self, end, next_atom, self.neighbor_baseatoms)
print_compact_stack("\n" + msg + ": ")
continue
# ... but in length==1 case, do axis atoms both at once
if not self.strandQ and len(self.baseatoms) == 1:
end_atom = self.baseatoms[0]
next_atoms = end_atom.axis_neighbors() # len 0 or 1 or 2
# remove atoms with errors [fix predicted bug, 080206]
# (review: should axis_neighbors, or a variant method, do this?)
###### SHOULD REVIEW ALL USES OF axis_neighbors FOR NEEDING THIS @@@@@
next_atoms = filter(lambda atom: not atom._dna_updater__error,
next_atoms)
while len(next_atoms) < 2:
next_atoms.append(None)
# if order matters, reverse this here, if either strand
# in the same ladder indicates we ought to, by its next atom
# bonding to one of these atoms (having no nick); I think any
# advice we get from this (from 1 of 4 possible next atoms)
# can't be inconsistent, but I haven't proved this. (Certainly
# it can't be for physically reasonable structures.)
# [bruce 080116 proposed, bruce 080602 implemented, as bugfix]
order_was_forced_by_strands = False # might be set below
try:
# very near a release, so cause no new harm...
ladder = rail_end_atom_to_ladder(end_atom)
assert self is ladder.axis_rail
evidence_counters = [0, 0] # [wrong order, right order]
for strand in ladder.strand_rails:
strand._f_update_neighbor_baseatoms()
# redundant with caller, but necessary since we don't
# know whether it called this already or not;
# calling it twice on a strand is ok (2nd call is a noop);
# not important to optimize since length-1 ladders are rare.
for strand_end in LADDER_ENDS:
for axis_end in LADDER_ENDS:
axis_next_atom = next_atoms[
axis_end] # might be None
strand_next_atom = strand.neighbor_baseatoms[
strand_end] # might be None
if axis_next_atom and strand_next_atom and \
atoms_are_bonded( axis_next_atom, strand_next_atom):
evidence_counters[strand_end == axis_end] += 1
continue
continue
continue
badvote, goodvote = evidence_counters
# note: current order of next_atoms is arbitrary,
# so we need symmetry here between badvote and goodvote
if badvote != goodvote:
if badvote > goodvote:
next_atoms.reverse()
badvote, goodvote = goodvote, badvote
pass
order_was_forced_by_strands = True
if badvote and goodvote:
# should never happen for physically reasonable structures,
# but is probably possible for nonsense structures
print "\nBUG or unreasonable structure: " \
"badvote %d goodvote %d for next_atoms %r " \
"around %r with %r" % \
(badvote, goodvote, next_atoms, self, end_atom)
pass
pass
except:
msg = "\n*** BUG: ignoring exception while disambiguating " \
"next_atoms %r around %r with %r" % \
(next_atoms, self, end_atom)
print_compact_traceback(msg + ": ")
pass
reverse_count = 0 # for debug prints only
if not order_was_forced_by_strands:
# For stability of arbitrary choices in case self.neighbor_baseatoms
# was already set, let non-None atoms still in it determine the order
# to preserve their position, unless the order was forced above.
for end in LADDER_ENDS:
old_atom = self.neighbor_baseatoms[end]
if old_atom and old_atom is next_atoms[1 - end]:
assert old_atom != -1 # next_atoms can't contain -1
next_atoms.reverse() # (this can't happen twice)
reverse_count += 1
self.neighbor_baseatoms = next_atoms
if DEBUG_NEIGHBOR_BASEATOMS:
msg = "set %r.neighbor_baseatoms = next_atoms %r, " \
"order_was_forced_by_strands = %r, reverse_count = %r" % \
(self, next_atoms, order_was_forced_by_strands, reverse_count)
print_compact_stack("\n" + msg + ": ")
pass
pass
# we're done
assert len(self.neighbor_baseatoms) == 2
assert type(self.neighbor_baseatoms) == type([])
for atom in self.neighbor_baseatoms:
assert atom is None or atom.element.role in ['axis', 'strand']
# note: 'unpaired-base' won't appear in any chain
return # from _f_update_neighbor_baseatoms
def populate(self, mol, length, bn_members=False):
def add(element, x, y, z, atomtype='sp2'):
atm = Atom(element, V(x, y, z), mol)
atm.set_atomtype_but_dont_revise_singlets(atomtype)
return atm
evenAtomDict = {}
oddAtomDict = {}
bondDict = {}
mfirst = []
mlast = []
for n in range(self.n):
mmin, mmax = self.mlimits(-.5 * length, .5 * length, n)
mfirst.append(mmin)
mlast.append(mmax)
for m in range(mmin, mmax + 1):
x, y, z = self.xyz(n, m)
if bn_members:
atm = add("B", x, y, z)
else:
atm = add("C", x, y, z)
evenAtomDict[(n, m)] = atm
bondDict[atm] = [(n, m)]
x, y, z = self.xyz(n + 1. / 3, m + 1. / 3)
if bn_members:
atm = add("N", x, y, z, 'sp3')
else:
atm = add("C", x, y, z)
oddAtomDict[(n, m)] = atm
bondDict[atm] = [(n + 1, m), (n, m + 1)]
# m goes axially along the nanotube, n spirals around the tube
# like a barber pole, with slope depending on chirality. If we
# stopped making bonds now, there'd be a spiral strip of
# missing bonds between the n=self.n-1 row and the n=0 row.
# So we need to connect those. We don't know how the m values
# will line up, so the first time, we need to just hunt for the
# m offset. But then we can apply that constant m offset to the
# remaining atoms along the strip.
n = self.n - 1
mmid = (mfirst[n] + mlast[n]) / 2
atm = oddAtomDict[(n, mmid)]
class FoundMOffset(Exception):
pass
try:
for m2 in range(mfirst[0], mlast[0] + 1):
atm2 = evenAtomDict[(0, m2)]
diff = atm.posn() - atm2.posn()
if dot(diff, diff) < self.maxlensq:
moffset = m2 - mmid
# Given the offset, zipping up the rows is easy.
for m in range(mfirst[n], mlast[n] + 1):
atm = oddAtomDict[(n, m)]
bondDict[atm].append((0, m + moffset))
raise FoundMOffset()
# If we get to this point, we never found m offset.
# If this ever happens, it indicates a bug.
raise Exception, "can't find m offset"
except FoundMOffset:
pass
# Use the bond information to bond the atoms
for (dict1, dict2) in [(evenAtomDict, oddAtomDict),
(oddAtomDict, evenAtomDict)]:
for n, m in dict1.keys():
atm = dict1[(n, m)]
for n2, m2 in bondDict[atm]:
try:
atm2 = dict2[(n2, m2)]
if not atoms_are_bonded(atm, atm2):
if bn_members:
bond_atoms(atm, atm2, V_SINGLE)
else:
bond_atoms(atm, atm2, V_GRAPHITE)
except KeyError:
pass
def make_or_remove_crossover(twoPls, make = True, cmdname = None):
"""
Make or Remove (according to make option) a crossover, given Pl5_recognizers for its two Pl atoms.
"""
# What we are doing is recognizing one local structure and replacing it with another
# made from the same atoms. It'd sure be easier if I could do the manipulation in an mmp file,
# save that somewhere, and read those to generate the operation! I'd have two sets of atoms, before and after,
# and see how bonds and atomtypes got changed.
# In this case it's not too hard to hand-code... I guess only the Pl atoms and their bonds are affected.
# We probably do have to look at strand directions -- hmm, probably we should require them to exist before saying it's ok!
# Or maybe better to give history error message when the command is chosen, saying you need to set them (or repair them) first...
# Then we have to move the new/moved Pl atoms into a good position...
# Note: Pl.ordered_bases are ordered by bond direction, to make this easier...
# but if we want to patch up the directions in the end, do we need to care exactly which ones were defined?
# or only "per-Pl"? hmm... it's per-Pl for now
assert cmdname
for pl in twoPls:
if pl.ordered_bases is None: # should no longer be possible -- now checked before menu commands are offered [bruce 070604]
###BUG: this could have various causes, not only the one reported below! Somehow we need access to the
# message supplied to the RecognizerError, for use here.
###REVIEW: Does that mean it should pass through compute methods (probably in a controlled way)
# rather than making computed values None?
# Or, should the value not be None, but a "frozen" examinable and reraisable version of the error exception??
msg = "%s: Error: bond direction is locally undefined or inconsistent around %s" % (cmdname, pl.atom) ###UNTESTED
print "should no longer be possible:", msg #bruce 070604
env.history.message( redmsg( quote_html( msg)))
return
Pl1, Pl2 = twoPls
a,b = Pl1.ordered_bases
d,c = Pl2.ordered_bases # note: we use d,c rather than c,d so that the atom arrangement is as shown in the diagram below.
# Note: for either the Make or Remove operation, the geometric arrangement is initially:
#
# c <-- Pl2 <-- d
#
# a --> Pl1 --> b
#
# and it ends up being (where dots indicate arrowheads, to show bond direction):
#
# c d
# . /
# \ .
# Pl1 Pl2
# . \
# / .
# a b
#
# Note: Pl1 stays attached to a, and Pl2 to d. Which two opposite bonds to preserve like that
# is an arbitrary choice -- as long as Make and Remove make the same choice about that,
# they'll reverse each other's effects precisely (assuming the sugars were initially correct as Ss or Sj).
# break the bonds we no longer want
for obj1, obj2 in [(Pl1, b), (Pl2, c)]:
bond = find_bond(obj1.atom, obj2.atom)
bond.bust(make_bondpoints = False)
# make the bonds we want and didn't already have
for obj1, obj2 in [(Pl1, c), (Pl2, b)]:
assert not atoms_are_bonded(obj1.atom, obj2.atom)
###e we should make bond_atoms do this assert itself, or maybe tolerate it (or does it already??)
bond_atoms_faster(obj1.atom, obj2.atom, V_SINGLE)
# set directions of all 4 bonds (even the preserved ones -- it's possible they were not set before,
# if some but not all bonds had directions set in the part of a strand whose directions we look at.)
for obj1, obj2 in [(a, Pl1), (Pl1, c), (d, Pl2), (Pl2, b)]:
bond = find_bond(obj1.atom, obj2.atom)
bond.set_bond_direction_from(obj1.atom, 1)
# WARNING: after that bond rearrangement, don't use our Pl5_recognizers in ways that depend on Pl bonding,
# since it's not well defined whether they think about the old or new bonding to give their answers.
Pl_atoms = Pl1.atom, Pl2.atom
del Pl1, Pl2, twoPls
# transmute base sugars to Sj or Ss as appropriate
if dna_updater_is_enabled():
want = Element_Ss5 #bruce 080320 bugfix
else:
want = make and Element_Sj5 or Element_Ss5
for obj in (a,b,c,d):
obj.atom.Transmute(want)
# Note: we do this after the bond making/breaking so it doesn't add singlets which mess us up.
# move Pl atoms into better positions
# (someday, consider using local minimize; for now, just place them directly between their new neighbor atoms,
# hopefully we leave them selected so user can easily do their own local minimize.)
for pl in Pl_atoms:
pl.setposn( average_value( map( lambda neighbor: neighbor.posn() , pl.neighbors() )))
env.history.message( greenmsg( cmdname + ": ") + quote_html("(%s - %s)" % tuple(Pl_atoms)))
#e need assy.changed()? evidently not.
return # from make_or_remove_crossover
def _f_update_neighbor_baseatoms(self):
"""
[friend method for dna updater]
This must be called at least once per ladder rail chain
(i.e. _DnaChainFragment object, I think, 080116),
during each dna updater run which encounters it (whether as a
new or preexisting rail chain).
It computes or recomputes whichever attributes carry info about
the neighboring baseatoms in neighboring rail chains (which
connect to self at the ends), based on current bonding.
Specifically, it sets self.neighbor_baseatoms[end] for end in LADDER_ENDS
to either None (if this chain ends on that ladder-end) or to the
next atom in the next chain (if it doesn't end). (Atoms with
_dna_updater__error set are not allowed as "next atoms" -- None will
be set instead.)
For end atom order (used as index in self.neighbor_baseatoms),
it uses whatever order has been established by the DnaLadder
we're in, which may or may not have reversed our order. (Ladders
have been made, finished, and merged, before we're called.)
For strands, it finds neighbors using bond direction, and knows
about skipping Pl atoms; for axes, in the ambiguous length==1 case,
it uses an arbitrary order, but
makes sure this is consistent with strands when at least one strand
has no nick at one end of this chain's ladder. [#todo: explain better]
If this doesn't force an order, then if this had already been set
before this call and either of the same non-None atoms are still
in it now, preserve their position.
The attrs we set are subsequently reversed by our methods
_f_reverse_arbitrary_bond_direction and reverse_baseatoms.
[###REVIEW whether it's correct in _f_reverse_arbitrary_bond_direction;
see comment there.]
@note: the ordering/reversal scheme described above may need
revision. The special case for length==1 axis described above is
meant to ensure
that axis and strand order correspond between two ladders which
are connected on the axis and one strand, but not the other strand
(i.e. which have an ordinary nick), if the ladder we're on has length 1
(i.e. if there are two nicks in a row, on the same or opposite strands).
If this ever matters, we might need to straighten out this order
in DnaLadder.finished() for length==1 ladders. The ladders are already
made and merged by the time we're called, so whatever reversals they'll
do are already done. [update, 080602: this was implemented today,
to fix a bug; no change to DnaLadder.finished() seemed to be needed.]
"""
assert self.strandQ in (False, True)
self.neighbor_baseatoms = list(self.neighbor_baseatoms)
# do most atoms one end at a time...
for end in LADDER_ENDS: # end_baseatoms needs ladder end, not chain end
next_atom = -1 # will be set to None or an atom, if possible
if self.strandQ:
# similar to code in DnaLadder._can_merge_at_end
end_atom = self.end_baseatoms()[end]
assert self._bond_direction
# relative to LADDER_ENDS directions
# (since that's in the same direction as our baseatoms array)
# (review: not 100% sure this is set yet;
# but the assert is now old and has never failed)
if end == LADDER_END0:
arrayindex_dir_to_neighbor = -1
else:
arrayindex_dir_to_neighbor = 1
bond_dir_to_neighbor = self._bond_direction * arrayindex_dir_to_neighbor
next_atom = end_atom.strand_next_baseatom(bond_direction = bond_dir_to_neighbor)
assert next_atom is None or next_atom.element.role == 'strand'
# (note: strand_next_baseatom returns None if end_atom or the atom it
# might return has ._dna_updater__error set.)
# store next_atom at end of loop
if len(self.baseatoms) > 1: #080602 debug code
if arrayindex_dir_to_neighbor == 1:
next_interior_atom = self.baseatoms[1]
else:
next_interior_atom = self.baseatoms[-2]
if next_interior_atom is next_atom:
print "\n*** PROBABLE BUG: next_interior_atom is next_atom %r for end_atom %r in %r" % \
(next_atom, end_atom, self)
pass
else:
# do axis atoms in this per-end loop, only if chain length > 1;
# otherwise do them both at once, after this loop.
if len(self.baseatoms) > 1:
# easy case - unambiguous other-chain neighbor atom
# (Note: length-2 axis ring is not possible, since it would
# require two bonds between the same two Ax pseudoatoms.
# It's also not physically possible, so that's fine.)
end_atom = self.end_baseatoms()[end]
next_atom_candidates = end_atom.axis_neighbors() # len 1 or 2,
# and one should always be the next one in this chain
# (I guess it can't have _dna_updater__error set,
# since such atoms are not made into chains;
# so I assert this, 080206);
# the other one (if present) might have it set
if end == LADDER_END0:
next_to_end_index = 1
else:
next_to_end_index = -2
not_this_atom = self.baseatoms[next_to_end_index]
assert not not_this_atom._dna_updater__error # 080206
next_atom_candidates.remove(not_this_atom)
# it has to be there, so we don't mind raising an
# exception when it's not
assert len(next_atom_candidates) <= 1, \
"too many candidates: %r" % (next_atom_candidates,)
# Note: got exception here when lots of Ss had two
# Ax neighbors due to errors in an mmp file;
# assertion message untested [080304]
if next_atom_candidates:
next_atom = next_atom_candidates[0]
if next_atom._dna_updater__error:
## print "avoiding bug 080206 by not seeing next axis atom with error", next_atom
next_atom = None
else:
next_atom = None
pass
pass
if next_atom != -1:
self.neighbor_baseatoms[end] = next_atom # None or an atom
assert next_atom is None or not next_atom._dna_updater__error # 080206
if DEBUG_NEIGHBOR_BASEATOMS:
msg = "set %r.neighbor_baseatoms[%r] = %r, whole list is now %r" % \
(self, end, next_atom, self.neighbor_baseatoms)
print_compact_stack( "\n" + msg + ": ")
continue
# ... but in length==1 case, do axis atoms both at once
if not self.strandQ and len(self.baseatoms) == 1:
end_atom = self.baseatoms[0]
next_atoms = end_atom.axis_neighbors() # len 0 or 1 or 2
# remove atoms with errors [fix predicted bug, 080206]
# (review: should axis_neighbors, or a variant method, do this?)
###### SHOULD REVIEW ALL USES OF axis_neighbors FOR NEEDING THIS @@@@@
next_atoms = filter( lambda atom: not atom._dna_updater__error , next_atoms )
while len(next_atoms) < 2:
next_atoms.append(None)
# if order matters, reverse this here, if either strand
# in the same ladder indicates we ought to, by its next atom
# bonding to one of these atoms (having no nick); I think any
# advice we get from this (from 1 of 4 possible next atoms)
# can't be inconsistent, but I haven't proved this. (Certainly
# it can't be for physically reasonable structures.)
# [bruce 080116 proposed, bruce 080602 implemented, as bugfix]
order_was_forced_by_strands = False # might be set below
try:
# very near a release, so cause no new harm...
ladder = rail_end_atom_to_ladder(end_atom)
assert self is ladder.axis_rail
evidence_counters = [0, 0] # [wrong order, right order]
for strand in ladder.strand_rails:
strand._f_update_neighbor_baseatoms()
# redundant with caller, but necessary since we don't
# know whether it called this already or not;
# calling it twice on a strand is ok (2nd call is a noop);
# not important to optimize since length-1 ladders are rare.
for strand_end in LADDER_ENDS:
for axis_end in LADDER_ENDS:
axis_next_atom = next_atoms[axis_end] # might be None
strand_next_atom = strand.neighbor_baseatoms[strand_end] # might be None
if axis_next_atom and strand_next_atom and \
atoms_are_bonded( axis_next_atom, strand_next_atom):
evidence_counters[ strand_end == axis_end ] += 1
continue
continue
continue
badvote, goodvote = evidence_counters
# note: current order of next_atoms is arbitrary,
# so we need symmetry here between badvote and goodvote
if badvote != goodvote:
if badvote > goodvote:
next_atoms.reverse()
badvote, goodvote = goodvote, badvote
pass
order_was_forced_by_strands = True
if badvote and goodvote:
# should never happen for physically reasonable structures,
# but is probably possible for nonsense structures
print "\nBUG or unreasonable structure: " \
"badvote %d goodvote %d for next_atoms %r " \
"around %r with %r" % \
(badvote, goodvote, next_atoms, self, end_atom)
pass
pass
except:
msg = "\n*** BUG: ignoring exception while disambiguating " \
"next_atoms %r around %r with %r" % \
(next_atoms, self, end_atom)
print_compact_traceback( msg + ": " )
pass
reverse_count = 0 # for debug prints only
if not order_was_forced_by_strands:
# For stability of arbitrary choices in case self.neighbor_baseatoms
# was already set, let non-None atoms still in it determine the order
# to preserve their position, unless the order was forced above.
for end in LADDER_ENDS:
old_atom = self.neighbor_baseatoms[end]
if old_atom and old_atom is next_atoms[1-end]:
assert old_atom != -1 # next_atoms can't contain -1
next_atoms.reverse() # (this can't happen twice)
reverse_count += 1
self.neighbor_baseatoms = next_atoms
if DEBUG_NEIGHBOR_BASEATOMS:
msg = "set %r.neighbor_baseatoms = next_atoms %r, " \
"order_was_forced_by_strands = %r, reverse_count = %r" % \
(self, next_atoms, order_was_forced_by_strands, reverse_count)
print_compact_stack( "\n" + msg + ": ")
pass
pass
# we're done
assert len(self.neighbor_baseatoms) == 2
assert type(self.neighbor_baseatoms) == type([])
for atom in self.neighbor_baseatoms:
assert atom is None or atom.element.role in ['axis', 'strand']
# note: 'unpaired-base' won't appear in any chain
return # from _f_update_neighbor_baseatoms
