path: root/cad/src/dna/commands/JoinStrands/ClickToJoinStrands_Command.py

# Copyright 2008 Nanorex, Inc.  See LICENSE file for details.
"""
@author:    Ninad
@version:   $Id$
@copyright: 2008 Nanorex, Inc.  See LICENSE file for details.
@license:   GPL

History:
2008-10-22: Created to support single click join strand operation
Example: while in this command, if user clicks anywhere on a strand, its 3'end
is joined to the nearest 5' end on the same dnasegment.

TODOs as of 2008-10-26:
- Method _bond_two_strandAtoms needs refactoring and to be moved to a dna_helper
package.
"""
import foundation.env as env
from dna.commands.JoinStrands.JoinStrands_PropertyManager import JoinStrands_PropertyManager
from commands.Select.Select_Command import Select_Command
from dna.commands.JoinStrands.ClickToJoinStrands_GraphicsMode import ClickToJoinStrands_GraphicsMode
import foundation.env as env
from utilities.prefs_constants import joinStrandsCommand_clickToJoinDnaStrands_prefs_key
from utilities.debug import print_compact_stack
from utilities.constants import CL_SUBCOMMAND
from model.bonds import bond_at_singlets
from geometry.NeighborhoodGenerator import NeighborhoodGenerator
from utilities.prefs_constants import joinStrandsCommand_recursive_clickToJoinDnaStrands_prefs_key
from geometry.VQT import vlen
# == Command part

