- since it needs to work in _superclass.copy_empty_shell_in_mapping

- return a list of (dist, handle) pairs, in arbitrary order,

- which includes, for each handle (spherical surface) hit by the ray from p1 thru p2,

- its front-surface intersection with the ray,

- unless that has dist < cutoff and backs_ok,

- in which case include its back-surface intersection

- (unless *that* has dist < cutoff).

- ## is this modifying the vector in-place, causing a bug?? offset += self.origin # treat our handles' pos as relative to this

- ## I don't know, but one of the three instances of += was doing this!!! probably i was resetting the atom or mol pos....

- return None, or the frontmost (dist, handle) pair, as computed by findHandles_exact;

- but turn the handle into a pyobj for convenience of caller.

- #####k i don't know if retval needs self.radius_multiplier...

- #e will we need to let caller know whether it was the front or back surface we hit?

- # or even the exact position on the sphere? if so, add more data to the returned pair.

-def bond_atoms_oldversion(a1, a2): #bruce 050502 renamed this from bond_atoms; it's called from the newer version of bond_atoms

- # bruce 041109 split this out of [later removed] molecule.bond method.

- # probably no need for a1._changed_structure() since we'll do it in Bond(a1, a2) below; probably same for a2;

- # but as a precaution in case of bugs (or misanalysis or future change of this code),

- #e refile this code -- only print warning once for each place in the code it can happen from

- blame = compact_stack() # slow, but should be ok since this case should be rare

- # known cases as of 051216 include only one: reading pdb files with redundant CONECT records

- print_compact_stack( "atom_debug: note: bond_atoms_oldversion doing nothing since %r and %r already bonded: " % (a1, a2))

- print "(above message (bond_atoms_oldversion noop) is only printed once for each compact_stack that calls it)"

- b = Bond(at1, at2, v6) # (this does all necessary invals, including _changed_structure on atoms, and asserts at1 is not at2)

- bond_atoms_oldversion( a1, a2) # warning [obs??#k]: mol.copy might rely on this being noop when bond already exists!

- if 0 and debug_flags.atom_debug and (dir1 or dir2 or want_dir_a1 or want_dir_a2 or want_dir):

- print "bond at open bonds with directions, %r and %r, => %r" % (s1 and s1.bonds[0], s2 and s2.bonds[0], want_dir)

- # Note: we don't yet have any explicit way to kill or destroy a Bond, and perhaps no Bond attrs change when a

- # Bond is removed from its atoms (I'm not sure, and it might depend on which code does it);

- # for now, this is ok, and it means those events needn't be tracked as changes to a Bond.

- # If a Bond is later given a destroy method, that should remove it from this dict;

- # If it has a kill or delete method (or one that's called when it's not on its atoms),

- # that should count as a change in this dict (and perhaps it should also change its atom attrs).

- # global_model_changedicts.changed_bond_types should perhaps become a subscriber

- # (though as of 071107 there are several things that get into _changed_Bonds

- # but not into global_model_changedicts.changed_bond_types -- should REVIEW the correctness of that)

-

- ##e see comments about similar dicts in chem.py for how this will end up being used

- pi_bond_obj = None #bruce 050718; used to memoize a perceived PiBondSpChain object (if any) which covers this bond

- # sometimes I search for pi_bond_info when I want this; see also get_pi_info and pi_info

- _s_attr_atom1 = S_PARENT # too bad these can change, or we might not need them (not sure, might need them for saving a file... #k)

- _direction = 0 # default value of private (except known to Atom.writemmp) instance variable for bond_direction [bruce 070414]

- # _direction is 0 for most bonds; for directional bonds [###e term to be defined elsewhere] it will be 1 if atom1 comes first,

- # I think no code destructively swaps the atoms in a bond; if it ever does, it needs to invert self._direction too.

- # That goes for the process of mmp save/load as well, and for copying of a bond (which *might* reverse the atoms) --

- # write and read this info with care, since it's the first time in NE1 that the order of a bond's atoms will matter.

- # This is a private attr, since its meaning depends on atom order; public access methods must be

- # passed one of self's atoms, so they can accept or return directions relative to that atom.

- # For comments about how chains/rings of directional bonds might best be perceived,

- # for purposes of inferring directions or warning about inconsistencies,

- # see pi_bond_sp_chain.py's module docstring.

- # [bruce 070414, mostly nim ###]

-

- _s_attr_key = S_DATA #bruce 060405, not sure why this wasn't needed before (or if it will help now)

- return True # not sure if this or False would be safer; using True so we're covered if any live atom refers to us

- assert 0, "%r.set_bond_direction_from(%r, %r), but that bond doesn't have that atom" % (self, atom, direction)

- # propogate self's direction both ways, as far as possible, overwriting any prior directions encountered

- # (and do this even if this bond's direction was already the same as the one we're setting)

- # (note: the direction being set here can be 0)

- # (note: if self can ever be a bond which *silently ignores* sets of direction,

- # then for the following to be correct, we'd need to pass the initial direction to use,

- # which would be an opposite one to each call. Not doing that now makes direction-switching bugs less likely

- # or tests the default direction used by propogate_bond_direction_towards.)

- # For Undo, we only worry about changes to "definitive" (not derived) state. That's only in self.

- # Since Bonds use an optimized system for changetracking, we have to store self in a dictionary.

- # (This is more efficient than calling atom._changed_structure on each of our atoms,

- # Someday, doing that should also cover all modification notices to model object containers that contain us,

- # such as the file we're saved in. It might already do that, but I'm not sure, so do that explicitly:

- backdir = self.bond_direction_from(atom) # measured backwards, relative to direction in which we're propogating

- def is_directional(self): #bruce 070415 #e this might be replaced with an auto-updated attribute, self.directional

- # We'll support a bond_direction record which only writes atoms in bond_direction order.

- # That way we needn't write out the direction itself, and the record format permits encoding

- # a bond-chain in one record listing a chain of atomcodes

- # (though we don't yet take advantage of that when writing).

- assert direction # otherwise we should not be writing this record (#e could extend API to let us return "" in this case)

-

-

-

- self.pi_bond_obj.destroy() ###k is this safe, if that obj and ones its knows are destroyed?

- ##e is this also needed in self._changed_atoms or _changed_v6??? see if bond orientation bugs are helped by that...

- self.__dict__.clear() ###k is this safe??? [see comments in Atom.destroy implem for ways we might change this ##e]

- # we want the lowest permitted valence which is at least v_have - vdelta, i.e. in the range v_want to v_have.

- # This code is very similar to that of increase_valence_noupdate, but differs in a few important places!

- if v_want <= v_to_try <= v_have: # warning: order of comparison will differ in the sister method for "increase"

- v_want = v_to_try # good thing we'll break now, since this assignment alters the meaning of the loop-test

- # we want the highest permitted valence which is at most v_have + vdelta, i.e. in the range v_have to v_want.

- # This code is very similar to that of reduce_valence_noupdate but several things are reversed.

- for v_to_try in BOND_VALENCES_HIGHEST_FIRST: # this list is in highest-to-lowest order, unlike BOND_VALENCES

- v_want = v_to_try # good thing we'll break now, since this assignment alters the meaning of the loop-test

- print "atom_debug: i hoped for did_break != else_reached but it's not true, in increase_valence_noupdate"

- # no valence is legal! Not yet sure what to do in this case. (Or whether it ever happens.)

- self.setup_invalidate() # not sure this is needed, but let's do it to make sure it's safe if/when it's needed [bruce 050502]

- self.atom1._modified_valence = self.atom2._modified_valence = True # (this uses a private attr of class atom; might be revised)

- self.atom2.changed() # for now, only the file (assy) records this, so 2nd call is redundant, but someday that will change.

- def numeric_valence(self): # has a long name so you won't be tempted to use it when you should use .v6 ###@@@ not yet used?

- # This version helps atombase.c not to fail when atom keys

- #self.bond_key = 65536 * min(at1.key, at2.key) + max(at1.key, at2.key)

- # used only in __eq__ as of 051018; problematic (see comments there)

- # !!!!!!! Nope, also used in chunk.standard_draw_atoms()

- # such that keys must be unique within the chunk. But,

- # with that use replaced with id(bond), we may be ok with

- # this only being unique for bonds attached to a single

- # atom.

-

- a1pos = atom1.baseposn() #e could optim, since their calcs of whether basepos is present are the same

- # after this, attr is either an updated_attr or a bug, so it's ok to assume we need to recompute if invalid...

- # if any of the attrs used by recomputing geom are missing, we'll get infinite recursion;

- # these are just atom1, atom2, and the ones used herein.

- return geom # callers desiring speed should use this case, to get several attrs but only check validity once

- elif attr == 'axis': # a2pos - a1pos (not normalized); in relative coords [bruce 050719 new feature]