_superclass = Select_Command
class ClickToJoinStrands_Command(Select_Command):
    """
    Command part for joining two strands.
    @see: superclass B{BreakOrJoinStrands_Command}
    """
    # class constants

    commandName = 'CLICK_TO_JOIN_STRANDS'
    featurename = "Click To Join Strands"
    GraphicsMode_class = ClickToJoinStrands_GraphicsMode

    FlyoutToolbar_class = None
    command_should_resume_prevMode = False
    command_has_its_own_PM = False

    #class constants for the NEW COMMAND API -- 2008-07-30
    command_level = CL_SUBCOMMAND
    command_parent = 'JOIN_STRANDS'


    def command_update_state(self):
        """
        See superclass for documentation.
        Note that this method is called only when self is the currentcommand on
        the command stack.
        @see: BuildAtomsFlyout.resetStateOfActions()
        @see: self.activateAtomsTool()
        """
        _superclass.command_update_state(self)

        #Make sure that the command Name is JOIN_STRANDS. (because subclasses
        #of JoinStrands_Command might be using this method).
        #As of 2008-10-23, if the checkbox 'Click on strand to join'
        #in the join strands PM is checked, NE1 will enter a command that
        #implements different mouse behavior in its graphics mode and will stay
        #there.
        if self.commandName == 'CLICK_TO_JOIN_STRANDS' and \
           not env.prefs[joinStrandsCommand_clickToJoinDnaStrands_prefs_key]:

            self.command_Done()

    def joinNeighboringStrands(self, strand, endChoice = 'THREE_PRIME_END'):
        """
        Join the 3 or 5' end of the given strand with a 5' or 3' (respt) end of
        a neighboring strand, on the SAME DnaSegment.

        @param strand: The DnaStrand whose 3' or 5' end will be joined with
                       the 5' or 3' end base atom (respectively) on a
                       neighboring strand of the same DnaSegment.
        @type strand: DnaStrand
        @see: self._bond_two_strandAtoms()
        @TODO: implement code when endChoice is 'Five prime end'. At the moment,
        it works only for the the 3' end atom of <strand>.

        @see: ClickToJoinStrands_GraphicsMode.chunkLeftUp()
        """

        if not isinstance(strand, self.assy.DnaStrand):
            print_compact_stack("bug: %s is not a DnaStrand instance"%strand)
            return

        bool_recursively_join_strands = env.prefs[joinStrandsCommand_recursive_clickToJoinDnaStrands_prefs_key]

        if endChoice == 'THREE_PRIME_END':
            current_strand = strand

            count = 0

            #This implements a NFR by Mark. Recursively join the DnaStrand's
            #3 prime end with the 5' end of a neighboring strand.
            #This is SLOW for recursively joining strands.
            while(True):
                #If the 'recursivly join DnaStrand option is not checked
                #return immediately after the first interation (which joins
                #the two neighboring strands)
                if count == 1 and not bool_recursively_join_strands:
                    return

                endAtom = current_strand.get_three_prime_end_base_atom()
                if endAtom is None:
                    return

                #Now find the nearest five prime end atom on a strand of the
                #*same* Dna segment.
                axis_atom = endAtom.axis_neighbor()
                if axis_atom is None:
                    return

                segment = current_strand.get_DnaSegment_with_content_atom(endAtom)

                if segment is None:
                    return

                #find all five prime end base atoms contained by this DnaSegment.
                raw_five_prime_ends = segment.get_all_content_five_prime_ends()

                def func(atm):
                    """
                    Returns true if the given atom's strand is not same as
                    the 'strand' which is 'endAoms' parent DnaStrand

                    """
                    if atm.getDnaStrand() is current_strand:
                        return False

                    return True

                #Following ensures that the three prime end of <strand> won't be
                #bonded to the five prime end of the same strand.
                five_prime_ends = filter(lambda atm: func(atm), raw_five_prime_ends)

                #Max radius within which to search for the 'neighborhood' atoms
                #(five prime ends)
                maxBondLength = 10.0
                neighborHood = NeighborhoodGenerator(five_prime_ends, maxBondLength)

                pos = endAtom.posn()
                region_atoms = neighborHood.region(pos)

                #minor optimization
                if not region_atoms:
                    if not bool_recursively_join_strands:
                        print_compact_stack(
                            "No five prime end atoms found" \
                            "within %f A radius of the "\
                            "strand's 3 prime end"%(maxBondLength))
                    return
                elif len(region_atoms) == 1:
                    five_prime_end_atom = region_atoms[0]
                else:
                    lst = []
                    for atm in region_atoms:
                        length = vlen(pos - atm.posn())
                        lst.append((length, atm))
                    lst.sort()

                    #Five prime end atom nearest to the 'endAtom' is the contained
                    #within the first tuple of the sorted list 'tpl'
                    length, five_prime_end_atom = lst[0]

                self._bond_two_strandAtoms(endAtom, five_prime_end_atom)
                self.assy.update_parts()

                current_strand = endAtom.getDnaStrand()
                count += 1

        elif endChoice == 'FIVE_PRIME_END':
            #NOT IMPLEMENTED AS OF 2008-10-26
            endAtom = strand.get_five_prime_end_base_atom()
            if endAtom is None:
                return

    def _bond_two_strandAtoms(self, atm1, atm2):
        """
        Bonds the given strand atoms (sugar atoms) together. To bond these atoms,
        it always makes sure that a 3' bondpoint on one atom is bonded to 5'
        bondpoint on the other atom.

        @param atm1: The first sugar atom of PAM3 (i.e. the strand atom) to be
                     bonded with atm2.
        @param atm2: Second sugar atom

        @see: self.joinNeighboringStrands() which calls this

        TODO 2008-10-26: This method is originally from
        B_DNA_PAM3_SingleStrand class. It is modified further to account for
        color change after bonding the two strand atoms. It needs to
        be refactored and moved to a dna_helper package. [-- Ninad comment]
        """
        #Moved from B_Dna_PAM3_SingleStrand_Generator to here, to fix bugs like
        #2711 in segment resizing-- Ninad 2008-04-14
        assert atm1.element.role == 'strand' and atm2.element.role == 'strand'
        #Initialize all possible bond points to None

        five_prime_bondPoint_atm1  = None
        three_prime_bondPoint_atm1 = None
        five_prime_bondPoint_atm2  = None
        three_prime_bondPoint_atm2 = None
        #Initialize the final bondPoints we will use to create bonds
        bondPoint1 = None
        bondPoint2 = None

        #Find 5' and 3' bondpoints of atm1 (BTW, as of 2008-04-11, atm1 is
        #the new dna strandend atom See self._fuse_new_dna_with_original_duplex
        #But it doesn't matter here.
        for s1 in atm1.singNeighbors():
            bnd = s1.bonds[0]
            if bnd.isFivePrimeOpenBond():
                five_prime_bondPoint_atm1 = s1
            if bnd.isThreePrimeOpenBond():
                three_prime_bondPoint_atm1 = s1

        #Find 5' and 3' bondpoints of atm2
        for s2 in atm2.singNeighbors():
            bnd = s2.bonds[0]
            if bnd.isFivePrimeOpenBond():
                five_prime_bondPoint_atm2 = s2
            if bnd.isThreePrimeOpenBond():
                three_prime_bondPoint_atm2 = s2
        #Determine bondpoint1 and bondPoint2 (the ones we will bond). See method
        #docstring for details.
        if five_prime_bondPoint_atm1 and three_prime_bondPoint_atm2:
            bondPoint1 = five_prime_bondPoint_atm1
            bondPoint2 = three_prime_bondPoint_atm2
        #Following will overwrite bondpoint1 and bondPoint2, if the condition is
        #True. Doesn't matter. See method docstring to know why.
        if three_prime_bondPoint_atm1 and five_prime_bondPoint_atm2:
            bondPoint1 = three_prime_bondPoint_atm1
            bondPoint2 = five_prime_bondPoint_atm2

        #Do the actual bonding
        if bondPoint1 and bondPoint2:
            bond_at_singlets(bondPoint1, bondPoint2, move = False)
        else:
            print_compact_stack("Bug: unable to bond atoms %s and %s: " %
                                (atm1, atm2) )


        #The following fixes bug 2770
        #Set the color of the whole dna strandGroup to the color of the
        #strand, whose bondpoint, is dropped over to the bondboint of the
        #other strandchunk (thus joining the two strands together into
        #a single dna strand group) - Ninad 2008-04-09
        color = atm1.molecule.color
        if color is None:
            color = atm1.element.color
        strandGroup1 = atm1.molecule.parent_node_of_class(self.assy.DnaStrand)

        #Temporary fix for bug 2829 that Damian reported.
        #Bruce is planning to fix the underlying bug in the dna updater
        #code. Once its fixed, The following block of code under
        #"if DEBUG_BUG_2829" can be deleted -- Ninad 2008-05-01

        DEBUG_BUG_2829 = True

        if DEBUG_BUG_2829:
            strandGroup2 = atm2.molecule.parent_node_of_class(
                self.assy.DnaStrand)
            if strandGroup2 is not None:
                #set the strand color of strandGroup2 to the one for
                #strandGroup1.
                strandGroup2.setStrandColor(color)
                strandChunkList = strandGroup2.getStrandChunks()
                for c in strandChunkList:
                    if hasattr(c, 'invalidate_ladder'):
                        c.invalidate_ladder()