- Return the pi orbital orientation/occupancy info for this bond, if any [#doc the format], or None

- if this is a single bond (which is not always a bug, e.g. in -C#C- chains, if we someday extend the

- subrs this calls to do any bond inference -- presently they just trust the existing bond order, self.v6).

- This info might be computed, and perhaps stored, or stored info might be used. It has to be computed

- all at once for all pi bonds in a chain connected by sp atoms with 2 bonds.

- If computed, and if it's partly arbitrary, **kws (out/up) might be used.

- reload_once_per_event(pi_bond_sp_chain) #bruce 050825 use reload_once_per_event to remove intolerable slowdown

- return bond_get_pi_info(self, **kws) # no need to pass an index -- that method can find one on self if it stored one

- # this always fails (so it's ok if it's slow) -- it's just our "understandable error message"

- #Note: bool_fullBondLength represent whether full bond length to be drawn

- #it is used only in select Chunks mode while highlighting the whole chunk and when

- #the atom display is Tubes display -- ninad 070214

- highlighted = True # ninad 070214 - passing 'highlighted' to bond.draw instead of highlighted = bool

- #bruce 050702, part of fix 2 of 2 redundant fixes for bug 716 (both fixes are desirable)

- # internal bond; geometric info is stored in chunk-relative coords; we need mol's help to use those

- # sorry for all the kluges (e.g. 2 of those args) that beg for refactoring! The info passing in draw methods

- # is not designed for drawing leaf nodes by themselves in a clean way! (#e should clean up somehow)

- #bruce 050702 using shorten_tubes [as of 050727, this is done via highlighted = True]

- # to help make room to mouseover-highlight the atoms,

- # when in tubes mode (thus fixing bug 715-1); a remaining bug was that it's sometimes hard to

- # highlight the tube bonds, apparently due to selatom seeming bigger even when not visible (not sure).

- # In another commit, same day, GLPane.py (sort selobj candidates) and this file (don't shorten_tubes

- # next to singlets [later moved to bond_drawer.py]), this has been fixed.

- # without either atom being killed. For now, just leave it out; fix this sometime. #####@@@@@

- def writepov(self, file, dispdef, col): #bruce 050727 moving implem to separate file; 050730 fixed bug in this method's name

- def __str__(self): #bruce 050705 revised this; note that it contains chars not compatible with HTML unless quoted

- # No quat is easily available here; better results if you call that subr directly and pass one;

- # the right one is (in current code, AFAIK, 070415) glpane.quat for the glpane that will display the bond

- print_compact_traceback("bug: exception in self.atom1.molecule.assy.o.quat: ") # don't print self here!

- return bonded_atoms_summary(self, quat = quat) #bruce 070415 added quat arg and above code to guess it ###UNTESTED

- It's an error if s1 == s2, or if they're on the same atom. It's a

- warning (no error, but no bond made) if the real atoms of the singlets

- are already bonded, unless we're able to make the existing bond have

- higher bond order, which we'll only attempt if increase_bond_order = True,

- and [bruce 050702] which is only possible if the bonded elements have suitable atomtypes.

- ###@@@ should we permit this as a way of changing the bonding pattern by summing the valences of these bonds? YES! [doit]

- # [later comment, 050702:] this is low-priority, since it's difficult to do for a free atom

- # (the atom tries to rotate to make it impossible) (tho I have to admit, for a bound C(sp3)

- # with 2 open bonds left, it's not too hard, due to the arguable-bug in which only one of them moves)

- # and since the context menu lets you do it more directly. ... even so, let's try it:

- if self.increase_bond_order and a1.can_reduce_numbonds() and a2.can_reduce_numbonds():

- # we'll try that -- it might or might not work, but it has its own error messages if it fails

- #bruce 050702 added can_reduce_numbonds conditions, which check whether the atoms can change their atomtypes appropriately

- return do_error("%s increase bond order between already-bonded atoms %r and %r" % (why, a1, a2), None)

- # [much later, 050702: that might be obs, but worrying about their *permitted* valences might not be...]

- status = "bonded atoms %r and %r" % (a1, a2) #e maybe subr should make this?? #e subr might prefix it with bond-type made ###@@@

- #bruce 071018, stop using old code here, finally; might fix open bond direction; clean up if so ###TODO

- Choice_boolean_False # bruce 071019 change default to False since new code works now

- # tell it the singlets to replace or reduce; let this do everything now, incl updates.

- # can that fail? I don't think so; if it could, it'd need to have new API and return us an error message explaining why.

- ###########@@@@@@@@@@ TODO bruce 071018: need to make this not harm any *other* singlets on these atoms,

- # since some callers already recorded them and want to call this immediately again to make other bonds.

- # it's good if it kills *these* singlets when that's correct, though.

- # REVIEW: what's the status of that?

- if len(a1.bonds) == 2: # (btw, this method is only called when a1 and a2 have at least 2 bonds)

- # Since a1 will have only one bond after this (if it's able to use up all of s1's valence),

- # we might as well try to add even more valence to the bond, to correct any deficient valence on a1.

- # But we'll never do this if there are uninvolved bonds to a1, since user might be planning

- # to manually increase their valence after doing this operation.

- # [bruce 051215 new feature, which ought to also fix bug 1221; other possible fixes seem too hard to do in isolation.

- # In that bug, -N-N- temporarily became N=N and was then "corrected" to N-N rather than to N#N as would be better.]

- vdelta = min(v1, v2) # but depending on the existing bond, we might use less than this, or none

- # (ignores elements and other bond orders -- "legal" just means for any conceivable bond);

- # returns actual amount of increase (maybe 0)

- ###@@@ why didn't we use vdelta_used in place of vdelta, below? (a likely bug, which would erroneously reduce valence;

- # but so far I can't find a way to make it happen -- except dNdNd where it fixes preexisting valence errors!

- # I will fix it anyway, since it obviously should have been written that way to start with. [bruce 051215])

-## print "atom_debug: bond_v6 changed from %r to %r; vdelta_used (difference) is %r; vdelta is %r" % (old_bond_v6, new_bond_v6, vdelta_used, vdelta)

- return self.do_error("can't increase order of bond between atoms %r and %r" % (a1, a2), None) #e say existing order? say why not?

- return (0, "increased bond order between atoms %r and %r" % (a1, a2)) #e say existing and new order?

- # Note, bruce 060629: the new bond order would be hard to say, since later code in bond_updater.py is likely

- # to decrease the value, but in a way it might be hard to predict at this point (it depends on what happens

- # to the atomtypes which that code will also fix, and that depends on the other bonds we modify here;

- # in theory we have enough info here, but the code is not well structured for this -- unless we save up this

- # message here and somehow emit it later after that stuff has been resolved). Not an ideal situation....

- def merge_open_bonds(self): #bruce 050702 new feature; implem is a guess and might be partly obs when written

- vdelta_used = bond2.increase_valence_noupdate(vdelta) # increases to legal value, returns actual amount of increase (maybe 0)

- return self.do_error("can't merge these two bondpoints on atom %r" % (a1,), None) #e say existing orders? say why not?

- a1.update_valence() # this can change the atomtype of a1 to match the fact that it deletes a singlet [bruce comment 050728]

-# some unused old code that would be premature to completely remove [moved here by bruce 050502]

-BALL_vs_CPK = 0.25 # ratio of default diBALL radius to default diTrueCPK radius [renamed from CPKvdW by bruce 060607]

- # bruce 060414 fix bug 1779 (more efficient than doing something in Atom._undo_update, for every atom)

- # KLUGE: assume this always runs (true as of 060414), not only if there are jigs or under some other "when needed" conds.

- # Note: it would be best to increment this counter at the start and end of every user op, but there's not yet any central place

- # for code to run at times like that (except some undo-related code which runs at other times too).

- # A more principled and safer fix would be either for kill functions participating in "prekill" to take

- # an argument, unique per prekill/kill event, or to ensure the global counter (acting as if it was that argument)

- # was unique by again incrementing it after the kill call returns within the same code that had initiated the prekill.

- _changed_structure_Atoms[a.key] = a #bruce 060322; try to only do this to atoms that need it

- #k tracking this change is probably not needed by Undo but might be needed by future non-Undo subscribers

- # to that dict; Undo itself needs to remember to clear its subscribed cache of it after this ###@@@DOIT

- a.jigs = [] #e or del it if we make that optim in Jig (and review whether this needs to occur outside 'if a.jigs')

- #k maybe the S_CACHE decl will make this unnecessary? Not sure... maybe not, and it's safe.

- # I hope refdecr is enough to avoid a memory leak; if not, give that obj a special destroy for us to call here.

- # That obj won't remove itself from a.jigs on refdecr (no __del__); but it would in current implem of .destroy.

- _changed_structure_Atoms[a.key] = a #bruce 060322; see comment about same statement above

- # strictly speaking, this is beyond our scope, but Atom._undo_update can't do it since a.jigs isn't set.

- # Also, whatever this does should really just be done by Jig._undo_update. So make that true, then remove this. ###@@@

- after_update_of = ('Assembly', 'Node', 'Atom.bonds') # Node also covers its subclasses Chunk and Jig.

- # We don't care if Atom is updated except for .bonds, nor whether Bond is updated at all,

- # which is good because *we* are presumably a required part of updating both of those classes!

- # FYI, we use 'Assembly' (string) rather than Assembly (class) to avoid a recursive import problem,

- # and also to avoid an inappropriate import dependency (low-level -> high-level).

-# These global dicts all map atom.key -> atom, for atoms which change in various ways (different for each dict).

-# The dicts themselves (as opposed to their contents) never change (so other modules can permanently import them),

-# but they are periodically processed and cleared.

-# For efficiency, they're global and not weak-valued,

-# so it's important to delete items from them when destroying atoms

-# (which is itself nim, or calls to it are; destroying assy needs to do that ### TODO).

-# obsolete comment:

-# ###@@@ Note: These are not yet looked at, but the code to add atoms into them is supposedly completed circa bruce 060322.

-# update 071106: some of them are looked at (and have been since Undo worked), but maybe not all of them.

- # record atoms w/ changed assy or molecule or liveness/killedness

- # (an atom's assy is atom.molecule.assy; no need to track changes here to the mol's .part or .dad)

- # related attributes: __killed, molecule ###@@@ declare these??

- # not yet sure if that should be per-attr or not, re subclasses...

- # WARNING: name is private, but it's directly accessed in many places in

- # chunk.py [bruce 071106 comment]

- #k or must we say _Atom__killed??

- # (It depends on whether that routine knows how to mangle it itself.)

- # (As of long before 071018 that arg of register_changedict (related_attrs)

- # is not yet used.)

- # WARNING: there is also a related but different global dict

- # earlier than this one in the same file (global_model_changedicts.py),

- # whose spelling differs only in 'A' vs 'a' in Atoms, and in having no initial underscore,

- # namely, changed_structure_atoms.

- # This confusion should be cleaned up sometime, by letting that one just be a subscriber to this one,

- # and if efficiency demands it, first splitting this one into the part equivalent to that one, and the rest.

- # Ways this one has more atoms added to it than that one does:

- # jigs, info, kill, bond direction. (See also the comment where the other one is defined.)

- # See also: _changed_parent_Atoms, which also covers kill (probably in a better way).

- # related attributes: bonds, element, atomtype, info, jigs # (not only '.jigs =', but '.jigs.remove' or '.jigs.append')

- # (we include info since it's used for repeat-unit correspondences in extrude; this is questionable)

- # (we include jigs since they're most like a form of structure, and in future might have physical effects,

- # and since the jigs for pi bonds are structural)

- # tracks changes to atom._posn (not clear what it'll do when we can treat baseposn as defining state)

-# Notes (design scratch):

-# for which Atom attrs is the attr value mutable in practice? bonds, jigs, maybe _posn (probably not).

-# the rest could be handled by a setter in a new-style class, or by AtomBase

-# and i wonder if it's simpler to just have one dict for all attrs... certainly it's simpler, so is it ok?

-# The reason we have multiple dicts is so undo diff scanning is faster when (e.g.) lots of atoms change in _posn

-# and nothing else (as after Minimize or movie playing or (for now) chunk moving).

- # See also some code below class Atom, which registers these changedicts as being used with that class.

- # That code has to occur after the class is defined, but we permit the above per-changedict registrations

- # to come first so that they can help document the dicts near the top of the file.

- # The dicts themselves needn't come first, since they're only looked up as module globals (or from external modules),

- # but it's easier to read the code if they do.

- Prepare to kill some set of atoms (known to the caller) more efficiently than otherwise.

- Return a value which the caller should pass to the _prekill method on all (and ONLY) those atoms,

- before killing them.

- [#e Note: If we can ever kill atoms and chunks in the same operation, we'll need to revise some APIs

- so they can all use the same value of _will_kill_count, if we want to make that most efficient.]

- #bruce 050610 renamed this from class atom, but most code still uses "atom" for now

- # (so we have to assign atom = Atom, after this class definition, until all code has been revised)

- ## atomtype -- set when first demanded, or can be explicitly set using set_atomtype or set_atomtype_but_dont_revise_singlets

- index = -1 #bruce 060311 add this as a precaution re bug 1661, and since it seems necessary in principle,

- # given that we store it as undoable state, but (I guess, re that bug) don't always set it very soon

- # after making an atom; -1 is also the correct value for an atom in a chunk but not yet indexed therein;

- # in theory the value doesn't matter at all for a chunkless atom, but a removed atom (see Chunk.delatom) will have -1 here,

- # so imitating that seems most correct.

- # _s_attr decls for state attributes -- children, parents, refs, bulky data, optional data [bruce 060223]

- # note: self.molecule is initially None. Later it's self's chunk.

- # If self is then killed, it's _nullMol. Some buglike behavior might effectively

- # kill or never-make-fully-alive self's chunk, without removing self from it

- # (especially in nonstandardly-handled assys like the ones for the partlib).

- # Finally, undoing to before self was created will cause its .molecule to become None again.

- # In that state there is no direct way to figure out self's assy,

- # but it might have one, since it might be in its undo_archive and be able

- # to come back to life that way, by Redo. Or the redo stack might get cleared,

- # but self might still be listed in some dicts in that undo_archive (not sure),

- # and maybe in various global dicts (changedicts, glname dict, dna updater error dict, etc).

- # This makes it hard to destroy self and all its storage, when self's assy is destroyed.

- # To fix this, we might keep a dict in assy of all atoms ever in it,

- # and/or keep a permanent _f_assy field in self. Not yet decided. Making _nullMol per-assy

- # would not help unless we can always use it rather than None, but that's hard because

- # atoms initially don't know assy, and Undo probably assumes the initial state of .molecule

- # is None. So a lot of code would need analysis to fix that, whereas a new one-purpose

- # system to know self's assy would be simpler. But it takes RAM and might not really be needed.

- # The main potential need is to handle atoms found in changedicts with .molecule of None or _nullMol,

- # to ask their assy if it's destroyed (updater should ignore atom) or not (updater should handle

- # atom if it handles killed atoms). But do updaters ever need to handle killed atoms?

- # [bruce 080219 comment]

- _s_attr_jigs = S_CACHE # first i said S_REFS, but this is more efficient, and helps handle pi_bond_sp_chain.py's Jigs.

- # This means that restored state will unset the .jigs attr, for *all* atoms (???), and we'll have to recompute them somehow.

- # The alg is easy (scan all jigs), but exactly how to organize it needs to be thought about.

- # Is it worth thinking of Atom.jigs in general (not just re Undo) as a recomputable attribute?

- # We could revise the incremental updaters to not worry if it's missing,

- # and put in a __getattr__ which redid the entire model's atoms when it ran on any atom.

- # (Just scan all jigs, and assume all atoms' .jigs are either missing or correct, and ignore correct ones.)

- # But that approach would be wrong for pi_bond_sp_chain.py's Jigs since they would not be scanned (efficiently).

- # So for them, they have to insist that if they exist, the atoms know about them. (Using a sister attr to .jigs?)

- # (Or do we teach atoms how to look for them on nearby bonds? That's conceivable.)

- # ... or if these fields are derived specifically from the atomsets of Jigs, then do we know which atoms to touch

- # based on the manner in which Undo altered certain Jigs (i.e. does our update routine start by knowing the set of

- # old and new values of all changed atomsets in Jigs)?? Certainly we could teach the diff-applyer to make that info

- # available (using suitable attr decls so it knew it needed to)... but I don't yet see how this can work for pi_bond Jigs

- # and for incremental Undo.

-

- #e we might want to add type decls for the bulky data (including the objrefs above), so it can be stored in compact arrays:

-

-#bruce 060322 zapping _s_attr_key = S_DATA decl -- should be unnecessary since .key never changes. ####@@@@ TEST

-# NOTE: for using this for binary mmp files, it might be necessary -- review that when we have them. ###@@@

-## _s_attr_key = S_DATA # this is not yet related to Undo's concept of objkey (I think #k) [bruce 060223]

- # we'll want an "optional" decl on the following, so they're reset to class attr (or unset) when they equal it:

- _s_categorize_picked = 'selection' ##k this is noticed and stored, but I don't think it yet has any effect (??) [bruce 060313]

- ## _s_attr_ghost = S_DATA #bruce 080529; might not be needed (since no ops change this except on newly made atoms, so far)

- _s_attr__Atom__killed = S_DATA # Declaring (name-mangled) __killed seems needed just like for any other attribute...

- # (and without it, reviving a dead atom triggered an assertfail, unsurprisingly)

- ###e need atomtype - hard part is when it's unset, might have to revise how we handle that, e.g. derive it from _hyb;

- # actually, for pure scan, why is 'unset' hard to handle? i bet it's not. It just has no default value.

- # It's down here under the 'optional' data since we should derive it from _hyb which is usually 'default for element'.

- # new behavior as of 060409, needed to interact well with differential mash_attrs...

- # i'm not yet fully comfortable with this (maybe we really need _nullMol in here??) ###@@@

- #bruce 060224 conservative guess -- invalidate everything we can find any other code in this file invalidating

- self.molecule.invalidate_attr('externs') #bruce 070602: fix Undo bug after Make Crossover (crossovers.py) --

- # the bug was that bonds being (supposedly) deleted during this undo state-mashing would remain in mol.externs

- # and continue to get drawn. I don't know why it didn't happen if bonds were also created on the same atoms

- # (or perhaps on any atoms in the same chunk), but presumably that happened to invalidate externs in some other way.

- # As for why the bug went uncaught until now, maybe no other operation creates external bonds without also

- # deleting bonds on the same atoms (which evidently prevents the bug, as mentioned). For details of what was

- # tried and how it affected what happened, see crossovers.py cvs history circa now.

- self.setposn( posn - V(1,1,1) ) # i hope it doesn't optimize for posn being unchanged! just in case, set wrong then right

- Create an Atom of element sym

- (e.g. 'C' -- sym can be an element, atomtype, or element-symbol, or another atom to copy these from)

- at location 'where' (e.g. V(36, 24, 36))

- belonging to molecule mol (can be None or missing).

- # note: it's not necessary to track changes to self's attrs (in e.g. _changed_parent_Atoms) during __init__. [bruce 060322]

- _changed_parent_Atoms[self.key] = self # since this dict tracks all new atoms (i.e. liveness of atoms) (among other things)

- # [bruce 050707 revised this; previously the default behavior was to set no atomtype now

- # (picking one when first asked for), not to set the default atomtype now. This worked ok

- # when the atomtype guessed later was also the default one, but not once that was changed

- # to guess it based on the number of bonds (when first asked for), since some old code

- # would ask for it before creating all the bonds on a new atom. Now, the "guessing atomtype

- # from bonds" behavior is still needed in some cases, and is best asked for by leaving it unset,

- # but that is done by a special method or init arg ###doc, since it should no longer be what this init

- # method normally does. BTW the docstring erroneously claimed we were already setting default atomtype.]

- #e could assert self.element is now an Elem, but don't bother -- if not, we'll find out soon enough

- ## self._source = compact_stack()

- print "%r._f_set_assy: leaving old assy %r, for new one %r. Implem of this case is untested." % \

- Would this (Atom) object be picked up as a child object in a (hypothetical) complete scan of children

- (including change-tracked objects) by the given undo_archive (or, optional to consider, by some other one)?

- The caller promises it will only call this when it's just done ... ###doc

- # This implem is only correct because atoms can only appear in the archive's current state

- # if they are owned by chunks which appear there.

- # (That's only true because we fix or don't save invalid _hotspots, since those can be killed bondpoints.)

- # For each entry in this dictionary, add a context menu command on atoms of the key element type

- # allowing transmutation to each of the element types in the value list.

- # If picked, do it for all picked atoms, but only if they are all the same element.

- # (But if they're not, still offer to do it for just this atom, clearly saying so if possible.)

- # Kluge: locate that command method on atom, used for access to selatoms,

- # even though it's not defined to operate on atom (tho it does in this case).

- # One motivation is to ease the upcoming emergency merge by not modifying more files/code

- Note: it should be legal to call this multiple times, in any order w/ other objs' destroy methods.

- SEMANTICS ARE UNCLEAR -- whether it should destroy bonds in self.bonds (esp in light of rebond method).

- See comments in assy_clear by bruce 060322 (the "misguided" ones, written as if that was assy.destroy, which it's not).

- """

- # If this proves inefficient, we can dispense with most of it, since glselect dict can be made weak-valued

- # (and will probably need to be anyway, for mmkit library part atoms),

- # and change-tracking dicts (_Atom_global_dicts) are frequently cleared, and subscribers will ignore objects

- # from destroyed assys. So it's only important here if we destroy atoms before their assy is destroyed

- # (e.g. when freeing from redo or old undo diffs), and it's probably not enough for that anyway (not thought through).

- # Ideally we'd remove cycles, not worry about transient refs in change-trackers, make change-trackers robust

- # to being told about destroyed atoms, and that would be enough. Not yet sure whether that's practical.

- # [bruce 060327 comment]

- #e even this might be done by StateMixin if we declare these dicts to it for the class

- # (but we'd have to tell it what key we use in them, e.g. provide a method or attr for that

- # (like .key? no, needs _s_ prefix to avoid accidental definition))

- ###e we need to also tell the subscribers to those dicts that we're being destroyed, I think

- ## self.bonds = self.jigs = self.molecule = self.atomtype = self.element = self.info = None # etc...

- #bruce 050702 revised this; 050707 using it much less often (only on special request ###doc what)

- ###@@@ Bug: This does not yet [050707] guess correctly for all bond patterns; e.g. it probably never picks N/sp2(graphitic).

- # That means there is presently no way to save and reload that atomtype in an mmp file, and only a "direct way"

- # (specifying it as an atomtype, not relying on inferring from bonds) would work unless this bug is fixed here.

- if 1: ## or env.once_per_event("reguess_atomtype warning"): #bruce 060720, only warn once per user event

- print_compact_stack(

- ## "atom_debug: warning (once per event): reguess_atomtype(%s) sees %s with no bonds -- probably a bug: " % \

- "warning: reguess_atomtype(%s) sees non-killed %s with no bonds -- probably a bug: " % \

- (elt, self) )

- def set_atomtype_but_dont_revise_singlets(self, atomtype): ####@@@@ should merge with set_atomtype; perhaps use more widely

- atomtype = self.element.find_atomtype( atomtype) # handles all forms of the request; exception if none matches

- self._changed_structure() #bruce 050627; note: as of 050707 this is always called during Atom.__init__

- Set this atom's atomtype as requested, and do all necessary invalidations or updates,

- including remaking our singlets as appropriate, and [###@@@ NIM] invalidating or updating bond valences.

- It's ok to pass None (warning: this sets default atomtype even if current one is different!),

- atomtype's name (specific to self.element) or fullname, or atomtype object. ###@@@ also match to fullname_for_msg()??? ###e

- Special case: if new atomtype would be same as existing one (and that is already set), do nothing

- (rather than killing and remaking singlets, or even correcting their positions),

- unless always_remake_bondpoints is true. [not sure if this will be used in atomtype-setting menu-cmds ###@@@]

- """

- # Note: mvElement sets self.atomtype directly; if it called this method, we'd have infrecur!

- atomtype = self.element.find_atomtype( atomtype) # handles all forms of the request; exception if none matches

- assert atomtype.element is self.element # [redundant with find_atomtype] #e or transmute if not??

- self.direct_Transmute( atomtype.element, atomtype ) ###@@@ not all its needed invals/updates are implemented yet

- res = V(0,0,0) ##e is there any better choice of position for this purpose? e.g. a small random one, so it's unique?

- Return our posn, as the simulator should see it -- same as posn except for Singlets,

- which should pretend to be H and correct their distance from base atom accordingly.

- Should work even for killed atoms (e.g. singlets with no bonds).

- Note that if this is used on a corrected singlet position derived from a simulated H position

- (as in the 060111 approximate fix of bug 1297), it's only approximate, since the actual H position

- might not have been exactly its equilibrium position.

- if basepos is not None: ##[bruce 060308 zapped:]## and self.xyz == 'no': #bruce 050516 bugfix: fix sense of comparison to 'no'

- # note: since mol.basepos exists, mol.atlist does, so self.index is a valid index into both of them

- # [bruce 060313 comment]

- return mol.quat.unrot(self.posn() - mol.basecenter) # this inlines mol.abs_to_base( self.posn() ) [bruce 060411 comment]

- #e (should this be a separate method -- does anything else need it?)

- # note: the comment mentions jigs, but this code doesn't alert them to the move. Bug?? [bruce 070518 question]

- #e note: this does nothing for most kinds of jigs,

- # so in theory we might optim by splitting self.jigs into two lists;

- # however, there are other change methods for atoms in jigs (maybe changed_structure?),

- # so it's not clear how many different lists are needed, so it's unlikely the complexity is justified.

- print "fyi: check_bond_geometry(%r) set or cleared error string %r" % (self, error_string)

- self._f_draw_bond_geometry_error_indicator_externally = draw_externally # this attr might never be used

- def draw(self, glpane, dispdef, col, level, special_drawing_handler = None, special_drawing_prefs = USE_CURRENT):

- pickedrad = drawrad * 1.8 # this code snippet is now shared between draw and draw_in_abs_coords [bruce 060315]

- # WARNING: various routines make use of this return value in different ways,

- # but these ways are not independent (e.g. one might draw a cone and one might estimate its size),

- # so changes in any of the uses need to be reviewed for possibly needing changes in the others. [bruce 070409]

- # current implem has cosmetic bugs (details commented there), so don't say non_debug = True

- #e REVIEW: does Bond.draw need to be updated due to this, if "draw bondpoints as stubs" is True?

- #e REVIEW: Do we want to draw even an isolated Pe (with bondpoint) as a cone, in case it's in MMKit,

- # since it usually looks like a cone when it's correctly used? Current code won't do that.

- #e Maybe add option to draw the dir == 0 case too, to point out you ought to propogate the direction

- # and sometimes the highlighting cylfaces mix with the non-highlighted ones,

- # as if same depth value. ###@@@

- # note: this is only correct since self and other are guaranteed to belong to the same chunk --

- # if they didn't, their baseposns (pos and otherpos) would be in different coordinate systems.

- drawcylinder(color, inpos, outpos, drawrad, 1) #e see related code in Bond.draw; drawrad is slightly more than the bond rad

- #Following implements custom arrowhead colors for the 3' and 5' end

- #(can be changed using Preferences > Dna page) Feature implemented

- #for Rattlesnake v1.0.1

- #Following implements custom arrowhead colors for the 3' and 5' end

- #(can be changed using Preferences > Dna page) Feature implemented

- #for Rattlesnake v1.0.1

- ###BUG: this becomes wrong if the chunks move relative to each other! But we don't get updated then. ###FIX

- ## color = gray # to indicate the direction is suspicious and might become invalid (for now)

- # the following cone dimensions enclose the original sphere (and therefore the bond-cylinder end too)

- # (when axis and arrowRadius have their default values above -- not sure if this remains true after [mark 071014]):

- # cone base at pos - axis, radius = 2 * drawrad, cone midplane (radius = drawrad) at pos + axis,

- # thus cone tip at pos + 3 * axis.

- # WARNING: this cone would obscure the wirespheres, except for special cases in self.draw_wirespheres().

- # If you make the cone bigger you might need to change that code too.

- # compensate for the cone (drawn by draw_atom_sphere in this case) being bigger than the sphere [bruce 070409]

- if self.picked: # (do this even if disp == diINVISIBLE or diLINES [bruce comment 050825])

- drawwiresphere(color, pos, pickedrad) ##e worry about glname hit test if atom is invisible? [bruce 050825 comment]

- # The check for glpane class is a kluge to prevent this from showing in thumbviews: should remove ASAP.

- #e We might need to be able to turn this [what?] off by a preference setting; or, only do it in Build mode.

- # should be correct, but this case won't be used as of 041217 [probably no longer needed even if used -- 050511]

- return numbonds != len(self.bonds) ##REVIEW: this doesn't check bond valence at all... should it??

- #bruce 050806; should review uses (or inlinings) of self.bad() to see if they need this too ##REVIEW

- # WARNING: keep the code of self.bad_valence() and self.bad_valence_explanation() in sync!

- #e we might optimize this by memoizing it (in a public attribute), and letting changes to any bond invalidate it.

- If this atom clearly wants more valence (based on existing bond types),

- return the minimum amount it needs (as an int or float valence number, NOT as a v6).

- Otherwise return 0.

- def draw_in_abs_coords(self, glpane, color, useSmallAtomRadius = False): #bruce 050610

- ###@@@ needs to be told whether or not to "draw as selatom"; now it does [i.e. it's misnamed]

- """

- Draw this atom in absolute (world) coordinates,

- using the specified color (ignoring the color it would naturally be drawn with).

- See code comments about radius and display mode (current behavior might not be correct or optimal).

- This is only called for special purposes related to mouseover-highlighting,

- and should be renamed to reflect that, since its behavior can and should be specialized

- for that use. (E.g. it doesn't happen inside display lists; and it need not use glName at all.)

- In this case (Atom), this method (unlike the main draw method) will also

- draw self's bond, provided self is a singlet with a bond which gets drawn, so that for an "open bond"

- it draws the entire thing (bond plus bondpoint). In order for this to work,

- the bond must (and does, in current code) borrow the glname

- of self whenever it draws itself (with any method).

- (This is only possible because bonds have at most one bondpoint.)

- ###@@@ remaining code might or might not be correct (issues: larger radius, display-mode independence)

- # review: does this need to be bigger when self.bond_geometry_error_string

- # to make tooltip work on self?

- #bruce 050825 comment: it's probably incorrect to do this even for invisible atoms.

- # This probably caused the "highlighting part" of bug 870, but bug 870 has been fixed

- # by other changes today, but this still might cause other bugs of highlighting

- # otherwise-invisible atoms. Needs review. ###@@@

- # (Indirectly related: drawwiresphere acts like drawsphere for hit-test purposes.)

- if len(self.bonds) == 1 and self.element is Singlet: #bruce 050708 new feature - bond is part of self for highlighting

- #bruce 050719 question: is it correct to ignore .display of self and its base atom? ###@@@

- #bruce 060315 try to fix disappearing hover highlight when mouse goes over one of our wirespheres.

- # We have to do it in the same coordinate system as the original wirespheres were drawn.

- # (This will only work well if there is also a depth offset, or (maybe) an increased line thickness.

- # I think there's a depth offset in the calling code, and it does seem to work. Note that it needs

- # testing for rotated chunks, since until you next modify them, the wirespheres are also drawn rotated.)

- dispdef = self.molecule.get_dispdef() #e could optimize, since sometimes computed above -- but doesn't matter.

- pickedrad = drawrad * 1.8 # this code snippet is now shared between several places [bruce 060315/080411]

- print_compact_traceback("exception in draw_wirespheres part of draw_in_abs_coords ignored: ")

- def howdraw(self, dispdef): # warning: if you add env.prefs[] lookups to this routine, modify selradius_prefs_values!

- #bruce 060307 moved all this into else clause; this might prevent some needless (and rare)

- # gl_updates when all is shown in Tubes but prefs for other dispmodes are changed.

- rad = self.element.rvdw # correct value for diTrueCPK (formerly, default); modified to produce values for other dispmodes

- def selradius_prefs_values(): # staticmethod in Atom #bruce 060317 for bug 1639 (and perhaps an analogue for other prefs)

- def selradius_squared(self): # warning: if you add env.prefs[] lookups to this routine, modify selradius_prefs_values!

- posn = self.ideal_posn_re_neighbor( self.singlet_neighbor(), pretend_I_am = Hydrogen ) # see also self.sim_posn()

- disp = "openbond" # kluge, meant as a comment in the file #bruce 051115 changed this from "singlet" to "openbond"

- (self, self.molecule.assy.ppa2, vlen(self.posn()-self.molecule.assy.ppa2.posn()))) # fix bug 366-2 ninad060721

- print_compact_traceback("bug, fyi: ignoring exception in atom distance computation: ") #bruce 050218

- # this is surely bad in only remaining use (depositMode.getCoords):

- return # mark 060303. [note: bruce 060321 has always thought it was nonmodular to check this here]

- #bruce 060331 comment: we can't move this inside the conditional to optimize it, since we want it to affect

- # whether we set picked_time, but we want to set that even for already-picked atoms.

- # (Which are reasons of dubious value if this missed optim is important (don't know if it is), but are real ones.)

- self._picked_time = self.molecule.assy._select_cmd_counter #bruce 051031, for ordering selected atoms; two related attrs

- Return something which can be sorted to determine the order in which atoms were selected; include tiebreakers.

- Legal to call even if self has never been selected or is not currently selected,

- though results will not be very useful then.

- def unpick(self, filtered = True): #bruce 060331 adding filtered = False option, as part of fixing bug 1796

- # note: this is inlined (perhaps with filtered = False, not sure) into assembly.unpickatoms (in ops_select.py)

- Add singlets (or do equivalent invals) as if origbond was copied from origatom

- onto self (a copy of origatom), then broken; uses origatom

- so it can find the other atom and know bond direction in space

- (it assumes self might be translated but not rotated, wrt origatom).

- For now this works like mol.copy used to, but later it might "inval singlets" instead.

- # compare to code in Bond.unbond() (maybe merge it? ####@@@@ need to inval things to redo singlets sometimes?)

- x = Atom('X', b.ubp(a), numol) ###k verify Atom.__init__ makes copy of posn, not stores original (tho orig ok if never mods it)

- bond_copied_atoms(na, x, origbond, origatom) # same properties as origbond... sensible in all cases?? ##k

- from dna.updater.dna_updater_globals import get_dnaladder_inval_policy, DNALADDER_INVAL_IS_NOOP_BUT_OK

- # can't be a toplevel import for now

- print "fyi: bug: unbond on a singlet %r finds unexpected bonds left over in it, %r" % (self, self.bonds)

- #bruce 060327 optim of Chunk.kill: if we're being killed right now, don't make a new bondpoint

- def singNeighbors(self): #e when we have only one branch again, rename this singletNeighbors or bondpointNeighbors

- Return a list of the baggage bonded to this atom (monovalent neighbors which should be dragged along with it),

- and a list of the others (independent neighbors). Special case: in H2 (for example) there is no baggage

- (so that there is some way to stretch the H-H bond); but singlets are always baggage, even in HX.

- # Note: we do this even if self.element is elt and self.atomtype is not elt.atomtypes[0] !

- # That is, passing no atomtype is *always* equivalent to passing elt's default atomtype,

- # even if this results in changing this atom's atomtype but not its element.

- # moving this atom to its neighbor atom's chunk, too

- # [btw we *do* permit self.element is Singlet before we change it]

- print_compact_stack( "atom_debug: fyi, bug?: mvElement changing %r to its existing element and atomtype" % self )

- return #bruce 050509, not 100% sure it's correct, but if not, caller probably has a bug (eg relies on our invals)

- print "debug: better_alive_answer is %r but (not self.__killed) is %r" % (better_alive_answer , not self.__killed)

- _changed_structure_Atoms[self.key] = self #k not sure if needed; if it is, also covers .bonds below #bruce 060322

- newlen = my_atype.rcovalent + its_atype.rcovalent #k Singlet.atomtypes[0].rcovalent better be 0, check this

- def Passivate(self): ###@@@ not yet modified for atomtypes since it's not obvious what it should do! [bruce 050511]

- # bruce 041215 modified docstring, added comments, capitalized name

- return self.element is Singlet # [bruce 050502 comment: it's possible self is killed and len(self.bonds) is 0]

- # higher-valence bonds methods [bruce 050502] [bruce 050627 comment: a lot of this might be obsolete. ###@@@]

- singlet_valence = singlet_v6 ###@@@ need to decide which name to keep! probably this one, singlet_valence. [050502 430pm]

-

- # (and letting it take advantage of the singlet's position, when it updates things)

- assert self.element is Singlet, "%r should be a singlet but is %s" % (self, self.element.name)

- assert len(self.bonds) == 1, "%r should have exactly 1 bond but has %d" % (self, len(self.bonds))

- self.bonds[0].reduce_valence_noupdate(vdelta, permit_illegal_valence = True) # permits in-between, 0, or negative(?) valence

- warning: following docstring used to be a comment, hasn't been verified recently:

- repositions/alters existing bondpoints, updates bonding pattern, valence errors, etc;

- might reorder bonds, kill bondpoints; but doesn't move the atom and doesn't alter

- existing real bonds or other atoms; it might let atom record how it wants to move,

- when it has a chance and wants to clean up structure, if this can ever be ambiguous

- later, when the current state (including positions of old bondpoints) is gone.

- self._modified_valence = False # do this first, so exceptions in the following only happen once

- # the only easy part is to kill bondpoints with illegal valences, and warn if those were not 0.

- for sing in self.singNeighbors(): ###@@@ check out the other calls of this for code that might help us here...

- sv = sing.singlet_valence()

- print "atom_debug: update_valence %r killed %d zero-valence and %d bad-valence bondpoints" % \

- ###e now fix things up... not sure exactly under what conds, or using what code (but see existing code mentioned above)

- #bruce 050702 working on bug 121, here is a guess: change atomtype to best match new total number of bonds

- # (which we might have changed by killing some bondpoints). But only do this if we did actually kill bondpoints.

- #bruce 050728 temporary fix for bug 823 (in which C(sp2) is left with 2 order1 bondpoints that should be one bondpoint);

- # but in the long run we need a more principled way to decide whether to remake bondpoints or change atomtype

- # when they don't agree:

- If this atom's number of bonds (including open bonds) is better matched

- by some other atomtype of its element than by its current atomtype, or if

- its atomtype is not yet set, then change to the best atomtype and (if atomtype

- was already set) emit a history message about this change.

- The comparison is of current atomtype to self.best_atomtype_for_numbonds().

- dont_revise_bondpoints is not passed (since set_atomtype also

- remakes bondpoints in better positions), or by set_atomtype_but_dont_revise_singlets

- otherwise (no attempt is made to correct the number of open bonds in that case).

- env.history.message("changing %s atomtype from %s to %s" % (self, atype_now.name, best_atype.name))

- # this will often happen twice, plus a third message from Build that it increased bond order,

- # so i'm likely to decide not to print it

- # right number of open bonds for new atype -- let's move them to better positions when we set it

- def best_atomtype_for_numbonds(self, atype_now = None, elt = None): #bruce 050702; elt arg added 050707

- # see also best_atype in bond_utils.py, which does something different but related [bruce 060523]

- (or for the passed element <elt>, if any)

- and number of bonds (including open bonds),

- breaking ties by favoring <atype_now> (if provided),

- otherwise favoring atomtypes which come earlier

- in the list of this element's (or elt's) possible atomtypes.

-

- For comparing atomtypes which err in different directions (which I doubt can ever matter in

- practice, since the range of numbonds of an element's atomtypes will be contiguous),

- we'll say it's better for an atom to have too few bonds than too many.

- In fact, we'll say any number of bonds too few (on the atom, compared to the atomtype)

- is better than even one bond too many.

-

- This means: the "best" atomtype is the one with the right number of bonds, or the fewest extra bonds,

- or (if all of them have fewer bonds than this atom) with the least-too-few bonds.

-

- (This method is used in Build mode, and might later be used when reading mmp files or pdb files, or in other ways.

- As of 050707 it's also used in Transmute.)

- [###k Should we also take into account positions of bonds, or their estimated orders, or neighbor elements??]

- nbonds = len(self.bonds) # the best atomtype has numbonds == nbonds. Next best, nbonds+1, +2, etc. Next best, -1,-2, etc.

- if atype is atype_now: # (if atype_now is None or is not for elt, this is a legal comparison and is always False)

- i = -1 # best to stay the same (as atype_now), or to be earlier in the list of atomtypes, other things being equal

- This must be called by all low-level methods which change this atom's or bondpoint's element, atomtype,

- or set of bonds. It doesn't need to be called for changes to neighbor atoms, or for position changes,

- or for changes to chunk membership of this atom, or when this atom is killed (but it will be called indirectly

- when this atom is killed, when the bonds are broken, unless this atom has no bonds). Calling it when not needed

- is ok, but might slow down later update functions by making them inspect this atom for important changes.

- (For example, calling it on a PAM atom invalidates that atom's entire DnaLadder.)

-

- All user events which can call this (indirectly) should also call env.do_post_event_updates() when they're done.

- """

- ####@@@@ I suspect it is better to also call this for all killed atoms or bondpoints, but didn't do this yet. [bruce 050725]

- #e could probably optim by importing this dict at toplevel, or perhaps even assigning a lambda in place of this method

- def invalidate_everything(self): # for an atom, remove it and then readd it to its chunk

- debugging method

- print "warning: invalidate_everything on the lone atom %r in chunk %r does nothing" % (self, self.molecule)

- #bruce 080318 bugfix: don't do this if only one atom; revise print above to say so

- # note: delatom invals self.bonds

- self.molecule.delatom(self) # note: this kills the chunk if it becomes empty!

- ## this code might be used if we don't always return due to bond valence: ###@@@

- ## atomtype = self.atomtype # use current atomtype if we're correct for it now, even if it's not default atomtype

- def Transmute_selection(self, elt): #bruce 070412; could use review for appropriate level, error handling, etc

- permitted = {} # maps each permitted v6 to the list of atomtypes which permit it (in same order as self.element.atomtypes)

- # if we changed self to that atomtype, how high could bond's valence be? (expressed as its permitted valences)

- # There are two limits: atype.permitted_v6_list, and atype.valence minus min_other_valence.

- # But the min_other_valence is the max of two things: other real bonds, or required numbonds (for this atype)

- # minus 1 (really, that times the minimum bond order for this atomtype, if that's not 1, but minimum bond order

- # not being 1 is nim in all current code).

- # (BTW, re fixed bug 1944, I don't know why double is in N(sp2)g's permitted_v6_list, and that's wrong

- # and remains unfixed, though our_min_other_valence makes it not matter in this code.)

- reload_once_per_event(reposition_baggage) # this can be removed when devel is done, but doesn't need to be

- atom.mvElement(Singlet) ####k ??? #####@@@@@ kluge to kill it w/o replacing w/ singlet; better to just tell kill that

- #bruce 050510 extending this to use atomtypes; all subrs still need to set singlet valence ####@@@@

- #bruce 050728 new feature: for new pi bonds to sp atoms, use pi_info to decide where to pretend a2 lies.

- # If we give up, it's safe to just say a2pos = a1.posn() -- twistor() apparently tolerates that ambiguity.

- # catch exceptions in case for some reason it's too early to compute this...

- # note that, if we're running in Build mode (which just deposited self and bonded it to a1),

- # then that new bond and that change to a1 hasn't yet been seen by the bond updating code,

- # so an old pi_info object might be on the other bonds to a1, and none would be on the new bond a1-self.

- # But we don't know if this bond is new, so if it has a pi_bond_obj we don't know if that's ok or not.

- # So to fix a bug this exposed, I'm making bond.rebond warn the pi_bond_obj on its bond, immediately

- # (not waiting for bond updating code to do it).

- # [050729: this is no longer needed, now that we destroy old pi_bond_obj (see below), but is still done.]

- b = self.bonds[0] # if there was not just one bond on self, we'd say find_bond(self,a1)

- #bruce 050729: it turns out there can be incorrect (out of date) pi_info here,

- # from when some prior singlets on self were still there -- need to get rid of this and recompute it.

- # This fixes a bug I found, and am reporting, in my mail (not yet sent) saying bug 841 is Not A Bug.

- pi_info = b.get_pi_info(abs_coords = True) # without the option, vectors would be in bond's coordsys

- # note that we don't know whether we're atom1 or atom2 in that info, but it shouldn't matter

- # since self is not affecting it so it should not be twisted along b.

- # So we'll pretend a1py, a1pz are about a1, though they might not be.

- # We'll use a1pz as the relative place to imagine a1's neighbor, if a1 had been sp2 rather than sp.

- # the following old code has the wrong sign on spin, thus causing bug 661: [fixed by bruce 050614]

- # but as an example of how to use debug_pref, I'll put in code that can do it either way,

- # with the default pref value giving the correct behavior (moved just above, outside of this loop).

- # [bruce 050716 comment: one time this can happen is when we change atomtype of some C in graphite to sp3]

- print "atom_debug: fyi: self at center of its neighbors (more or less) while making singlet", self, self.bonds

- # that assumes s1 and s2 are not opposite each other; #e it would be safer to pick best of all 3 pairs

-@author: Josh

-bruce optimized some things, including using 'is' and 'is not' rather than '==', '!='

-for atoms, molecules, elements, parts, assys in many places (not all commented individually); 050513

-

-bruce 060308 rewriting Atom and Chunk so that atom positions are always stored in the atom

-(eliminating Atom.xyz and Chunk.curpos, adding Atom._posn, eliminating incremental update of atpos/basepos).

-Motivation is to make it simpler to rewrite high-frequency methods in Pyrex.

-

-bruce 060313 splitting _recompute_atlist out of _recompute_atpos, and planning to remove atom.index from

-undoable state. Rules for atom.index (old, reviewed now and reconfirmed): owned by atom.molecule; value doesn't matter

-unless atom.molecule and its .atlist exist (but is set to -1 otherwise when this is convenient, to help catch bugs);

-must be correct whenever atom.molecule.atlist exists (and is reset when it's made); correct means it's an index for

-that atom into .atlist, .atpos, .basepos, whichever of those exist at the time (atlist always does).

-This means a chunk's addatom, delatom, and _undo_update need to invalidate its .atlist,

-and means there's no need to store atom.index as undoable state (making diffs more compact),

-or to update a chunk's .atpos (or even .atlist) when making an undo checkpoint.

-

-(It would be nice for Undo to not store copies of changed .atoms dicts of chunks too, but that's harder. ###e)

-

-[update, bruce 060411: I did remove atom.index from undoable state, as well as chunk.atoms, and I made atoms always store

-their own absposns. I forgot to summarize the new rules here -- maybe I did somewhere else. Looking at the code now,

-atoms still try to get baseposns from their chunk, which still computes that before drawing them; moving a chunk

-probably invalidates atpos and basepos (guess, but _recompute_atpos inval decl code would seem wrong otherwise)

-and drawing it then recomputes them -- or maybe not, since it's only when remaking display list that it should need to.

-Sometime I should review this and see if there is some obvious optimization needed.]

- # class constants to serve as default values of attributes, and _s_attr decls for some of them

- _s_attr_hotspot = S_REF #bruce 060404 revised this in several ways; bug 1633 (incl. all subbugs) will need retesting.

- # Note that this declares hotspot, not _hotspot, so that undo state never contains dead atoms.

- # This is only ok because we provide _undo_setattr_hotspot as well.

- # Note that we don't put this (or Jig.atoms) into the 'atoms' _s_attrlayer, since we still need to scan them as data.

- # Here are some old comments from when this declared _hotspot, still relevant:

- #e we need to warn somehow if you hit a StateMixin object in S_REF but didn't store state for it

- # (as could happen when we declared _hotspot as data, not child, and it could be a dead atom);

- #e ideally we'd add debug code to detect the original error (declaring hotspot),

- # due to presence of a _get_hotspot method; maybe we'd have an optional method (implemented by InvalMixin)

- # to say whether an attr is legal for an undoable state decl. But (060404) there needs to be an exception,

- # e.g. when _undo_setattr_hotspot exists, like now.

- is_movable = True #mark 060120 [no need for _s_attr decl, since constant for this class -- bruce guess 060308]

- # Undoable/copyable attrs: (no need for _s_attr decls since copyable_attrs provides them)

- # [bruce 080321 for PAM3+5] ### TODO: use for conversion, and prevent ladder merge when different

- display_as_pam = "" # PAM model to use for displaying and editing PAM atoms in self (not set means use user pref)

- save_as_pam = "" # PAM model to use for saving self (not normally set; not set means use save-op params)

- # no need to _s_attr_ decl basecenter and quat -- they're officially arbitrary, and get replaced when things get recomputed

- assert self.assy is not None #bruce 080227 guess (from docstring) [can fail, 080325, tom bug when updater turned on after separate @@@]

- # This permits us to not store atom.index as undoable state, and to not update self.atpos before undo checkpoints.

- # [bruce 060313]

- self.invalidate_everything() # this is probably overkill, but its call of self.invalidate_atom_lists() is certainly needed

- del self._colorfunc #bruce 060308 precaution; might fix (or cause?) some "Undo in Extrude" bugs

- def _undo_setattr_hotspot(self, hotspot, archive): #bruce 060404; 060410 use store_if_invalid to fix new bug 1829

- this lets us handle that specially, just for self.hotspot, but in unknown order (for now)

- relative either to our attrs or other objects.

- # to avoid duplicating this code; TODO: inline this method when it soon returns a constant True

- Choice_boolean_True,

- prefs_key = True,

- non_debug = True )

- ## dad = None #bruce 050216 removed dad from __init__ args, since no calls pass it

- # and callers need to do more to worry about the location anyway (see comments above)

- # for use by anything that wants to store its own memo data on us, using a key it's sure is unique [bruce 060608]

- # (when we eventually have a real destroy method, it should zap this; maybe this will belong on class Node #e)

- complementBaseName= getComplementSequence(str(baseName))

- if debug_pref("GLPane: print deleted display lists", Choice_boolean_False): #bruce 071205 made debug pref

- self.changed() #bruce 060324 fix bug 1532, and an unreported bug where this didn't mark file as modified

- if not store_if_invalid: # (when that's true, it's important not to recompute self.hotspot, even in an assertion)

- # now recompute self.hotspot from the new self._hotspot (to check whether it's valid)

- self.hotspot # this has side effects we depend on!

- def node_icon(self, display_prefs): # bruce 050109 revised this [was seticon]; revised again 060608

- # Special case for protein icon. This only adds the icon to the MT.

- # To add the protein icon for PM_SelectionListWidget, the attr iconPath

- # was modified in isProteinChunk(). --Mark 2008-12-16.

-

- # probably one of those new-fangled ChunkDisplayModes [bruce 060608]

- # hmm, some sort of bug

- (except for optimized callers like Chunk.merge, and others with comments saying they inline it).

- Add an existing atom (with no current Chunk, and with a valid literal

- Details of invalidations: Curpos must be left alone (so as not

- (It's not worth tracking changes to the set of singlets in the mol,

- Remove atom from the Chunk self, preparing atom for being destroyed

- # this is what makes it ok for atom indices to be invalid, as they are when self.atoms changes,

- # until self.atlist is next recomputed [bruce 060313 comment]

- ## AssertionError: validate_attr finds no attr 'externs' was saved, in <Chunk 'Ring Gear' (5167 atoms) at 0xd967440>

- # now this is done in that method: attrs.sort() # be deterministic even if it hides bugs for some orders

- # now this is done in that method: attrs.sort() # be deterministic even if it hides bugs for some orders

- # initial implem might be too conservative; should optimize, perhaps recode in a new Pyrex ChunkBase.

- # Some code is copied from now-obsolete setatomposn; some of its comments might apply here as well.

- self.invalidate_attr('atpos') #e should optim this ##k verify this also invals basepos, or add that to the arg of this call

-#bruce 060119 commenting these out since they are not used, though if we want them it's fine to add them back.

- assert not self.valid_attrs(), "full_inval_and_update forgot to invalidate something: %r" % self.valid_attrs()

- assert not self.invalid_attrs(), "full_inval_and_update forgot to update something: %r" % self.invalid_attrs()

- atomitems.sort() # in order of atom keys; probably doesn't yet matter but makes order deterministic

- def _recompute_atpos(self): #bruce 060308 major rewrite; #bruce 060313 splitting _recompute_atlist out of _recompute_atpos

- # Something must have been invalid to call us, so basepos must be invalid. So we needn't call changed_attr on it.

- # [bruce comment 050702: this happens if you delete the chunk while dragging it by selatom in build mode]

- print_compact_stack("atom_debug: fyi, recompute atpos called on killed mol %r: " % self)

- atpos = map( lambda atom: atom.posn(), atlist ) # atpos, basepos, and atlist must be in same order

- # unary '+' prevents mods to basecenter from affecting average_position;

- # it might not be needed (that depends on Numeric.array += semantics).

- # Note: basecenter is arbitrary, but should be somewhere near the atoms...

- # except see set_basecenter_and_quat, used in extrudeMode -- it may be that it's not really arbitrary

- # due to kluges in how that's used [still active as of 070411].

- # arbitrary value, except we assume it has this specific value to simplify/optimize the next line

- # set now (rather than when next needed) so it's still safe to assume self.quat == Q(1,0,0,0)

- ###k Could we fix that by just assigning atpos to it (no elements, so should be correct)?? [bruce 060119 question]

- # as of 060308 atpos (when defined) is a separate array object, since curpos no longer exists.

- # (and now also needed by BorrowerChunk during draw_dispdef's call of _dispfunc [bruce 060411])

- self.bbox.scale() + (MAX_ATOM_SPHERE_RADIUS - BBOX_MIN_RADIUS) + 0.5)

- # (This is probably not actually needed at the moment,

- # due to a special system used by self.changeapp() in place of self.track_change(),

- # but it should be harmless.)

- # (if that happens and grabs the pref value, I think this won't subscribe our display list to it,

- # since we're outside the begin/end for that, and that's good, since we include this in havelist

- # instead, which avoids some unneeded redrawing, e.g. if pref changed and changed back while

- # displaying a different Part. [bruce 060215])

- # update, bruce 080930: that point is probably moot, since drawLevel is part of havelist.

- if self.havelist == (disp, eltprefs, matprefs, drawLevel): # value must agree with set of havelist, below

- # our main display list is still valid -- use it

- # only count when it was set to 0 externally, not just when it doesn't match and we reset it below.

- # (Note: current code will also increment this every frame, when wantlist is false.

- # I'm not sure what to do about that. Could we set it here to False rather than 0, so we can tell?? ##e)

- ##e in future we might also record eltprefs, matprefs, drawLevel (since they're stored in .havelist)

- pass # end of the case where our "main display list (and all extra lists) needs to be remade"

- #self._draw_selection_frame(glpane, delegate_selection_wireframe, hd) #bruce 060608 moved this here

- if self.hotspot is not None: # note, as of 050217 that can have side effects in getattr

- self.overdraw_hotspot(glpane, disp) # only does anything for pastables as of 050316 (toplevel clipboard items)

- # Someday we might decide to record whether that's true when recomputing externs,

- # and to invalidate it as needed -- since it's rare for atoms to override display modes.

- # Or we might even keep a list of all our atoms which override our display mode. ###e

- ### REVIEW: efficient under all settings of debug_prefs?? [bruce 080702 question]

-## def _draw_selection_frame(self, glpane, delegate_selection_wireframe, hd): #bruce 060608 split this out of self.draw

- self.standard_draw_chunk(glpane, disp0)

- self.standard_draw_atoms(glpane, disp0)

- def standard_draw_chunk(self, glpane, disp0, highlighted = False):

- [private submethod of self.draw:]

- as if self's display mode was disp0;

- this occurs inside our local coordinate system and display-list-making,

- and it doesn't occur if chunk drawing is delegated to our display mode.

-

- @note: as of 080605 nothing is ever drawn for a chunk as a whole,

- so this method does nothing (in this class or any subclass).

- That might change, e.g. if we made chunks able to show their

- axes, name, bbox, etc.

- """

- #bruce 060608 split this out of _draw_for_main_display_list

- if self.picked and not (drawing_globals.allow_color_sorting and drawing_globals.use_color_sorted_dls):

- #bruce disable this case when using drawing_globals.use_color_sorted_dls

- def standard_draw_atoms(self, glpane, disp0): #bruce 060608 split this out of _draw_for_main_display_list

- # bruce 041014 hack for extrude -- use _colorfunc if present [part 1; optimized 050513]

- _colorfunc = self._colorfunc # might be None [as of 050524 we supply a default so it's always there]

- _dispfunc = self._dispfunc #bruce 060411 hack for BorrowerChunk, might be more generally useful someday

- for atom in self.atoms.itervalues(): #bruce 050513 using itervalues here (probably safe, speed is needed)

- # bruce 041014 hack for extrude -- use _colorfunc if present [part 2; optimized 050513]

- print_compact_traceback("bug in _colorfunc for %r and %r: " % (self, atom)) #bruce 060411 added errmsg

- #bruce 060411 hack for BorrowerChunk; done here and in this way in order to not make

- # ordinary drawing inefficient, and to avoid duplicating this entire method:

- ###e (I might need to specialcase it for singlets so their bond-valence number is still drawn...)

- # [bruce 050513]

- # (this might mean some externs are missing; never mind that for now.) [bruce 050513 -- not anymore]

- atom_source = atom._source # optional atom-specific debug info

- return # from standard_draw_atoms (submethod of _draw_for_main_display_list)

- self.set_hotspot(hs) # this assertfails if hotspot is invalid [#k does caller handle that? ####@@@@]

- # val should be 3 decimal ints from 0-255; colors of None are not saved since they're the default

- print "fyi: info chunk display_as_pam with unrecognized value %r" % (val,) # deferred_summary_message?

- print "fyi: info chunk save_as_pam with unrecognized value %r" % (val,) # deferred_summary_message?

- # [bruce 050516 comment (95% sure it's right): note that we don't, and need not, inval internal bonds]

- Set our atom's positions en masse from the given array, doing no chunk or bond invals

- (caller must do whichever invals are needed, which depends on how the positions changed).

- The array must be in the same order as self.atpos (its typical value, but we won't depend

- on that and won't access or modify self.atpos) and self.atlist (which must already exist).

- map anything (which is accepted by quat.rot() and Numeric.array's '+' method)

- from Chunk-relative coords to absolute coords;

- guaranteed to never recompute basepos/atpos or modify the mol-relative

- coordinate system it uses. Inverse of abs_to_base.

- map anything (which is accepted by quat.unrot() and Numeric.array's '-' method)

- from absolute coords to mol-relative coords;

- guaranteed to never recompute basepos/atpos or modify the mol-relative

- coordinate system it uses. Inverse of base_to_abs.

- It's deprecated since basecenter and quat are replaced by

- in-principle-arbitrary values every time certain recomputations are done

- after self's geometry might have changed, but this method is only useful

- if the caller knows what they are, and computes the new ones it wants

- relative to what they are, which in practice means the caller must

- be able to prevent modifications to self during an entire period

- when it wants to be able to call this method repeatedly on self.

- So it's much better to use self.pivot instead (or some combo of move,

- self.basepos # bruce 050315 bugfix: recompute this if it's currently invalid!

- self.quat = Q(1,0,0,0) + quat #e +quat might be correct and faster... don't know; doesn't matter much

- glpane = self.glpane # the last glpane that drew this chunk, or None if it was never drawn

- # (if more than one can ever draw it at once, this code needs to be revised to scan them all ##k)

- #As of 2008-11-09, this is only implemented for a DnaStrand.

-

-

- def getinfo(self):

- # Return information about the selected chunk for the msgbar [mark 2004-10-14]

-

- if self is self.assy.ppm: return

- if not ele2Num.has_key(a.element.symbol): ele2Num[a.element.symbol] = 1 # New element found

- else: ele2Num[a.element.symbol] += 1 # Increment element

- else: eleStr = "[" + item[0] + ": " + str(item[1]) + "] "

- if nsinglets: # Add singlet info to end of info string

- #bruce 041227 changed term "Singlets" to "Open bonds"

- natoms -= nsinglets # The number of real atoms in this chunk

- # ppm is self for next mol picked.

- def pickatoms(self): # mark 060211. Could use a complementary unpickatoms() method. [not referring to the one in ops_select --bruce]

- Pick the atoms of self not already picked. Return the number of newly picked atoms.

- # Just in case it didn't get picked due to a selection filter.

- #bruce 050308 comment: _superclass.pick (Node.pick) has ensured that we're in the current selection group,

- # so it's correct to append to selmols, *unless* we recompute it now and get a version

- # which already contains self. So, we'll maintain it iff it already exists.

- # Let the Part figure out how best to do this.

- eltprefs = PeriodicTable.rvdw_change_counter # (color changes don't matter for this, unlike for havelist)

- radiusprefs = Atom.selradius_prefs_values() #bruce 060317 -- include this in the tuple below, to fix bug 1639

- # don't have them, or have them for wrong display mode, or for wrong element-radius prefs

-

- # Old methods for finding certain atoms or singlets

- # [bruce 060313 removed even the commented-out forms, last present in rev. 1.109]

- #

- # [bruce 041207 comment: these [removed old methods] ought to be unified, and perhaps bugfixed.

- # To help with this, I'm adding comments, listing their callers,

- # and removing the ones with no callers.

- # See also some relevant code used in extrudeMode.py,

- # actually findHandles_exact in handles.py,

- # which will be useful for postprocessing lists of atoms

- # found by code like the following.

- # ]

- ## ....

-

- assert 0, "should never be called, since a chunk does not *refer* to selatoms, or appear in atom.jigs"

- def copy_empty_shell_in_mapping(self, mapping): #bruce 070430 revised to honor mapping.assy

- self.copy_copyable_attrs_to(numol) # copies .name (redundantly), .hidden, .display, .color...

- def copy_full_in_mapping(self, mapping): # Chunk method [bruce 050526] #bruce 060308 major rewrite

- numol = self.copy_empty_shell_in_mapping( mapping)

-## if 0:

-## # I'm not sure how to make this correct, since it doesn't copy everything recomputed

-## # when we recompute atlist/atpos/basepos; beside's it's often wasted work since caller plans to

-## # move all the atoms after the copy, or so... so nevermind.

-## numol.atlist = copy_val(self.atlist)

-## numol.atpos = copy_val(self.atpos) # use copy_val in case length is 0 and type is unusual

-## numol.basepos = copy_val(self.basepos)

-

- mapping.do_at_end( lambda ch = copy_of_hotspot, numol = numol: numol._preserve_implicit_hotspot(ch) )

- #e could be integrated with mapping.do_at_end,

- # since externs should not be too frequent); could do all this in a Bond method #e

- # arbitrary condition which is true for exactly one ordering of the atoms;

- # note both keys are for original atoms (it would also work if both were from

- # a->na mapping will be needed outside this method, to copy or break this bond

- numol = self.copy_empty_shell_in_mapping( mapping)

- # Could do this uniformly in copy_empty_shell_in_mapping,

- for a in self.atlist: # 060308 changed similarly to copy_full_in_mapping (shares some code with it)

- if extern_atoms_bonds:

- pass ## print "fyi: mol.copy didn't copy %d extern bonds..." % len(extern_atoms_bonds)

-##Chunk = molecule #bruce 051227 permit this synonym; for A8 we'll probably rename the class this way

-##

-##del molecule #bruce 071113 along with revising all uses to refer to Chunk (except the classname itself)

-##

-### Note: we can't rename the class until all string literals 'molecule' are reviewed. [has been done now]

-