Difference between revisions of "User:Remig/plico/tug"

From Jmol
Jump to navigation Jump to search
(lc all functions)
(Avoid "axis," a newly reserved word)
 
(8 intermediate revisions by the same user not shown)
Line 1: Line 1:
'''Tug''' allows the user to pull or push by mouse actions to move or rotate one part of a polypeptide against the rest by rotation on its psi and phi bonds with collision detection and restriction.  It also allows the user to move an entire chain to nest against another chain.
+
'''Tug''' allows the user to pull or push by mouse actions to move or rotate one part of a polypeptide against the rest by rotation on its psi and phi bonds with collision detection and restriction.  It also allows the user to move an entire chain to nest against another chain. A full description of its capabilities can be found [[User:Remig/plico/tugManual|here]].
  
 
'''Tug''' is a member of the Plico suite of protein folding tools described in [[User:Remig/plico]] . It may be installed and accessed as a macro with the file:
 
'''Tug''' is a member of the Plico suite of protein folding tools described in [[User:Remig/plico]] . It may be installed and accessed as a macro with the file:
 
<pre>Title=PLICO Tug
 
<pre>Title=PLICO Tug
Script=script <path to your scripts folder>/tug.spt;plicotug</pre>
+
Script=script <path to your scripts directory>/tug.spt;plico_tug</pre>
 
saved as plicotug.macro in your .jmol/macros directory as described in [[Macro]].
 
saved as plicotug.macro in your .jmol/macros directory as described in [[Macro]].
  
Copy and paste the following into a text editor and save in your scripts folder as tug.spt.  
+
Copy and paste the following into a text editor and save in your scripts directory as tug.spt.  
 
<pre>#  tug - Jmol script by Ron Mignery
 
<pre>#  tug - Jmol script by Ron Mignery
#  v1.11 beta    5/16/2014 -lc all functions
+
#  v1.20 beta    4/12/2016 -axis is now a reserved word
 
#
 
#
 
#  Translate or rotate a stretch of a polypeptide against itself
 
#  Translate or rotate a stretch of a polypeptide against itself
Line 35: Line 35:
 
gCargoSet = ({})
 
gCargoSet = ({})
 
gMovingSet = ({})
 
gMovingSet = ({})
gBusy = FALSE
+
gBusy = false
 
gSCidx = -1
 
gSCidx = -1
 
gSCcircle = -1
 
gSCcircle = -1
 
gSCpt = {0 0 0}
 
gSCpt = {0 0 0}
 
gTargetPt = {0 0 0}
 
gTargetPt = {0 0 0}
gNewDrag = FALSE
+
gNewDrag = false
gEcho = ""
+
gTow = false
gZoom = ""
 
gRotate = ""
 
gTow = FALSE
 
 
g1dynamicIdx = -1
 
g1dynamicIdx = -1
 
g2dynamicIdx = -1
 
g2dynamicIdx = -1
gSCcheck = TRUE
+
gSCcheck = true
gBondPicking = FALSE
+
gBondPicking = false
 +
gFreeze = array()
 +
gToab = false
  
  
function get_cam_no (iNo) {
+
function get_cp_idx (idx) {
     while ((iNo > 0) and ({(atomno=iNo) and (chain=gChain)}.atomName != "CA")) {
+
    var no = {atomIndex=idx}.atomno
 +
    while ((no < gMaxNo) and ({(atomno=no) and (chain=gChain)
 +
        and thisModel}.atomName != "C")) {
 +
        no++
 +
    }
 +
    return ({(atomno=no) and (chain=gChain) and thisModel}.atomIndex)
 +
}
 +
 
 +
function get_cm_no (iNo) {
 +
     while ((iNo > 0) and ({(atomno=iNo) and (chain=gChain)
 +
        and thisModel}.atomName != "C")) {
 
         iNo--
 
         iNo--
 
     }
 
     }
Line 58: Line 67:
 
}
 
}
  
function get_cam_idx (idx) {
+
function get_nm_idx (idx) {
     var no = {atomIndex=idx and (chain=gChain)}.atomno
+
     var no = {atomIndex=idx}.atomno
     no = get_cam_no( no)
+
    while ((no > 0) and ({(atomno=no) and (chain=gChain)
     return ({(atomno=no) and (chain=gChain)}.atomIndex)
+
        and thisModel}.atomName != "N")) {
 +
        no--
 +
     }
 +
     return ({(atomno=no) and (chain=gChain) and thisModel}.atomIndex)
 
}
 
}
  
function get_cap_no (iNo) {
+
function get_np_no (iNo) {
     while ((iNo < gMaxNo) and ({(atomno=iNo) and (chain=gChain)}.atomName != "CA")) {
+
     while ((iNo < gMaxNo) and ({(atomno=iNo) and (chain=gChain)
 +
        and thisModel}.atomName != "N")) {
 
         iNo++
 
         iNo++
 
     }
 
     }
Line 71: Line 84:
 
}
 
}
  
function getCApIdx (idx) {
+
function get_cb_idx (BBidx) {
     var no = {atomIndex=idx and (chain=gChain)}.atomno
+
     var no = {atomIndex=BBidx}.atomno
     no = get_cap_no( no)
+
    var i = 1
     return ({(atomno=no) and (chain=gChain)}.atomIndex)
+
    for (; i < 5; i++) {
 +
        if ({(atomno=@{no+i}) and (chain=gChain)
 +
            and thisModel}.atomName == "CB") {
 +
            break
 +
        }
 +
     }
 +
     return {(atomno=@{no+i}) and (chain=gChain) and thisModel}.atomIndex
 
}
 
}
  
function get_cp_no (iNo) {
+
function get_o_idx (BBidx) {
     while ((iNo < gMaxNo) and ({(atomno=iNo) and (chain=gChain)}.atomName != "C")) {
+
     var no = {atomIndex=BBidx}.atomno
         iNo++
+
    var i = 1
 +
    for (; i < 4; i++) {
 +
        if ({(atomno=@{no+i}) and (chain=gChain)
 +
            and thisModel}.atomName == "O") {
 +
            break
 +
         }
 
     }
 
     }
     return iNo
+
     return {(atomno=@{no+i}) and (chain=gChain) and thisModel}.atomIndex
 
}
 
}
  
function get_cp_idx (idx) {
+
function get_nward_bb_idx (idx, iChain) {
     var no = {atomIndex=idx and (chain=gChain)}.atomno
+
     var no = {atomIndex=idx}.atomno - 1
     no = get_cp_no( no)
+
     for (; no >= 0; no--) {
    return ({(atomno=no) and (chain=gChain)}.atomIndex)
+
        var atomName = {(atomno=no) and (chain=iChain)
}
+
            and thisModel}.atomName
 
+
        if ((atomName = "N") or (atomName = "C") or (atomName = "CA")) {
function get_cm_no (iNo) {
+
            break
    while ((iNo > 0) and ({(atomno=iNo) and (chain=gChain)}.atomName != "C")) {
+
         }
         iNo--
 
 
     }
 
     }
     return iNo
+
     return ((no >= 0) ? ({(atomno=no) and (chain=iChain)
 +
        and thisModel}.atomIndex) : -1)
 
}
 
}
  
function get_cm_idx (idx) {
+
function get_cward_bb_idx (idx, iChain) {
     var no = {atomIndex=idx and (chain=gChain)}.atomno
+
     var no = {atomIndex=idx}.atomno + 1
    no = get_cm_no( no)
+
    for (; no < gMaxNo; no++) {
     return ({(atomno=no) and (chain=gChain)}.atomIndex)
+
        var atomName = {(atomno=no) and (chain=iChain)
 +
            and thisModel}.atomName
 +
        if ((atomName = "N") or (atomName = "C") or (atomName = "CA")) {
 +
            break
 +
        }
 +
    }
 +
     return ((no >= 0) ? ({(atomno=no) and (chain=iChain)
 +
        and thisModel}.atomIndex) : -1)
 
}
 
}
  
function get_nm_no (iNo) {
+
function get_sc_set (scIdx, iChain) {
     while ((iNo > 0) and ({(atomno=iNo) and (chain=gChain)}.atomName != "N")) {
+
     var scSet = ({})
         iNo--
+
    var idx = get_sc_bb_idx(scIdx, iChain)
 +
    var iNo = {atomIndex=idx}.atomno + 3
 +
 
 +
    for (var i = 1; i < 20; i++) {
 +
        idx = {(atomno=@{iNo+i}) and (chain=iChain)
 +
            and thisModel}.atomIndex
 +
        if (is_bb_idx(idx)) {
 +
            break
 +
         }
 +
        scSet = scSet or {atomIndex=idx}
 
     }
 
     }
     return iNo
+
     return scSet
 
}
 
}
  
function get_nm_idx (idx) {
+
function get_sc_bb_idx (idx, iChain) {
    var no = {atomIndex=idx and (chain=gChain)}.atomno
 
    no = get_nm_no( no)
 
    return ({(atomno=no) and (chain=gChain)}.atomIndex)
 
}
 
 
 
function get_np_no (iNo) {
 
    while ((iNo < gMaxNo) and ({(atomno=iNo) and (chain=gChain)}.atomName != "N")) {
 
        iNo++
 
    }
 
    return iNo
 
}
 
 
 
function get_np_idx (idx) {
 
 
     var no = {atomIndex=idx}.atomno
 
     var no = {atomIndex=idx}.atomno
     no = get_np_no( no)
+
     for (; no > 0; no--) {
    return ({(atomno=no) and (chain=gChain)}.atomIndex)
+
        if ({(atomno=no) and (chain=iChain)
}
+
            and thisModel}.atomName == "CA") {
 
+
            break
function get_cb_idx (BBidx) {
+
        }
    var no = {atomIndex=BBidx}.atomno
+
        else if ({(atomno=no) and (chain=iChain)
    var i = 1
+
            and thisModel}.atomName == "C") {
    for (; i < 5; i++) {
+
            break
         if ({(atomno=@{no+i}) and (chain=gChain)}.atomName == "CB") {
+
         }
 +
        else if ({(atomno=no) and (chain=iChain)
 +
            and thisModel}.atomName == "N") {
 
             break
 
             break
 
         }
 
         }
    }
+
         else if ({(atomno=no) and (chain=iChain)
    return {(atomno=@{no+i}) and (chain=gChain)}.atomIndex
+
            and thisModel}.atomName == "CB") {
}
+
            no -= 3
 
 
function get_o_idx (BBidx) {
 
    var no = {atomIndex=BBidx}.atomno
 
    var i = 1
 
    for (; i < 4; i++) {
 
         if ({(atomno=@{no+i}) and (chain=gChain)}.atomName == "O") {
 
 
             break
 
             break
 
         }
 
         }
 
     }
 
     }
     return {(atomno=@{no+i}) and (chain=gChain)}.atomIndex
+
     return {(atomno=no) and (chain=iChain) and thisModel}.atomIndex
 
}
 
}
  
function get_nward_bb_no (iNo, iChain) {
+
function is_bb_idx(aIdx) {
     while ((iNo >= 0) and (
+
     var ret = false
        ({(atomno=iNo) and (chain=iChain)}.atomName != "N")
+
    switch({atomIndex=aIdx}.atomName) {
        and ({(atomno=iNo) and (chain=iChain)}.atomName != "C")
+
    case "N":
         and ({(atomno=iNo) and (chain=iChain)}.atomName != "CA"))) {
+
    case "CA":
         iNo--
+
    case "C":
 +
         ret = true
 +
         break
 
     }
 
     }
     return iNo
+
     return ret
 
}
 
}
  
function get_nward_bb_idx (idx, iChain) {
+
function is_sc_idx(aIdx) {
     var no = {atomIndex=idx}.atomno - 1
+
 
     no = get_nward_bb_no( no, iChain)
+
     var ret = false
    return ((no >= 0) ? ({(atomno=no) and (chain=iChain)}.atomIndex) : -1)
+
     if (not is_bb_idx(aIDx)) {
 +
 
 +
        ret = true
 +
        switch({atomIndex=aIdx}.atomName) {
 +
        case "O":
 +
        case "CB":
 +
            ret = false
 +
            break
 +
        }
 +
    }
 +
    return ret
 
}
 
}
  
function get_cward_bb_no (iNo, iChain) {
+
function select_add_sc(fromIdx) {
     while ((iNo < gMaxNo) and (
+
     var iNo = {atomIndex=fromIdx}.atomno
        ({(atomno=iNo) and (chain=iChain)}.atomName != "N")
+
    var iChain = {atomIndex=fromIdx}.chain
        and ({(atomno=iNo) and (chain=iChain)}.atomName != "C")
+
    select none
         and ({(atomno=iNo) and (chain=iChain)}.atomName != "CA"))) {
+
    while ({(atomno=iNo) and (chain=iChain)
 +
        and thisModel and sidechain}) {
 +
         var a = {(atomno=iNo) and (chain=iChain)and thisModel}
 +
        a.selected = true
 
         iNo++
 
         iNo++
 
     }
 
     }
    return iNo
 
 
}
 
}
  
function get_cward_bb_idx (idx, iChain) {
+
# Resolve collisions on selection
    var no = {atomIndex=idx}.atomno + 1
+
function handle_collisions( targetIdx) {
    no = get_cward_bb_no( no, iChain)
 
    return ((no >= 0) ? ({(atomno=no) and (chain=iChain)}.atomIndex) : -1)
 
}
 
  
function get_sc_set (scIdx, iChain) {
+
     # For all selected atoms
     var scSet = ({})
+
     for (var iNo = {selected}.min.atomno; iNo <= {selected}.max.atomno; iNo++) {
     var idx = get_sc_bb_idx(scIdx, iChain)
+
         var idx = {(atomno=iNo) and (chain=gchain)
    var iNo = {atomIndex=idx}.atomno + 3
+
            and thisModel}.atomIndex
   
+
         if ({atomindex=idx}.selected) {
    for (var i = 1; i < 20; i++) {
 
         idx = {(atomno=@{iNo+i}) and (chain=iChain)}.atomIndex
 
         if (is_bb_idx(idx)) {
 
            break
 
        }
 
        scSet = scSet or {atomIndex=idx}
 
    }
 
    return scSet
 
}
 
  
function get_sc_bb_idx (idx, iChain) {
+
            # Collect local colliders
    var no = {atomIndex=idx}.atomno
+
            var lcAtoms = (within(kCtolerance, false, {atomIndex=idx})
    for (; no > 0; no--) {
+
                and not {atomIndex=idx}
        if ({(atomno=no) and (chain=iChain)}.atomName == "CA") {
+
                and not {gOkCollide}
             break
+
                and not connected({atomIndex=idx}))
        }
+
             if (lcAtoms) {
        else if ({(atomno=no) and (chain=iChain)}.atomName == "C") {
+
                # Ignore kinked BB
            break
+
                try {
        }
+
                    if (is_bb_idx(idx) and (angle(
        else if ({(atomno=no) and (chain=iChain)}.atomName == "N") {
+
                        {atomIndex=@{get_cward_bb_idx(idx, gChain)}}, {atomIndex=idx},
            break
+
                        {atomIndex=@{get_nward_bb_idx(idx, gChain)}}) < 100.0)) {
        }
+
                        continue
        else if ({(atomno=no) and (chain=iChain)}.atomName == "CB") {
+
                    }
            no -= 3
+
                }
            break
+
                catch {
        }
+
                }
    }
 
    return {(atomno=no) and (chain=iChain)}.atomIndex
 
}
 
  
function is_bb_idx(aIdx) {
+
                # For all local colliders
    var ret = FALSE
+
                for (var c = 1; c <= lcAtoms.size; c++ ) {
    switch({atomIndex=aIdx}.atomName) {
+
                    var cidx = lcAtoms[c].atomIndex
    case "N":
 
    case "CA":
 
    case "C":
 
        ret = TRUE
 
        break
 
    }
 
    return ret
 
}
 
  
function is_sc_idx(aIdx) {
+
                    # If it is with water, delete it
 +
                    if (lcAtoms[c].group = "HOH") {
 +
                        delete {atomIndex=cidx}
 +
                    }
  
    var ret = FALSE
+
                    # else if it is with side chain not proline, fix it
    if (not is_bb_idx(aIDx)) {
+
                    else if (is_sc_idx(cidx) and ({atomIndex=cidx}.group != "PRO")) {
 +
                        fix_sc_collision_2(cidx)
 +
                       
 +
                        # If not fixed, exit fail
 +
                        if (not gOk2) {
 +
                            return # early exit (break n jmol bug)
 +
                        }
 +
                    }
  
        ret = TRUE
+
                    # else if it is itself a side chain not proline, fix it
        switch({atomIndex=aIdx}.atomName) {
+
                    else if (is_sc_idx(idx) and ({atomIndex=idx}.group != "PRO")) {
        case "O":
+
                        fix_sc_collision_2(idx)
        case "CB":
 
            ret = FALSE
 
            break
 
        }
 
    }
 
    return ret
 
}
 
  
function add_sc_to_select(CAno, isAdd, addOXT, iChain) {
+
                        # If not fixed, exit fail
    var iNo = CAno+3
+
                        if (not gOk2) {
    while ({(atomno=iNo) and (chain=iChain)}.resno == {(atomno=CAno) and (chain=iChain)}.resno) {
+
                            return # early exit (break n jmol bug)
        {(atomno=iNo) and (chain=iChain)}.selected = isAdd
+
                        }
        if ({(atomno=iNo) and (chain=iChain)}.atomName == "OXT") {
+
                    }
            {(atomno=iNo) and (chain=iChain)}.selected = addOXT
 
        }
 
        iNo++
 
    }
 
}
 
  
function select_add_sc(fromIdx) {
+
                    # Else if it is with O, counter-rotate
    var iNo = {atomIndex=fromIdx}.atomno
+
                    else if (lcAtoms[c].atomName = "O") {
    var iChain = {atomIndex=fromIdx}.chain
+
                        counter_rotate_2(lcAtoms[c].atomIndex,
    select none
+
                            {atomIndex=idx}.xyz, targetIdx, false)
    while ({(atomno=iNo) and (chain=iChain)}.atomName != "N") {
 
        {(atomno=iNo) and (chain=iChain)}.selected = TRUE
 
        iNo++
 
        if (iNo > {chain=iChain}.atomno.max) {
 
            break
 
        }
 
    }
 
}
 
  
# First and last are BB atoms
+
                        # If not fixed, exit fail
# Any side atoms in the range are also selected
+
                        if (not gOk2) {
function select_nward_idx (firstIdx, lastIdx) {
+
                            return # early exit (break n jmol bug)
    var firstno = ((firstIdx < 0) ? {atomIndex=lastIdx}.atomno : {atomIndex=firstIdx}.atomno)
+
                        }
    var lastno = ((lastIdx < 0) ? firstno : {atomIndex=lastIdx}.atomno)
+
                    }
    var iChain = ((firstIdx < 0)
 
        ? {atomIndex=lastIdx}.chain : {atomIndex=firstIdx}.chain)
 
  
    select (atomno <= firstno) and (atomno >= lastno) and (chain = iChain)
+
                    # Else if it is itself O, counter-rotate
 +
                    else if ({atomIndex=idx}.atomName = "O") {
 +
                        counter_rotate_2(idx, lcAtoms[c].xyz, targetIdx, false)
  
    if ({(atomno=firstno) and (chain=gChain)}.atomName == "C") { # if psi
+
                        # If not fixed, exit fail
        add_sc_to_select(firstno-1, TRUE, TRUE, iChain)
+
                        if (not gOk2) {
        {(atomno=@{firstno+1}) and (chain=iChain)}.selected = TRUE # add O
+
                            return # early exit (break n jmol bug)
    }
+
                        }
    if ({(atomno=firstno) and (chain=iChain)}.atomName == "CA") {
+
                    }
        add_sc_to_select(firstno, TRUE, FALSE, iChain)
 
    }
 
    if ({(atomno=lastno) and (chain=iChain)}.atomName == "C") { # if psi
 
        add_sc_to_select(lastno-1, FALSE, FALSE, iChain)
 
    }
 
}
 
  
# First and last are BB atoms
+
                    else {    # Else not fixed, exit fail
# Any side atoms in the range are also selected
+
                        gOk2 = false
function select_cward_idx (firstIdx, lastIdx) {
+
                        return # early exit (break n jmol bug)
    var firstno = ((firstIdx < 0) ? gMaxNo : {atomIndex=firstIdx}.atomno)
+
                    }
    var lastno = ((lastIdx < 0) ? 1 : {atomIndex=lastIdx}.atomno)
+
                } # endfor
    var iChain = ((firstIdx < 0)
+
            }
        ? {atomIndex=lastIdx}.chain : {atomIndex=firstIdx}.chain)
 
 
 
    # If nWard anchor in range, begin selection with it
 
    if ((gNanchorIdx >= 0) and ({atomIndex=gNanchorIdx}.chain == iChain))  {
 
        var aNo = {atomIndex=gNanchorIdx}.atomno
 
        if (aNo > firstNo) {
 
            firstno = aNo
 
 
         }
 
         }
     }
+
     } # endfor iNo
 +
}
  
    # If cWard anchor in range, end selection with it
+
# Rotate rotor set to move target atom to its proper place
    if ((gCanchorIdx >= 0) and ({atomIndex=gCanchorIdx}.chain == iChain))  {
+
function tug_track_idx(targetIdx, targetPt, nWard, cDetect) {
        var aNo = {atomIndex=gCanchorIdx}.atomno
+
    gOK = false
        if (aNo < lastNo) {
+
    var pt = targetPt
            lastno = aNo
+
    var dist = distance(pt, {atomIndex=targetIdx}.xyz)
        }
 
    }
 
  
     select (atomno >= firstno) and (atomno <= lastno) and (chain = iChain)
+
     var rotors = (nWard ? gNrotors : gCrotors)
  
     if ({(atomno=firstno) and (chain=iChain)}.atomName == "C") { # if psi
+
     # For a number of passes
         add_sc_to_select(firstno-1, FALSE, FALSE, iChain)
+
    for (var pass1 = 0; pass1 < 20; pass1++) {
    }
+
         var blocked = ({})
    if ({(atomno=lastno) and (chain=iChain)}.atomName == "CA") {
+
         for (var pass2 = 0; pass2 < (rotors.size/4); pass2++) {
         add_sc_to_select(lastno, TRUE, FALSE, iChain)
 
    }
 
    if ({(atomno=lastno) and (chain=iChain)}.atomName == "C") { # if psi
 
        add_sc_to_select(lastno-1, TRUE, TRUE, iChain)
 
        {(atomno=@{lastno+1}) and (chain=iChain)}.selected = TRUE # add O
 
    }
 
}
 
  
 +
            var v1 = {atomIndex=targetIdx}.xyz - pt
  
# Resolve collisions
+
            # Find the most orthgonal unused rotor
function handle_collisions_2( targetIdx) {
+
            var imax = 0
 
+
            var smax = 0.5
    # For all selected atoms
+
            for (var i = 1; i < rotors.size; i += 4) {
    for (var iNo = {selected}.min.atomno; iNo <= {selected}.max.atomno; iNo++) {
+
                var i2 = rotors[i+1]
        var idx = {(atomno=iNo) and (chain=gchain)}.atomIndex
+
                var i3 = rotors[i+2]
        if ({atomindex=idx}.selected) {
+
                var i4 = rotors[i+3]
 +
                if ((i2 != targetIdx) and (i3 != targetIdx) and (i4 != targetIdx)) {
 +
                    if ({blocked and {atomIndex=i2}}.count == 0) {
 +
                        var v2 = {atomIndex=i3}.xyz - {atomIndex=i2}.xyz
  
            # Collect local colliders
+
                        var s = sin(abs(angle(v1, {0 0 0}, v2)))
            var lcAtoms = (within(kCtolerance, FALSE, {atomIndex=idx})
+
                        if (s > smax) {
                and not {atomIndex=idx}
+
                            smax = s
                and not {gOkCollide}
+
                            imax = i
                and not connected({atomIndex=idx}))
+
                        }
            if (lcAtoms.size > 0) {
+
                     }
 
 
                # Ignore kinked BB
 
                if (is_bb_idx(idx) and angle({atomIndex=@{get_cward_bb_idx(idx, gChain)}},
 
                     {atomIndex=idx} , {atomIndex=@{get_nward_bb_idx(idx, gChain)}}) < 100) {
 
                    continue
 
 
                 }
 
                 }
 +
            }
  
                # For all local colliders
+
            # If no more rotors, break to next full try
                for (var c = 1; c <= lcAtoms.size; c++ ) {
+
            if (imax == 0) {
                    var cidx = lcAtoms[c].atomIndex
+
              break
 +
            }
 +
            var i1 = rotors[imax+0]
 +
            var i2 = rotors[imax+1]
 +
            var i3 = rotors[imax+2]
 +
            var i4 = rotors[imax+3]
  
                    # If it is with water, delete it
+
            # Get dihedral of rotor with target point
                    if (lcAtoms[c].group = "HOH") {
+
            var dt = angle({atomIndex=targetIdx}, {atomIndex=i2}, {atomIndex=i3}, pt)
                        delete {atomIndex=cidx}
+
            var dh = angle({atomIndex=i1}, {atomIndex=i2}, {atomIndex=i3}, {atomIndex=i4})
                    }
+
            if (abs(dh).type == "string") {
 +
                dh = -50
 +
            }
 +
            var psi = dh + dt
 +
            var phi = dh + dt
  
                    # else if it is with side chain not proline, fix it
+
            # Compute resultant psi and phi
                    else if (is_sc_idx(cidx) and ({atomIndex=cidx}.group != "PRO")) {
+
            # and select from target atom to first half of rotor
                        fix_sc_collision_2(cidx)
+
            var movePt = false
                         recollect = TRUE
+
            if (nWard) {
 
+
                if ({atomIndex=i2}.atomName="CA") {
                        # If not fixed, exit fail
+
                    psi = angle({atomIndex=@{get_cward_bb_idx(i1, gChain)}}, {atomIndex=i1},
                         if (not gOk2) {
+
                         {atomIndex=i2}, {atomIndex=i3}) + dt
                            return # early exit (break n jmol bug)
+
                }
                        }
+
                else {
                    }
+
                    phi = angle({atomIndex=i1}, {atomIndex=i2},
 +
                         {atomIndex=i3}, {atomIndex=@{get_nward_bb_idx(i3, gChain)}}) + dt
 +
                }
  
                     # else if it is itself a side chain not proline, fix it
+
                if ({atomIndex=i2}.atomno > {atomIndex=targetIdx}.atomno) {
                    else if (is_sc_idx(idx) and ({atomIndex=idx}.group != "PRO")) {
+
                    movePt = true
                        fix_sc_collision_2(idx)
+
                    select_nward_idx(i3, get_cward_bb_idx(targetIdx, gChain))
                         recollect = TRUE
+
                     {atomIndex=targetIdx}.selected = true
 
+
                }
                        # If not fixed, exit fail
+
                else {
                         if (not gOk2) {
+
                    select_cward_idx(i2, targetIdx)
                            return # early exit (break n jmol bug)
+
                }
                        }
+
            }
                    }
+
            else {
 +
                if (({atomIndex=i2}.atomName="CA")) {
 +
                    phi = angle({atomIndex=@{get_nward_bb_idx(i1, gChain)}}, {atomIndex=i1},
 +
                         {atomIndex=i2}, {atomIndex=i3}) + dt
 +
                }
 +
                else {
 +
                    psi = angle({atomIndex=i2}, {atomIndex=i3},
 +
                         {atomIndex=i4}, {atomIndex=@{get_cward_bb_idx(i4, gChain)}}) + dt
 +
                }
  
                    # Else if it is with O, counter-rotate
+
                if ({atomIndex=i2}.atomno < {atomIndex=targetIdx}.atomno) {
                    else if (lcAtoms[c].atomName = "O") {
+
                    movePt = true
                        counter_rotate_2(lcAtoms[c].atomIndex,
+
                    select_cward_idx(i3, get_nward_bb_idx(targetIdx, gChain))
                            {atomIndex=idx}.xyz, targetIdx, FALSE)
+
                    {atomIndex=targetIdx}.selected = true
 +
                }
 +
                else {
 +
                    select_nward_idx(i2, targetIdx)
 +
                }
 +
            }
  
                        # If not fixed, exit fail
+
            # Relax rules if desperate
                        if (not gOk2) {
+
            if (pass1 > 10) {
                            return # early exit (break n jmol bug)
+
                phi = -50
                        }
+
            }
                    }
 
  
                    # Else if it is itself O, counter-rotate
+
            # If rotation within ramachandran limits
                    else if ({atomIndex=idx}.atomName = "O") {
+
            if ((abs(dt) >= 0.1) and
                        counter_rotate_2(idx, lcAtoms[c].xyz, targetIdx, FALSE)
+
                (({atomIndex=i2}.group=="GLY") or (phi < 0))) {
 +
 
 +
                # If moving target point, put the target atom there
 +
                var cp = {atomIndex=targetIdx}.xyz
 +
                if (movePt) {
 +
                    dt = -dt
 +
                    {atomIndex=targetIdx}.xyz = pt
 +
                }
 +
 
 +
                # Rotate to minimize vector ====================
 +
                rotateSelected {atomIndex=i2} {atomIndex=i3} @dt
 +
 
 +
                # If collision checking
 +
                if (cDetect) {
  
                        # If not fixed, exit fail
+
                    # If collision, back off by eighths
 +
                    var wasCollision = false
 +
                    for (var ci = 0; ci < 4; ci++) {
 +
                        if (ci < 3) {
 +
                            dt /= 2
 +
                        }
 +
                        handle_collisions( targetIdx)
 
                         if (not gOk2) {
 
                         if (not gOk2) {
                             return # early exit (break n jmol bug)
+
                             wasCollision = true
 +
                            rotateSelected {atomIndex=i2} {atomIndex=i3} @{-dt}
 +
                        }
 +
                        else if (wasCollision) {
 +
                            if (ci <3) {
 +
                                rotateSelected {atomIndex=i2} {atomIndex=i3} @{dt}
 +
                            }
 +
                        }
 +
                        else {
 +
                            break
 
                         }
 
                         }
                    }
 
 
                    else {    # Else not fixed, exit fail
 
                        gOk2 = FALSE
 
                        return # early exit (break n jmol bug)
 
                    }
 
                } # endfor
 
            }
 
        }
 
    } # endfor iNo
 
}
 
  
# Rotate rotor set to move target atom to its proper place
+
                        if (dt < 0.01) {
function tug_track_idx(targetIdx, targetPt, nWard, cDetect) {
+
                            break
    gOK = FALSE
+
                        }
    var pt = targetPt
+
                    } # endfor
    var dist = distance(pt, {atomIndex=targetIdx}.xyz)
+
                }
  
    var rotors = (nWard ? gNrotors : gCrotors)
+
                # If moving target point, put the target atom back
 +
                if (movePt) {
 +
                    pt = {atomIndex=targetIdx}.xyz
 +
                    {atomIndex=targetIdx}.xyz = cp
 +
                }
 +
 
 +
            }
  
    # For a number of passes
+
            # If close enough, stop
    for (var pass1 = 0; pass1 < 20; pass1++) {
+
            if (distance(pt, {atomIndex=targetIdx}) < kDtolerance) {
        var blocked = ({})
+
                gOK = true
        for (var pass2 = 0; pass2 < (rotors.size/4); pass2++) {
+
                gTargetPt = pt
 +
                break
 +
            }
  
             var v1 = {atomIndex=targetIdx}.xyz - pt
+
             # Block rotor
 +
            blocked |= {atomIndex=i2}
  
            # Find the most orthgonal unused rotor
+
        }  # endfor num rotors passes
            var imax = 0
 
            var smax = 0.5
 
            for (var i = 1; i < rotors.size; i += 4) {
 
                var i2 = rotors[i+1]
 
                var i3 = rotors[i+2]
 
                var i4 = rotors[i+3]
 
                if ((i2 != targetIdx) and (i3 != targetIdx) and (i4 != targetIdx)) {
 
                    if ({blocked and {atomIndex=i2}}.count == 0) {
 
                        var v2 = {atomIndex=i3}.xyz - {atomIndex=i2}.xyz
 
  
                        var s = sin(abs(angle(v1, {0 0 0}, v2)))
+
        if (gOK) {
                        if (s > smax) {
+
            break
                            smax = s
+
        }
                            imax = i
+
    }   # endfor 20 passes
                        }
+
}
                    }
 
                }
 
            }
 
  
            # If no more rotors, break to next full try
+
# Counter rotate bonds on either side of a BB O
            if (imax == 0) {
+
function do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, nWard) {
              break
 
            }
 
            var i1 = rotors[imax+0]
 
            var i2 = rotors[imax+1]
 
            var i3 = rotors[imax+2]
 
            var i4 = rotors[imax+3]
 
  
            # Get dihedral of rotor with target point
+
    # Rotate psi
            var dt = angle({atomIndex=targetIdx}, {atomIndex=i2}, {atomIndex=i3}, pt)
+
    {atomIndex=nIdx}.selected = nWard
            var dh = angle({atomIndex=i1}, {atomIndex=i2}, {atomIndex=i3}, {atomIndex=i4})
+
    {atomIndex=cIdx}.selected = nWard
            if (dh == "NaN") {
+
    {atomIndex=oIdx}.selected = nward
                dh = -50
+
    rotateSelected {atomIndex=caPsiIdx} {atomIndex=cIdx} @{dir}
            }
+
 
            var psi = dh + dt
+
    # Counter-rotate phi
            var phi = dh + dt
+
    {atomIndex=nIdx}.selected = not nWard
 +
    {atomIndex=cIdx}.selected = not nWard
 +
    {atomIndex=oIdx}.selected = not nward
 +
    rotateSelected {atomIndex=nIdx} {atomIndex=caPhiIdx} @{-dir}
 +
}
  
            # Compute resultant psi and phi
+
function counter_rotate(oIdx, dir, nWard) {
            #  and select from target atom to first half of rotor
 
            var movePt = FALSE
 
            if (nWard) {
 
                if ({atomIndex=i2}.atomName="CA") {
 
                    psi = angle({atomIndex=@{get_cward_bb_idx(i1, gChain)}}, {atomIndex=i1},
 
                        {atomIndex=i2}, {atomIndex=i3}) + dt
 
                }
 
                else {
 
                    phi = angle({atomIndex=i1}, {atomIndex=i2},
 
                        {atomIndex=i3}, {atomIndex=@{get_nward_bb_idx(i3, gChain)}}) + dt
 
                }
 
  
                if ({atomIndex=i2}.atomno > {atomIndex=targetIdx}.atomno) {
+
    var iChain = {atomIndex=oIdx}.chain
                    movePt = TRUE
+
    var selsave = {selected}
                    select_nward_idx(i3, get_cward_bb_idx(targetIdx, gChain))
+
    var cIdx = get_sc_bb_idx(oIdx, iChain)
                    {atomIndex=targetIdx}.selected = TRUE
+
    var nIdx = get_cward_bb_idx(cIdx, iChain)
                }
+
    var caPhiIdx = get_cward_bb_idx(nIdx, iChain)
                else {
+
    var caPsiIdx = get_nward_bb_idx(cIdx, iChain)
                    select_cward_idx(i2, targetIdx)
+
 
                }
+
    if (nWard) {
            }
+
        var nNo = {(chain=iChain) and thisModel}.atomno.min
            else {
+
        select_nward_idx(caPsiIdx, {(atomno=nNo) and (chain=iChain)
                if (({atomIndex=i2}.atomName="CA")) {
+
            and thisModel}.atomIndex)
                    phi = angle({atomIndex=@{get_nward_bb_idx(i1, gChain)}}, {atomIndex=i1},
+
    }
                        {atomIndex=i2}, {atomIndex=i3}) + dt
+
    else {
                }
+
        var cNo = {(chain=iChain) and thisModel}.atomno.max
                else {
+
        select_cward_idx(caPhiIdx, {(atomno=cNo) and (chain=iChain)
                    psi = angle({atomIndex=i2}, {atomIndex=i3},
+
            and thisModel}.atomIndex)
                        {atomIndex=i4}, {atomIndex=@{get_cward_bb_idx(i4, gChain)}}) + dt
+
    }
                }
 
  
                if ({atomIndex=i2}.atomno < {atomIndex=targetIdx}.atomno) {
+
    # Counter-rotate
                    movePt = TRUE
+
    do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, not nWard)
                    select_cward_idx(i3, get_nward_bb_idx(targetIdx, gChain))
+
    select selsave
                    {atomIndex=targetIdx}.selected = TRUE
+
}
                }
 
                else {
 
                    select_nward_idx(i2, targetIdx)
 
                }
 
            }
 
  
            # Relax rules if desperate
+
function counter_rotate_2(oIdx, toPt, terminalIdx, oDrag) {
            if (pass1 > 10) {
 
                phi = -50
 
            }
 
  
            # If rotation within ramachandran limits
+
    var iChain = {atomIndex=oIdx}.chain
            if ((abs(dt) >= 0.1) and
+
    var selsave = {selected}
                (({atomIndex=i2}.group=="GLY") or (phi < 0))) {
+
    var gOk2 = true
 +
    var cIdx = get_sc_bb_idx(oIdx, iChain)
 +
    var nIdx = get_cward_bb_idx(cIdx, iChain)
 +
    var caPhiIdx = get_cward_bb_idx(nIdx, iChain)
 +
    var caPsiIdx = get_nward_bb_idx(cIdx, iChain)
  
                # If moving target point, put the target atom there
+
    var nTward = ({atomIndex=oIdx}.atomno < {atomIndex=terminalIdx}.atomno)
                var cp = {atomIndex=targetIdx}.xyz
+
    if (nTward) {
                if (movePt) {
+
        select_cward_idx(cIdx, terminalIdx)
                    dt = -dt
+
    }
                    {atomIndex=targetIdx}.xyz = pt
+
    else {
                }
+
        select_nward_idx(nIdx, terminalIdx)
 +
    }
 +
 
 +
    # Until all collisions cancelled
 +
    var dir = 5
 +
    var ang = angle(toPt, {atomIndex=oIdx}, {atomIndex=cIdx})
 +
    var tcount = 0
 +
    while (oDrag or (within(kCtolerance, false, {atomIndex=oIdx})
 +
            and not {atomIndex=oIdx} and not connected({atomIndex=oIdx})
 +
            and not {gOkCollide} > 0)) {
  
                # Rotate to minimize vector ====================
+
        # Counter-rotate
                rotateSelected {atomIndex=i2} {atomIndex=i3} @dt
+
        do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, nTward)
 +
        var newang = angle(toPt, {atomIndex=oIdx}, {atomIndex=cIdx})
  
                # If collision checking
+
        # If wrong direction once, undo and reverse
                if (cDetect) {
+
        if (newang > ang) {
 +
            do_counter_rotate(caPhiIDx, nIdx, cIdx, oIdx, caPsiIdx, -dir, nTward)
  
                    # If collision, back off by eighths
+
            # If first time, continue in opposite direction
                    var wasCollision = FALSE
+
            dir *= -1
                    for (var ci = 0; ci < 4; ci++) {
+
            if (dir < 0) {
                        if (ci < 3) {
+
                continue
                            dt /= 2
+
            }
                        }
+
        }
                        handle_collisions_2( targetIdx)
 
                        if (not gOk2) {
 
                            wasCollision = TRUE
 
                            rotateSelected {atomIndex=i2} {atomIndex=i3} @{-dt}
 
                        }
 
                        else if (wasCollision) {
 
                            if (ci <3) {
 
                                rotateSelected {atomIndex=i2} {atomIndex=i3} @{dt}
 
                            }
 
                        }
 
                        else {
 
                            break
 
                        }
 
  
                        if (dt < 0.01) {
+
        if (oDrag) {
                            break
+
            break
                        }
+
        }
                    } # endfor
 
                }
 
  
                # If moving target point, put the target atom back
+
        # If no go, undo and exit
                if (movePt) {
+
        tcount++
                    pt = {atomIndex=targetIdx}.xyz
+
        if (tcount > (360/abs(dir))) {
                    {atomIndex=targetIdx}.xyz = cp
+
            gOk2 = false
                }
+
            break
 +
        }
  
            }
+
    } # endwhile
 +
    select selsave
 +
}
  
            # If close enough, stop
+
# Repair proline
            if (distance(pt, {atomIndex=targetIdx}) < kDtolerance) {
+
function repair_proline(BBidx) {
                gOK = TRUE
+
    var cbidx = get_cb_idx(BBidx)
                gTargetPt = pt
+
    var cbno = {atomIndex=cbidx}.atomno
                break
+
    var cgidx = {(atomno=@{cbno+1}) and (chain=gChain)
            }
+
        and thisModel}.atomIndex
 +
    var cdidx = {(atomno=@{cbno+2}) and (chain=gChain)
 +
        and thisModel}.atomIndex
 +
    var caidx = {(atomno=@{cbno-3}) and (chain=gChain)
 +
        and thisModel}.atomIndex
 +
    var nidx = {(atomno=@{cbno-4}) and (chain=gChain)
 +
        and thisModel}.atomIndex
  
            # Block rotor
+
    select {atomIndex=cbidx}
            blocked |= {atomIndex=i2}
+
    set_angle_idx(nidx, caidx, cbidx, 109.5)
  
        }   # endfor num rotors passes
+
    select {atomIndex=cdidx}
 
+
    set_distance_idx(nidx, cdidx, 1.47)
        if (gOK) {
+
    set_angle_idx(caidx, nidx, cdidx, 102.7)
            break
+
    set_dihedral_idx(cbidx, caidx, nidx, cdidx, 16.2)
        }
+
 
     }  # endfor 20 passes
+
    select {atomIndex=cgidx}
 +
    set_distance_idx(cdidx, cgidx, 1.51)
 +
    set_angle_idx(nidx, cdidx, cgidx, 106.4)
 +
     set_dihedral_idx(caidx, nidx, cdidx, cgidx, 16.2)
 
}
 
}
  
# Counter rotate bonds on either side of a BB O
+
# Repair side chain
function do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, nWard) {
+
function repair_sc(targetIdx, nWard) {
  
     # Rotate psi
+
     var idx = (nWard ? get_cward_bb_idx(targetIdx, gChain) : get_nward_bb_idx(targetIdx, gChain))
    {atomIndex=nIdx}.selected = nWard
 
    {atomIndex=cIdx}.selected = nWard
 
    {atomIndex=oIdx}.selected = nward
 
    rotateSelected {atomIndex=caPsiIdx} {atomIndex=cIdx} @{dir}
 
  
     # Counter-rotate phi
+
     if (({atomIndex=targetIdx}.atomName == "CA")
    {atomIndex=nIdx}.selected = not nWard
+
        and ({atomIndex=targetIdx}.group != "GLY")) {
    {atomIndex=cIdx}.selected = not nWard
+
        var cbidx = get_cb_idx(targetIdx)
    {atomIndex=oIdx}.selected = not nward
+
        select none
    rotateSelected {atomIndex=nIdx} {atomIndex=caPhiIdx} @{-dir}
+
        select_add_sc(cbidx)
}
+
        set_angle_idx(idx, targetIdx, cbidx, 110.0)
 +
        set_distance_idx(targetIdx, cbidx, 1.5)
 +
        if ({atomIndex=targetIdx}.group != "PRO") {
 +
            var colliders = (within(kCtolerance, false, {selected})
 +
                and not {atomIndex=targetIdx} and not {selected})
 +
            if (colliders) {
 +
                if ({atomIndex=targetIdx}.group != "ALA") {
 +
                    fix_sc_collision_2(cbidx)
 +
                }
 +
            }
 +
        }
 +
        else {
 +
            if (nWard) {
 +
            }
 +
            else {
 +
                set_dihedral_idx(get_nward_bb_idx(idx, gChain), idx, targetIdx, cbidx, 174.2)
 +
            }
 +
        }
 +
    }
  
function counter_rotate(oIdx, dir, nWard) {
+
    else if ({atomIndex=targetIdx}.atomName == "C") {
 
+
        var oidx = get_o_idx(targetIdx)
    var iChain = {atomIndex=oIdx}.chain
+
        select {atomIndex=oidx}
    var selsave = {selected}
+
        set_angle_idx(idx, targetIdx, oidx, 120.0)
    var cIdx = get_sc_bb_idx(oIdx, iChain)
+
        set_distance_idx(targetIdx, oidx, 1.21)
    var nIdx = get_cward_bb_idx(cIdx, iChain)
+
        if (nWard) {
    var caPhiIdx = get_cward_bb_idx(nIdx, iChain)
+
            set_dihedral_idx(get_cward_bb_idx(idx, gChain), idx, targetIdx, oidx, 0.0)
    var caPsiIdx = get_nward_bb_idx(cIdx, iChain)
+
        }
 
+
        if ({atomIndex=idx}.group == "PRO") {
    if (nWard) {
+
            repair_proline(idx)
        nNo = {chain=iChain}.atomno.min
+
            var dNo = {atomIndex=targetIdx}.atomno + 4
        select_nward_idx(caPsiIdx, {(atomno=nNo) and (chain=iChain)}.atomIndex)
+
            var dIdx = {(atomno=dNO) and (chain=gChain)
    }
+
                and thisModel}.atomIndex
    else {
+
            var colliders = (within(kCtolerance, false, {atomIndex=dIdx})
        cNo = {chain=iChain}.atomno.max
+
                and not connected({atomIndex=dIdx})
        select_cward_idx(caPhiIdx, {(atomno=cNo) and (chain=iChain)}.atomIndex)
+
                and not {atomIndex=dIdx})
 +
            for (var i = 1; i <= colliders.size; i++) {
 +
                if (colliders[i].atomName == "O") {
 +
                    counter_rotate_2(colliders[i].atomIndex,
 +
                        {atomIndex=dIdx}.xyz, targetIdx, false)
 +
                }
 +
            }
 +
        }
 
     }
 
     }
 
    # Counter-rotate
 
    do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, not nWard)
 
    select selsave
 
 
}
 
}
  
function counter_rotate_2(oIdx, toPt, terminalIdx, oDrag) {
+
# Rebuild Cward rotors set
 +
function tug_track_c() {
  
     var iChain = {atomIndex=oIdx}.chain
+
     # For all bb atoms cWard of cargo
    var selsave = {selected}
+
     var targetIdx = gCcargoIdx
    var gOk2 = TRUE
+
     var okCount = 0
    var cIdx = get_sc_bb_idx(oIdx, iChain)
 
    var nIdx = get_cward_bb_idx(cIdx, iChain)
 
     var caPhiIdx = get_cward_bb_idx(nIdx, iChain)
 
     var caPsiIdx = get_nward_bb_idx(cIdx, iChain)
 
  
    var nTward = ({atomIndex=oIdx}.atomno < {atomIndex=terminalIdx}.atomno)
+
     # Allow collisions with cargo
    if (nTward) {
+
     gOkCollide = gCargoSet
        select_cward_idx(cIdx, terminalIdx)
 
    }
 
    else {
 
        select_nward_idx(nIdx, terminalIdx)
 
    }
 
 
 
     # Until all collisions cancelled
 
     var dir = 5
 
    var ang = angle(toPt, {atomIndex=oIdx}, {atomIndex=cIdx})
 
 
     var tcount = 0
 
     var tcount = 0
     while (oDrag or (within(kCtolerance, FALSE, {atomIndex=oIdx})
+
     while (targetIdx != gNanchorIdx) {
            and not {atomIndex=oIdx} and not connected({atomIndex=oIdx})
 
            and not {gOkCollide} > 0)) {
 
  
         # Counter-rotate
+
         # Step to next atom
         do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, nTward)
+
         targetIdx = get_cward_bb_idx(targetIdx, gChain)
        var newang = angle(toPt, {atomIndex=oIdx}, {atomIndex=cIdx})
+
         if (targetIdx < 0) {
 
+
             break
        # If wrong direction once, undo and reverse
 
         if (newang > ang) {
 
            do_counter_rotate(caPhiIDx, nIdx, cIdx, oIdx, caPsiIdx, -dir, nTward)
 
 
 
            # If first time, continue in opposite direction
 
            dir *= -1
 
            if (dir < 0) {
 
                continue
 
             }
 
 
         }
 
         }
  
         if (oDrag) {
+
        # No collision with cargo allowed after two atoms placed
            break
+
         if (tcount == 2) {
 +
          gOkCollide = ({})
 
         }
 
         }
 
        # If no go, undo and exit
 
 
         tcount++
 
         tcount++
        if (tcount > (360/abs(dir))) {
 
            gOk2 = FALSE
 
            break
 
        }
 
  
     } # endwhile
+
        # Compute targets desired coords
     select selsave
+
        try {
}
+
            var c1idx = get_cward_bb_idx(targetIdx, gChain)
 +
            var n1idx = get_nward_bb_idx(targetIdx, gChain )
 +
            var n2idx = get_nward_bb_idx(n1Idx, gChain)
 +
            var n3idx = get_nward_bb_idx(n2Idx, gChain)
 +
            var pt = {0 0 0}
 +
            if ({atomIndex=targetIdx}.atomName == "N") {
 +
                var oidx = get_o_idx(n1idx)
 +
                select {atomIndex=oidx}
 +
      
 +
                # Desired target location is trigonal O
 +
                set_distance_idx(n1idx, oidx, 1.5)
 +
                pt = get_trigonal_idx(n2idx, n1idx, oidx, 1.37)
 +
                set_distance_idx(n1idx, oidx, 1.21)
 +
            }
 +
            else if (({atomIndex=targetIdx}.atomName == "C")
 +
                and ({atomIndex=targetIdx}.group != "GLY")) {
 +
   
 +
                # Desired target location is tetragonal CB
 +
                var cbidx = get_cb_idx(n1idx)
 +
                pt = get_tet_idx(n2idx, n1idx, cbidx, 1.5)
 +
            }
 +
            else { # CA (or GLY C)
 +
   
 +
                # Save current target coords
 +
                var cp = {atomIndex=targetIdx}.xyz
 +
      
 +
                # Set target atom at desired distance and angle
 +
                select {atomIndex=targetIdx}
 +
                set_distance_idx(n1idx, targetIdx, 1.5)
 +
                set_angle_idx(n2idx, n1idx, targetIdx, 120.0)
 +
                if ({atomIndex=targetIdx}.atomName == "CA") {
 +
                    set_dihedral_idx(n3idx, n2idx, n1idx, targetIdx, 180)
 +
                }
 +
   
 +
                # Record and restore target
 +
                pt = {atomIndex=targetIdx}.xyz
 +
                {atomIndex=targetIdx}.xyz = cp
 +
            }
 +
   
 +
            # If target not at desired location
 +
            if (distance(pt, {atomIndex=targetIdx}) > kDtolerance) {
 +
                okCount = 0
 +
                gTargetPt = pt
 +
                var xcount = 0
 +
                gOK = false
 +
                while ((xcount < 20) and (not gOK)) {
 +
   
 +
                    # Rotate on cWard rotor set to move it there
 +
                    tug_track_idx(targetIdx, pt, false, false)
 +
                    xcount++
 +
                }
 +
            }
 +
            else {
 +
                gOK = true
 +
                okCount++
 +
            }
 +
        }
 +
        catch {
 +
        }
  
# Repair proline
+
        # If successful
function repair_proline(BBidx) {
+
        if (gOK == true) {
    var cbidx = get_cb_idx(BBidx)
 
    var cbno = {atomIndex=cbidx}.atomno
 
    var cgidx = {(atomno=@{cbno+1}) and (chain=gChain)}.atomIndex
 
    var cdidx = {(atomno=@{cbno+2}) and (chain=gChain)}.atomIndex
 
    var caidx = {(atomno=@{cbno-3}) and (chain=gChain)}.atomIndex
 
    var nidx = {(atomno=@{cbno-4}) and (chain=gChain)}.atomIndex
 
  
    select {atomIndex=cbidx}
+
            # Adust any side atoms
    set_angle_idx(nidx, caidx, cbidx, 109.5)
+
            repair_sc(targetIdx, false)
 +
        }
  
    select {atomIndex=cdidx}
+
        # Else fail
    set_distance_idx(nidx, cdidx, 1.47)
+
        else {
    set_angle_idx(caidx, nidx, cdidx, 102.7)
+
            break
    set_dihedral_idx(cbidx, caidx, nidx, cdidx, 16.2)
+
        }
  
    select {atomIndex=cgidx}
+
        # If no movement in 4 tries, we are done
    set_distance_idx(cdidx, cgidx, 1.51)
+
        if (okCount > 3) {
    set_angle_idx(nidx, cdidx, cgidx, 106.4)
+
            break
     set_dihedral_idx(caidx, nidx, cdidx, cgidx, 16.2)
+
        }
 +
     } # endwhile (targetIdx != gCanchorIdx) {
 
}
 
}
  
# Repair side chain
+
# Rebuild Nward rotors set
function repair_sc(targetIdx, nWard) {
+
function tug_track_n() {
  
     var idx = (nWard ? get_cward_bb_idx(targetIdx, gChain) : get_nward_bb_idx(targetIdx, gChain))
+
     gOK = true
  
     if (({atomIndex=targetIdx}.atomName == "CA")
+
     # For all bb atoms nWard of cargo
        and ({atomIndex=targetIdx}.group != "GLY")) {
+
    var targetIdx = gNcargoIdx
        var cbidx = get_cb_idx(targetIdx)
+
    var okCount = 0
        select none
+
 
         select_add_sc(cbidx)
+
    # Allow collisions with cargo
         set_angle_idx(idx, targetIdx, cbidx, 110.0)
+
    gOkCollide = gCargoSet
        set_distance_idx(targetIdx, cbidx, 1.5)
+
    var tcount = 0
         if ({atomIndex=targetIdx}.group != "PRO") {
+
    while (targetIdx != gNanchorIdx) {
            var colliders = (within(kCtolerance, FALSE, {selected})
+
 
                and not {atomIndex=targetIdx} and not {selected})
+
         # Step to next atom
            if (colliders.size > 0) {
+
         targetIdx = get_nward_bb_idx(targetIdx, gChain)
                if ({atomIndex=targetIdx}.group != "ALA") {
+
         if (targetIdx < 0) {
                    fix_sc_collision_2(cbidx)
+
             break
                }
 
             }
 
 
         }
 
         }
         else {
+
          
            if (nWard) {
+
        # No collision with cargo allowed after two atoms placed
            }
+
         if (tcount == 2) {
            else {
+
          gOkCollide = ({})
                set_dihedral_idx(get_nward_bb_idx(idx, gChain), idx, targetIdx, cbidx, 174.2)
 
            }
 
         }
 
    }
 
 
 
    else if ({atomIndex=targetIdx}.atomName == "C") {
 
        var oidx = get_o_idx(targetIdx)
 
        select {atomIndex=oidx}
 
        set_angle_idx(idx, targetIdx, oidx, 120.0)
 
        set_distance_idx(targetIdx, oidx, 1.21)
 
        if (nWard) {
 
            set_dihedral_idx(get_cward_bb_idx(idx, gChain), idx, targetIdx, oidx, 0.0)
 
 
         }
 
         }
         if ({atomIndex=idx}.group == "PRO") {
+
         tcount++
            repair_proline(idx)
 
            var dNo = {atomIndex=targetIdx}.atomno + 4
 
            var dIdx = {(atomno=dNO) and (chain=gChain)}.atomIndex
 
            var colliders = (within(kCtolerance, FALSE, {atomIndex=dIdx})
 
                and not connected({atomIndex=dIdx})
 
                and not {atomIndex=dIdx})
 
            for (var i = 1; i <= colliders.size; i++) {
 
                if (colliders[i].atomName == "O") {
 
                    counter_rotate_2(colliders[i].atomIndex,
 
                        {atomIndex=dIdx}.xyz, targetIdx, FALSE)
 
                }
 
            }
 
        }
 
    }
 
}
 
  
# Rebuild Cward rotors set
+
         # Compute targets desired coords
function tug_track_c() {
+
         var n1idx = get_nward_bb_idx(targetIdx, gChain)
 
 
    # For all bb atoms cWard of cargo
 
    var targetIdx = gCcargoIdx
 
    var okCount = 0
 
 
 
    # Allow collisions with cargo
 
    gOkCollide = gCargoSet
 
    var tcount = 0
 
    while (targetIdx != gCanchorIdx) {
 
 
 
         # Step to next atom
 
         targetIdx = get_cward_bb_idx(targetIdx, gChain)
 
 
 
        # No collision with cargo allowed after two atoms placed
 
        if (tcount == 2) {
 
          gOkCollide = ({})
 
        }
 
        tcount++
 
 
 
        # Compute targets desired coords
 
 
         var c1idx = get_cward_bb_idx(targetIdx, gChain)
 
         var c1idx = get_cward_bb_idx(targetIdx, gChain)
         var n1idx = get_nward_bb_idx(targetIdx, gChain )
+
         var c2idx = get_cward_bb_idx(c1idx, gChain)
         var n2idx = get_nward_bb_idx(n1Idx, gChain)
+
         var c3idx = get_cward_bb_idx(c2idx, gChain)
        var n3idx = get_nward_bb_idx(n2Idx, gChain)
 
 
         var pt = {0 0 0}
 
         var pt = {0 0 0}
         if ({atomIndex=targetIdx}.atomName == "N") {
+
         if ({atomIndex=targetIdx}.atomName == "CA") {
            var oidx = get_o_idx(n1idx)
 
            select {atomIndex=oidx}
 
  
 
             # Desired target location is trigonal O
 
             # Desired target location is trigonal O
             set_distance_idx(n1idx, oidx, 1.5)
+
            var oidx = get_o_idx(c1idx)
             pt = get_trigonal_idx(n2idx, n1idx, oidx, 1.37)
+
            select {atomIndex=oidx}
             set_distance_idx(n1idx, oidx, 1.21)
+
             set_distance_idx(c1idx, oidx, 1.39)
         }
+
             pt = get_trigonal_idx(c2idx, c1idx, oidx, 1.41)
         else if (({atomIndex=targetIdx}.atomName == "C")
+
             set_distance_idx(c1idx, oidx, 1.21)
 +
         }
 +
         else if (({atomIndex=targetIdx}.atomName == "N")
 
             and ({atomIndex=targetIdx}.group != "GLY")) {
 
             and ({atomIndex=targetIdx}.group != "GLY")) {
  
             # Desired target location is tetragonal CB
+
             # Desired target location is r-tetragonal CB
             var cbidx = get_cb_idx(n1idx)
+
             var cbidx = get_cb_idx(c1idx)
             pt = get_tet_idx(n2idx, n1idx, cbidx, 1.5)
+
             pt = get_tet_idx(cbidx, c1idx, c2idx, 1.5)
 
         }
 
         }
         else { # CA (or GLY C)
+
         else { # C
  
 
             # Save current target coords
 
             # Save current target coords
Line 806: Line 809:
 
             # Set target atom at desired distance and angle
 
             # Set target atom at desired distance and angle
 
             select {atomIndex=targetIdx}
 
             select {atomIndex=targetIdx}
             set_distance_idx(n1idx, targetIdx, 1.5)
+
             set_distance_idx(c1idx, targetIdx, 1.37)
             set_angle_idx(n2idx, n1idx, targetIdx, 120.0)
+
             set_angle_idx(c2idx, c1idx, targetIdx, 110.0)
             if ({atomIndex=targetIdx}.atomName == "CA") {
+
 
                 set_dihedral_idx(n3idx, n2idx, n1idx, targetIdx, 180)
+
             if ({atomIndex=targetIdx}.group == "PRO") {
 +
                 set_dihedral_idx(c3idx, c2idx, c1idx, targetIdx, -57.0)
 
             }
 
             }
  
Line 819: Line 823:
 
         # If target not at desired location
 
         # If target not at desired location
 
         if (distance(pt, {atomIndex=targetIdx}) > kDtolerance) {
 
         if (distance(pt, {atomIndex=targetIdx}) > kDtolerance) {
             okCount = 0
+
             var okCount = 0
 
             gTargetPt = pt
 
             gTargetPt = pt
 
             var xcount = 0
 
             var xcount = 0
             gOK = FALSE
+
             gOK = false
 
             while ((xcount < 20) and (not gOK)) {
 
             while ((xcount < 20) and (not gOK)) {
  
                 # Rotate on cWard rotor set to move it there
+
                 # Rotate on nWard rotor set to move it there
                 tug_track_idx(targetIdx, pt, FALSE, FALSE)
+
                 tug_track_idx(targetIdx, pt, true, false)
 
                 xcount++
 
                 xcount++
 
             }
 
             }
 
         }
 
         }
 
         else {
 
         else {
             gOK = TRUE
+
             gOK = true
 
             okCount++
 
             okCount++
 
         }
 
         }
  
         # If successful
+
         # If sucessful
         if (gOK == TRUE) {
+
         if (gOK == true) {
  
 
             # Adust any side atoms
 
             # Adust any side atoms
             repair_sc(targetIdx, FALSE)
+
             repair_sc(targetIdx, true)
 
         }
 
         }
  
Line 851: Line 855:
 
             break
 
             break
 
         }
 
         }
     } # endwhile (targetIdx != gCanchorIdx) {
+
 
 +
     }   # endwhile (targetIdx != gNanchorIdx) {
 
}
 
}
  
# Rebuild Nward rotors set
+
# gPlicoRecord is maintained by the macro pilcoRecord
function tug_track_n() {
+
function translate_selected_record(pt) {
 
+
    if (gPlicoRecord != "") {
     gOK = TRUE
+
        plico_record(format("select %s;translateSelected %s;", {selected}, pt))
 +
     }
 +
    translateSelected @pt
 +
}
  
    # For all bb atoms nWard of cargo
+
# gPlicoRecord is maintained by the macro pilcoRecord
     var targetIdx = gNcargoIdx
+
function rotate_selected_record(pivotIdx, caxis, a) {
     var okCount = 0
+
     if (gPlicoRecord != "") {
 +
        plico_record(format("select %s;", {selected}))
 +
        plico_record(format("rotateSelected {atomIndex=%d} @%s @%s;",
 +
            pivotIdx, caxis, a))
 +
    }
 +
     rotateSelected {atomIndex=pivotIdx} @caxis @a
 +
}
  
     # Allow collisions with cargo
+
function collect_sc_rotors(no, iChain) {
     gOkCollide = gCargoSet
+
     var scBondIdxs = array()
    var tcount = 0
+
     for (var iNo = no; iNo >= 0; iNo--) {
    while (targetIdx != gNanchorIdx) {
+
        var ile = 0
 
+
        switch ({(atomno=iNo) and (chain=iChain)
         # Step to next atom
+
            and thisModel}.atomName) {
         targetIdx = get_nward_bb_idx(targetIdx, gChain)
+
        case "CA" :
 +
            return scBondIdxs # Early exit since break 1 appears broken
 +
        case "CZ" :
 +
            if ({(atomno=iNo) and (chain=iChain)
 +
                and thisModel}.group == "TYR") {
 +
                break
 +
            }
 +
        case "CE" :
 +
            if ({(atomno=iNo) and (chain=iChain)
 +
                and thisModel}.group == "MET") {
 +
                break
 +
            }
 +
        case "CG1" :
 +
            if ({(atomno=iNo) and (chain=iChain)
 +
                and thisModel}.group == "VAL") {
 +
                break
 +
            }
 +
            if ({(atomno=iNo) and (chain=iChain)
 +
                and thisModel}.group == "ILE") {
 +
                ile = 1
 +
            }
 +
         case "NE" :
 +
        case "CD" :
 +
        case "SD" :
 +
        case "CG" :
 +
         case "CB" :
 +
            scBondIdxs += {(atomno=@{iNo+1+ile}) and (chain=iChain)
 +
                and thisModel}.atomIndex
 +
            scBondIdxs += {(atomno=@{iNo+0}) and (chain=iChain)
 +
                and thisModel}.atomIndex
 +
            if ({(atomno=iNo) and (chain=iChain)
 +
                and thisModel}.atomName%2 == "CG") {
 +
                scBondIdxs += {(atomno=@{iNo-1}) and (chain=iChain)
 +
                    and thisModel}.atomIndex
 +
                scBondIdxs += {(atomno=@{iNo-4}) and (chain=iChain)
 +
                    and thisModel}.atomIndex
 +
            }
 +
            else if ({(atomno=iNo) and (chain=iChain)
 +
                and thisModel}.atomName == "CB") {
 +
                scBondIdxs += {(atomno=@{iNo-3}) and (chain=iChain)
 +
                    and thisModel}.atomIndex
 +
                scBondIdxs += {(atomno=@{iNo-4}) and (chain=iChain)
 +
                    and thisModel}.atomIndex
 +
            }
 +
            else {
 +
                scBondIdxs += {(atomno=@{iNo-1}) and (chain=iChain)
 +
                    and thisModel}.atomIndex
 +
                scBondIdxs += {(atomno=@{iNo-2}) and (chain=iChain)
 +
                    and thisModel}.atomIndex
 +
            }
 +
            break
 +
        }
  
        # No collision with cargo allowed after two atoms placed
+
    }
        if (tcount == 2) {
 
          gOkCollide = ({})
 
        }
 
        tcount++
 
  
        # Compute targets desired coords
+
    return scBondIdxs
        var n1idx = get_nward_bb_idx(targetIdx, gChain)
+
}
        var c1idx = get_cward_bb_idx(targetIdx, gChain)
+
 
        var c2idx = get_cward_bb_idx(c1idx, gChain)
+
# Drag Side Chain
        var c3idx = get_cward_bb_idx(c2idx, gChain)
+
function drag_sc() {
        var pt = {0 0 0}
+
    var iNo = {atomIndex=gSCidx}.atomno
        if ({atomIndex=targetIdx}.atomName == "CA") {
+
    var iChain  = {atomIndex=gSCidx}.chain
 +
    if ({atomIndex=gSCidx}.group != "PRO") {
  
            # Desired target location is trigonal O
+
        var scBondIdxs = collect_sc_rotors( iNo, iChain)
            var oidx = get_o_idx(c1idx)
+
        var numChi = scBondIdxs.size / 4
            select {atomIndex=oidx}
+
         var dist = distance({atomIndex=gSCidx}.xyz, gSCpt)
            set_distance_idx(c1idx, oidx, 1.39)
+
        var scSet = get_sc_set(gSCidx, iChain)
            pt = get_trigonal_idx(c2idx, c1idx, oidx, 1.41)
 
            set_distance_idx(c1idx, oidx, 1.21)
 
         }
 
        else if (({atomIndex=targetIdx}.atomName == "N")
 
            and ({atomIndex=targetIdx}.group != "GLY")) {
 
  
            # Desired target location is r-tetragonal CB
+
        # For all rotor combinations
            var cbidx = get_cb_idx(c1idx)
+
        var dh = array()
             pt = get_tet_idx(cbidx, c1idx, c2idx, 1.5)
+
        for (var i = 0; i < numChi; i++) {
 +
             dh += angle({atomIndex=@{scBondIdxs[4+(4*i)]}},
 +
                {atomIndex=@{scBondIdxs[3+(4*i)]}},
 +
                {atomIndex=@{scBondIdxs[2+(4*i)]}},
 +
                {atomIndex=@{scBondIdxs[1+(4*i)]}})
 
         }
 
         }
         else { # C
+
         for (var i = 0; i < numChi; i++) {
 +
            var rot = -120
 +
            for (var j = 0; j < 6; j++) {
 +
                rot += 60*j
 +
                select_add_sc(scBondIdxs[1+(4*i)])
 +
                set_dihedral_idx(scBondIdxs[4+(4*i)], scBondIdxs[3+(4*i)],
 +
                    scBondIdxs[2+(4*i)], scBondIdxs[1+(4*i)], rot)
 +
                var newDist = distance({atomIndex=gSCidx}.xyz, gSCpt)
 +
                if (gSCcheck) {
 +
                    var colliders = (within(kCtolerance, false, scSet)
 +
                        and not connected(scSet) and not {scSet})
 +
                    if (colliders) {
 +
                        continue
 +
                    }
 +
                }
  
            # Save current target coords
+
                # Find the best
            var cp = {atomIndex=targetIdx}.xyz
+
                if (newDist < dist) {
 
+
                    dist = newDist
            # Set target atom at desired distance and angle
+
                    for (var k = 0; k < numChi; k++) {
            select {atomIndex=targetIdx}
+
                        dh[k+1] = angle({atomIndex=@{scBondIdxs[4+(4*k)]}},
            set_distance_idx(c1idx, targetIdx, 1.37)
+
                        {atomIndex=@{scBondIdxs[3+(4*k)]}},
            set_angle_idx(c2idx, c1idx, targetIdx, 110.0)
+
                        {atomIndex=@{scBondIdxs[2+(4*k)]}},
 
+
                        {atomIndex=@{scBondIdxs[1+(4*k)]}})
            if ({atomIndex=targetIdx}.group == "PRO") {
+
                    }
                 set_dihedral_idx(c3idx, c2idx, c1idx, targetIdx, -57.0)
+
                 }
 
             }
 
             }
 +
        }
  
            # Record and restore target
+
        # Now set the best
            pt = {atomIndex=targetIdx}.xyz
+
        for (var i = 0; i < numChi; i++) {
             {atomIndex=targetIdx}.xyz = cp
+
             select_add_sc(scBondIdxs[1+(4*i)])
 +
            set_dihedral_idx(scBondIdxs[4+(4*i)], scBondIdxs[3+(4*i)],
 +
                scBondIdxs[2+(4*i)], scBondIdxs[1+(4*i)], dh[i+1])
 +
        }
 +
       
 +
        if (gSCcheck = false) {
 +
            plico_minimize( scSet)
 
         }
 
         }
 +
    }
 +
    else { # PRO - toggle between puckers up and down
 +
        var icd = {(atomno=@{iNo+1}) and (chain=iChain)
 +
            and thisModel}.atomIndex
 +
        var icb = {(atomno=@{iNo-1}) and (chain=iChain)
 +
            and thisModel}.atomIndex
 +
        var ica = {(atomno=@{iNo-4}) and (chain=iChain)
 +
            and thisModel}.atomIndex
 +
        var in = {(atomno=@{iNo-5}) and (chain=iChain)
 +
            and thisModel}.atomIndex
 +
        select {atomIndex=gSCidx}
  
        # If target not at desired location
+
         if (angle({atomIndex=ica}, {atomIndex=in},
         if (distance(pt, {atomIndex=targetIdx}) > kDtolerance) {
+
             {atomIndex=icd}, {atomIndex=gSCidx}) < -10.0) {
            var okCount = 0
+
             set_dihedral_idx(ica, in, icd, gSCidx, 8.7)
             gTargetPt = pt
+
            set_angle_idx(in, icd, gSCidx, 110.0)
            var xcount = 0
+
             set_distance_idx(icd, gSCidx, 1.5)
             gOK = FALSE
 
            while ((xcount < 20) and (not gOK)) {
 
 
 
                # Rotate on nWard rotor set to move it there
 
                tug_track_idx(targetIdx, pt, TRUE, FALSE)
 
                xcount++
 
             }
 
 
         }
 
         }
 
         else {
 
         else {
             gOK = TRUE
+
             set_dihedral_idx(ica, in, icd, gSCidx, -29.5)
             okCount++
+
             set_angle_idx(in, icd, gSCidx, 108.8)
 +
            set_distance_idx(icd, gSCidx, 1.5)
 
         }
 
         }
 +
    }
  
        # If sucessful
+
    draw gSCcircle CIRCLE {atomIndex=gSCidx} MESH NOFILL
        if (gOK == TRUE) {
+
    gSCpt = {atomIndex=gSCidx}.xyz
 +
}
  
            # Adust any side atoms
+
# Fix side chain collisions
            repair_sc(targetIdx, TRUE)
+
function fix_sc_collision_2(idx) {
         }
+
    gOk2 = false
 +
    var iNo = {atomIndex=idx}.atomno
 +
    var iChain = {atomIndex=idx}.chain
 +
    var resno = {(atomno=iNo) and (chain=iChain)
 +
         and thisModel}.resno
  
        # Else fail
+
    # Get SC terminus
        else {
+
     while (resno == {(atomno=iNo) and (chain=iChain)
            break
+
        and thisModel}.resno) {
        }
+
         iNo++
 
 
        # If no movement in 4 tries, we are done
 
        if (okCount > 3) {
 
            break
 
        }
 
 
 
     }  # endwhile (targetIdx != gNanchorIdx) {
 
}
 
 
 
# gPlicoRecord is maintained by the macro pilcoRecord
 
function plico_record(s) {
 
    var g = format("show file \"%s\"", gPlicoRecord)
 
    var ls = script(g)
 
    if (ls.find("FileNotFoundException")) {
 
         ls = ""
 
 
     }
 
     }
     ls += s
+
     iNo--
    write var ls @gPlicoRecord
 
}
 
  
# gPlicoRecord is maintained by the macro pilcoRecord
+
    var sc = array()
function translate_selected_record(pt) {
+
     var iBno = iNo
     if (gPlicoRecord != "") {
+
    while ({(atomno=iBno) and (chain=iChain)
         plico_record(format("select %s;translateSelected %s;", {selected}, pt))
+
        and thisModel}.atomName != "CB") {
 +
         sc += {(atomno=iBno) and (chain=iChain)
 +
            and thisModel}
 +
        iBno--
 
     }
 
     }
     translateSelected @pt
+
     var cbidx = {(atomno=iBno) and (chain=iChain)
}
+
        and thisModel}.atomIndex
  
# gPlicoRecord is maintained by the macro pilcoRecord
+
    var scBondIdxs = collect_sc_rotors( iNo, iChain)
function rotate_selected_record(pivotIdx, axis, a) {
+
     var numChi = scBondIdxs.size / 4
     if (gPlicoRecord != "") {
+
 
         plico_record(format("select %s;", {selected}))
+
    # For all rotor combinations
        plico_record(format("rotateSelected {atomIndex=%d} @%s @%s;",
+
    for (var i = 0; i < numChi; i++) {
            pivotIdx, axis, a))
+
         var rot = -120
    }
+
        for (var j = 0; j < 6; j++) {
    rotateSelected {atomIndex=pivotIdx} @axis @a
+
            rot += 60
}
+
            select_add_sc(scBondIdxs[1+(4*i)])
 +
            set_dihedral_idx(scBondIdxs[1+(4*i)], scBondIdxs[2+(4*i)],
 +
                scBondIdxs[3+(4*i)], scBondIdxs[4+(4*i)], rot)
  
function collect_sc_rotors(no, iChain) {
+
            # If no collision, exit
    var scBondIdxs = array()
+
            var colliders = (within(kCtolerance, false, {sc})
    for (var iNo = no; iNo >= 0; iNo--) {
+
                and not {atomIndex=cbidx} and not {sc})
        var ile = 0
+
 
        switch ({(atomno=iNo) and (chain=iChain)}.atomName) {
+
             # If it is with water, delete the water
        case "CA" :
+
             for (var c = 1; c < colliders.size; c++ ) {
             return scBondIdxs # Early exit since break 1 appears broken
+
                if (colliders[c].group = "HOH") {
        case "CZ" :
+
                    delete {atomIndex=@{colliders[c].atomIndex}}
             if ({(atomno=iNo) and (chain=iChain)}.group == "TYR") {
+
                    colliders = {colliders and not @{colliders[c]}}
                break
+
                 }
            }
 
        case "CE" :
 
            if ({(atomno=iNo) and (chain=iChain)}.group == "MET") {
 
                 break
 
 
             }
 
             }
        case "CG1" :
+
 
             if ({(atomno=iNo) and (chain=iChain)}.group == "VAL") {
+
             if (colliders.size == 0) {
                 break
+
                 gOk2 = true
 +
                return # Early exit since break 1 appears broken
 
             }
 
             }
            if ({(atomno=iNo) and (chain=iChain)}.group == "ILE") {
+
 
                ile = 1
 
            }
 
        case "NE" :
 
        case "CD" :
 
        case "SD" :
 
        case "CG" :
 
        case "CB" :
 
            scBondIdxs += {(atomno=@{iNo+1+ile}) and (chain=iChain)}.atomIndex
 
            scBondIdxs += {(atomno=@{iNo+0}) and (chain=iChain)}.atomIndex
 
            if ({(atomno=iNo) and (chain=iChain)}.atomName%2 == "CG") {
 
                scBondIdxs += {(atomno=@{iNo-1}) and (chain=iChain)}.atomIndex
 
                scBondIdxs += {(atomno=@{iNo-4}) and (chain=iChain)}.atomIndex
 
            }
 
            else if ({(atomno=iNo) and (chain=iChain)}.atomName == "CB") {
 
                scBondIdxs += {(atomno=@{iNo-3}) and (chain=iChain)}.atomIndex
 
                scBondIdxs += {(atomno=@{iNo-4}) and (chain=iChain)}.atomIndex
 
            }
 
            else {
 
                scBondIdxs += {(atomno=@{iNo-1}) and (chain=iChain)}.atomIndex
 
                scBondIdxs += {(atomno=@{iNo-2}) and (chain=iChain)}.atomIndex
 
            }
 
            break
 
 
         }
 
         }
 
 
     }
 
     }
 
    return scBondIdxs
 
 
}
 
}
  
# Drag Side Chain
+
function is_moveable_sc(aIdx) {
function drag_sc() {
 
  
     var iNo = {atomIndex=gSCidx}.atomno
+
     var ret = (({atomIndex=aIdx}.group != "PRO")
     var iChain  = {atomIndex=gSCidx}.chain
+
        or ({atomIndex=aIdx}.atomName == "CG"))
 +
     switch({atomIndex=aIdx}.atomName) {
 +
    case "N":
 +
    case "CA":
 +
    case "C":
 +
    case "CB":
 +
    case "O":
 +
    case "O4\'":
 +
        ret = false
 +
        break
 +
    }
 +
    return ret
 +
}
  
     if ({atomIndex=gSCidx}.group != "PRO") {
+
function is_rotor_avail(i1idx, i2idx) {
 +
    var ret = true
 +
     if (i1idx > i2idx) { # frozen bonds are kept as lo-hi
 +
        var idx = @i1idx
 +
        i1idx = @i2idx
 +
        i2idx = @idx
 +
    }
  
         var scBondIdxs = collect_sc_rotors( iNo, iChain)
+
    for (var i = 1; i <= gFreeze.size; i += 2) {
         var numChi = scBondIdxs.size / 4
+
         if ((gFreeze[i] == i1idx) and (gFreeze[i+1] == i2idx)) {
         var dist = distance({atomIndex=gSCidx}.xyz, gSCpt)
+
            ret = false
 +
            break
 +
         }
 +
    }
 +
 
 +
    return ret
 +
}
 +
 
 +
function xcollect_bb_rotors(nWard) {
 +
    var anchorNo = (nWard
 +
        ? ((gNanchorIdx >= 0) ? {atomIndex=gNanchorIdx}.atomno : gMinNo)
 +
         : ((gCanchorIdx >= 0) ? {atomIndex=gCanchorIdx}.atomno : gMaxNo))
 +
    var cargoNo = (nWard
 +
        ? ((gNcargoIdx >= 0) ? {atomIndex=gNcargoIdx}.atomno
 +
        : {atomIndex=gCcargoIdx}.atomno)
 +
        : {atomIndex=gCcargoIdx}.atomno)
 +
    var rotors = array()
 +
    if (cargoNo < anchorNo) {
  
         var scSet = ({})
+
         for (var iNo = cargoNo; iNo <= anchorNo; iNo++) {
        if (gSCcheck) {
+
            if ({(atomno=iNo) and (chain=gChain)
            scSet = get_sc_set(gSCidx, iChain)
+
                and thisModel}.atomName == "CA") {
 +
                if (is_rotor_avail(iNo)) {# xxx
 +
                    if (({(atomno=iNo) and (chain=gChain)
 +
                        and thisModel}.group != "PRO") and (iNo > cargoNo)) { # phi
 +
                        rotors += [{(atomno=@{get_cm_no(iNo-1)}) and (chain=gChain)
 +
                            and thisModel}.atomIndex,
 +
                            {(atomno=@{iNo-1}) and (chain=gChain)
 +
                                and thisModel}.atomIndex]
 +
                        rotors += [{(atomno=@{iNo}) and (chain=gChain)
 +
                            and thisModel}.atomIndex,
 +
                            {(atomno=@{iNo+1}) and (chain=gChain)
 +
                                and thisModel}.atomIndex]
 +
                    }
 +
                    if (iNo != (anchorNo-1)) { # psi
 +
                        rotors += [{(atomno=@{iNo-1}) and (chain=gChain)
 +
                            and thisModel}.atomIndex,
 +
                            {(atomno=@{iNo}) and (chain=gChain)
 +
                                and thisModel}.atomIndex]
 +
                        rotors += [{(atomno=@{iNo+1}) and (chain=gChain)
 +
                            and thisModel}.atomIndex,
 +
                            {(atomno=@{get_np_no(iNo+2)}) and (chain=gChain)
 +
                                and thisModel}.atomIndex]
 +
                    }
 +
                }
 +
            }
 
         }
 
         }
       
+
    }
        # For all rotor combinations
+
    else {
         var dh = array()
+
 
        for (var i = 0; i < numChi; i++) {
+
         for (var iNo = cargoNo; iNo >= anchorNo; iNo--) {
            dh += angle({atomIndex=@{scBondIdxs[4+(4*i)]}},
+
            if ({(atomno=iNo) and (chain=gChain)
                {atomIndex=@{scBondIdxs[3+(4*i)]}},
+
                and thisModel}.atomName == "CA") {
                {atomIndex=@{scBondIdxs[2+(4*i)]}},
+
                if (is_rotor_avail(iNo)) {
                {atomIndex=@{scBondIdxs[1+(4*i)]}})
+
                    if ((iNo != (anchorNo-1)) and (iNo < cargoNo)) { # psi
        }
+
                        rotors += [{(atomno=@{get_np_no(iNo+2)}) and (chain=gChain)
        for (var i = 0; i < numChi; i++) {
+
                            and thisModel}.atomIndex,
            var rot = -120
+
                            {(atomno=@{iNo+1}) and (chain=gChain)
            for (var j = 0; j < 6; j++) {
+
                                and thisModel}.atomIndex]
                rot += 60*j
+
                        rotors += [{(atomno=@{iNo}) and (chain=gChain)
                select_add_sc(scBondIdxs[1+(4*i)])
+
                            and thisModel}.atomIndex,
                set_dihedral_idx(scBondIdxs[4+(4*i)], scBondIdxs[3+(4*i)],
+
                            {(atomno=@{iNo-1}) and (chain=gChain)
                    scBondIdxs[2+(4*i)], scBondIdxs[1+(4*i)], rot)
+
                                and thisModel}.atomIndex]
                var newDist = distance({atomIndex=gSCidx}.xyz, gSCpt)
+
                    }
                if (gSCcheck) {
+
                    if ({(atomno=iNo) and (chain=gChain)
                    var colliders = (within(kCtolerance, FALSE, scSet)
+
                        and thisModel}.group != "PRO") { # phi
                        and not connected(scSet) and not {scSet})
+
                        rotors += [{(atomno=@{iNo+1}) and (chain=gChain)
                    if (colliders.size > 0) {
+
                            and thisModel}.atomIndex,
                        continue
+
                            {(atomno=@{iNo}) and (chain=gChain)
 +
                                and thisModel}.atomIndex]
 +
                        rotors += [{(atomno=@{iNo-1}) and (chain=gChain)
 +
                            and thisModel}.atomIndex,
 +
                            {(atomno=@{get_cm_no(iNo-1)}) and (chain=gChain)
 +
                                and thisModel}.atomIndex]
 
                     }
 
                     }
 
                 }
 
                 }
               
+
            }
                # Find the best
+
        }
                if (newDist < dist) {
+
    }
                    dist = newDist
+
 
                    for (var k = 0; k < numChi; k++) {
+
    if (nWard) {
                        dh[k+1] = angle({atomIndex=@{scBondIdxs[4+(4*k)]}},
+
        gNrotors = rotors
                        {atomIndex=@{scBondIdxs[3+(4*k)]}},
+
    }
                        {atomIndex=@{scBondIdxs[2+(4*k)]}},
+
    else {
                         {atomIndex=@{scBondIdxs[1+(4*k)]}})
+
        gCrotors = rotors
 +
    }
 +
}
 +
function collect_bb_rotors(nWard) {
 +
    if (nWard) {
 +
        gNrotors = array()
 +
        var nres = {atomIndex=gNcargoIdx}.resno
 +
        var nname = {atomIndex=gNcargoIdx}.atomName
 +
        var ares = get_resno_min(gChain)
 +
        var aA = get_atom_rcn( ares, gChain, "N")
 +
        if (gNanchorIdx >= 0) {
 +
            aA = {atomIndex=gNanchorIdx}
 +
        }
 +
        var aname = aA.atomName
 +
        for (var r = nres; r >= ares; r--) {
 +
            var aCp = get_atom_rcn( r-1, gChain, "C")
 +
            var aN = get_atom_rcn( r, gChain, "N")
 +
            var aCa = get_atom_rcn( r, gChain, "CA")
 +
            var aC = get_atom_rcn( r, gChain, "C")
 +
            var aNn = get_atom_rcn( r+1, gChain, "N")
 +
            if (aCp.size < 1) {
 +
                aCp = aNn
 +
            }
 +
            # psi
 +
            if (((r < nres) and (r > ares))
 +
                or ((r == nres) and (nname == "C"))
 +
                or ((r == ares) and (aname != "C"))) {
 +
                if (is_rotor_avail(aCa.atomIndex, aC.atomIndex)) {
 +
                    gNrotors += aNn.atomIndex
 +
                    gNrotors += aC.atomIndex
 +
                    gNrotors += aCa.atomIndex
 +
                    gNrotors += aN.atomIndex
 +
                }
 +
            }
 +
                          
 +
            # phi
 +
            if (aCa.group != "PRO") {
 +
                if (((r <= nres) and (r > ares))
 +
                    or ((r == ares) and (aname == "N"))) {
 +
                    if (is_rotor_avail(aCa.atomIndex, aN.atomIndex)) {
 +
                        gNrotors += aC.atomIndex
 +
                        gNrotors += aCa.atomIndex
 +
                        gNrotors += aN.atomIndex
 +
                        gNrotors += aCp.atomIndex
 
                     }
 
                     }
 
                 }
 
                 }
 
             }
 
             }
 +
        } # endfor
 +
    }
 +
    else {
 +
        gCrotors = array()
 +
        var cres = {atomIndex=gCcargoIdx}.resno
 +
        var cname = {atomIndex=gCcargoIdx}.atomName
 +
        var ares = get_resno_max(gChain)
 +
        var aA = get_atom_rcn( ares, gChain, "C")
 +
        if (gCanchorIdx >= 0) {
 +
            aA = {atomIndex=gCanchorIdx}
 
         }
 
         }
 
+
         var aname = aA.atomName
         # Now set the best
+
         for (var r = cres; r <= ares; r++) {
         for (var i = 0; i < numChi; i++) {
+
             var aCp = get_atom_rcn( r-1, gChain, "C")
             select_add_sc(scBondIdxs[1+(4*i)])
+
            var aN = get_atom_rcn( r, gChain, "N")
             set_dihedral_idx(scBondIdxs[4+(4*i)], scBondIdxs[3+(4*i)],
+
            var aCa = get_atom_rcn( r, gChain, "CA")
                 scBondIdxs[2+(4*i)], scBondIdxs[1+(4*i)], dh[i+1])
+
            var aC = get_atom_rcn( r, gChain, "C")
         }
+
             var aNn = get_atom_rcn( r+1, gChain, "N")
 +
            if (aNn.size < 1) {
 +
                aNn = aCp
 +
            }
 +
           
 +
            # phi
 +
            if (aCa.group != "PRO") {
 +
                if (((r > cres) and (r < ares))
 +
                    or ((r == cres) and (aname == "N"))
 +
                    or ((r == ares) and (aname != "N"))) {
 +
                    if (is_rotor_avail(aN.atomIndex, aCa.atomIndex)) {
 +
                        gCrotors += aCp.atomIndex
 +
                        gCrotors += aN.atomIndex
 +
                        gCrotors += aCa.atomIndex
 +
                        gCrotors += aC.atomIndex
 +
                    }
 +
                }
 +
            }
 +
           
 +
            # psi
 +
            if (((r >= cres) and (r < ares))
 +
                or ((r == cres) and (aname != "C"))
 +
                 or ((r == ares) and (aname == "C"))) {
 +
                if (is_rotor_avail(aCa.atomIndex, aC.atomIndex)) {
 +
                    gCrotors += aN.atomIndex
 +
                    gCrotors += aCa.atomIndex
 +
                    gCrotors += aC.atomIndex
 +
                    gCrotors += aNn.atomIndex
 +
                }
 +
            }
 +
         } # endfor
 
     }
 
     }
    else { # PRO - toggle between puckers up and down
+
}
        var icd = {(atomno=@{iNo+1}) and (chain=iChain)}.atomIndex
+
 
        var icb = {(atomno=@{iNo-1}) and (chain=iChain)}.atomIndex
+
function collect_rotors() {
        var ica = {(atomno=@{iNo-4}) and (chain=iChain)}.atomIndex
+
    collect_bb_rotors(false)
        var in = {(atomno=@{iNo-5}) and (chain=iChain)}.atomIndex
+
    collect_bb_rotors(true)
        select {atomIndex=gSCidx}
+
}
 +
 
 +
function tug_sc(pt) {
  
        if (angle({atomIndex=ica}, {atomIndex=in},
+
    # If destination atom defined
            {atomIndex=icd}, {atomIndex=gSCidx}) < -10.0) {
+
    if (gDestAtomIdx >= 0) {
             set_dihedral_idx(ica, in, icd, gSCidx, 8.7)
+
        var v = {atomIndex=gDestAtomIdx}.xyz - {atomIndex=gSCidx}.xyz
            set_angle_idx(in, icd, gSCidx, 110.0)
+
        if (abs(angle({atomIndex=gDestAtomIdx}.xyz, {0 0 0}, pt)) < 90) {
            set_distance_idx(icd, gSCidx, 1.5)
+
             pt = -v/20.0
 
         }
 
         }
 
         else {
 
         else {
             set_dihedral_idx(ica, in, icd, gSCidx, -29.5)
+
             pt = v/20.0
            set_angle_idx(in, icd, gSCidx, 108.8)
 
            set_distance_idx(icd, gSCidx, 1.5)
 
 
         }
 
         }
 
     }
 
     }
 +
    gSCpt += pt
 +
    draw arrow {atomIndex=gSCidx} @gSCpt
 +
}
  
     draw gSCcircle CIRCLE {atomIndex=gSCidx} MESH NOFILL
+
function set_colors() {
     gSCpt = {atomIndex=gSCidx}.xyz
+
    select (thisModel)
 +
    color {selected} @gScheme
 +
     color {atomIndex=g1pivotIdx} green
 +
    color {atomIndex=g2pivotIdx} green
 +
    color @gCargoSet @gAltScheme
 +
    color {gCargoSet and oxygen} pink
 +
     select {(atomIndex=gCcargoIdx) or (atomIndex=gNcargoIdx)
 +
        or (atomIndex=gCanchorIdx) or (atomIndex=gNanchorIdx)}
 +
    halo on
 +
    select {atomIndex=gDestAtomIdx}
 +
    star on
 +
    select none
 
}
 
}
  
# Fix side chain collisions
+
function clear_atom_idxs() {
function fix_sc_collision_2(idx) {
+
     gCcargoIdx = -1
     gOk2 = FALSE
+
    gNcargoIdx = -1
     var iNo = {atomIndex=idx}.atomno
+
     gCanchorIdx = -1
     var iChain = {atomIndex=idx}.chain
+
    gNanchorIdx = -1
     var resno = {(atomno=iNo) and (chain=iChain)}.resno
+
    g1pivotIdx = -1
 +
     g2pivotIdx = -1
 +
    g1dynamicIdx = -1
 +
     g2dynamicIdx = -1
 +
    gDestAtomIdx = -1
 +
    gSCidx = -1
 +
}
  
     # Get SC terminus
+
function timed_out (s) {
     while (resno == {(atomno=iNo) and (chain=iChain)}.resno) {
+
     timeout ID"tug" OFF
         iNo++
+
     refresh
 +
    if (prompt(format("%s - Undo?", s), "Yes|No", true) == "Yes") {
 +
        gBusy = false
 +
        restore state gState
 +
        connect
 +
        select gCargoSet
 +
        set bondPicking true
 +
        refresh
 +
        for (var i = 1; i <= gFreeze.size; i+=2) {
 +
            select {atomIndex=@{gFreeze[i]}} or {atomIndex=@{gFreeze[i+1]}}
 +
            color bonds lightblue
 +
        }
 +
        background ECHO yellow
 +
        echo @gEcho
 +
         select all
 +
        quit
 
     }
 
     }
    iNo--
+
}
  
     var sc = array()
+
function record_drag() {
     var iBno = iNo
+
     var ls = format("select %s;", {selected})
     while ({(atomno=iBno) and (chain=iChain)}.atomName != "CB") {
+
    ls += format("gCanchorIdx = %d;", gCanchorIdx)
        sc += {(atomno=iBno) and (chain=iChain)}
+
    ls += format("gCanchorNo = %d;", gCanchorNo)
        iBno--
+
    ls += format("gNanchorIdx = %d;", gNanchorIdx)
     }
+
    ls += format("gNanchorNo = %d;", gNanchorNo)
     var cbidx = {(atomno=iBno) and (chain=iChain)}.atomIndex
+
    ls += format("gCcargoIdx = %d;", gCcargoIdx)
 +
    ls += format("gNcargoIdx = %d;", gNcargoIdx)
 +
    ls += format("gCcargoNo = %d;", gCcargoNo)
 +
    ls += format("gNcargoNo = %d;", gNcargoNo)
 +
    ls += format("gDestAtomIdx = %d;", gDestAtomIdx)
 +
     ls += format("g1pivotIdx = %d;", g1pivotIdx)
 +
     ls += format("g2pivotIdx = %d;", g2pivotIdx)
 +
    ls += format("gOkCollide = %s;", gOkCollide)
 +
    ls += format("gChain = \"%s\";", gChain)
 +
    ls += format("gMinNo = %d;", gMinNo)
 +
    ls += format("gMaxNo = %d;", gMaxNo)
 +
    ls += format("gCargoSet = %s;", gCargoSet)
 +
    ls += format("gSCidx = %d;", gSCidx)
 +
     ls += format("gSCcircle = %d;", gSCcircle)
 +
     ls += format("gSCpt = %s;", gSCpt)
 +
    ls += "collect_rotors();"
 +
    ls += "tug_drag_done_mb();"
 +
    plico_record(ls)
 +
}
  
     var scBondIdxs = collect_sc_rotors( iNo, iChain)
+
# Pick call-back for freeze
    var numChi = scBondIdxs.size / 4
+
function tug_pick_cb() {
 
+
     if (_pickInfo[3][6] == "bond") {
    # For all rotor combinations
+
        var sel = {selected}
    for (var i = 0; i < numChi; i++) {
+
        var i = _pickInfo.find(":")
         var rot = -120
+
        var iChain = _pickInfo[i+1]
         for (var j = 0; j < 6; j++) {
+
        i = _pickInfo.find("#")
             rot += 60
+
        var a1no = 0 + _pickInfo[i+1][i+3]
             select_add_sc(scBondIdxs[1+(4*i)])
+
         var j = _pickInfo[i+1][9999].find("#")
             set_dihedral_idx(scBondIdxs[1+(4*i)], scBondIdxs[2+(4*i)],
+
         var a2no = 0 + _pickInfo[i+j+1][i+j+3]
                 scBondIdxs[3+(4*i)], scBondIdxs[4+(4*i)], rot)
+
        var i1idx = {(atomno=a1no) and (chain=iChain)
               
+
            and thisModel}.atomIndex
            # If no collision, exit
+
        var i2idx = {(atomno=a2no) and (chain=iChain)
            colliders = (within(kCtolerance, FALSE, {sc})
+
             and thisModel}.atomIndex
                 and not {atomIndex=cbidx} and not {sc})
+
        if (({atomIndex=i1idx}.atomName == "CA")
 +
             or ({atomIndex=i2idx}.atomName == "CA")) {
 +
             if (({atomIndex=i1idx}.atomName != "CB")
 +
                and ({atomIndex=i2idx}.atomName != "CB")) {
 +
                 if (i1idx > i2idx) {
 +
                    var idx = 0 + i1idx
 +
                    i1idx = 0 + i2idx
 +
                    i2idx = 0 + idx
 +
                }
 +
                 select {atomIndex=i1idx} or {atomIndex=i2idx}
  
            # If it is with water, delete the water
+
                for (i = 1; i <= gFreeze.size; i += 2) {
            for (var c = 1; c < colliders.size; c++ ) {
+
                    if ((gFreeze[i] == i1idx) and (gFreeze[i+1] == i2idx)) {
                if (colliders[c].group = "HOH") {
+
                        if (i > 1) {
                    delete {atomIndex=@{colliders[c].atomIndex}}
+
                            if (gFreeze.size = (i+1)) {
                    colliders = {colliders and not @{colliders[c]}}
+
                                gFreeze = gFreeze[1][i-1]
 +
                            }
 +
                            else {
 +
                                gFreeze = gFreeze[1][i-1] + gFreeze[i+2][0]
 +
                            }
 +
                        }
 +
                        else {
 +
                            gFreeze = gFreeze[i+2][0]
 +
                        }
 +
                        color bonds NONE
 +
                        i = 0
 +
                        break
 +
                    }
 +
                }
 +
                if (i > gFreeze.size) {
 +
                    gFreeze += i1idx
 +
                    gFreeze += i2idx
 +
                    color bonds lightblue
 
                 }
 
                 }
 
             }
 
             }
 
            if (colliders.size == 0) {
 
                gOk2 = TRUE
 
                return # Early exit since break 1 appears broken
 
            }
 
 
 
         }
 
         }
 +
        select {sel}
 
     }
 
     }
 
}
 
}
  
function is_moveable_sc(aIdx) {
+
# Bound to LEFT-UP by tug_enable_drag
 +
function tug_drag_done_mb() {
 +
    if (not gBusy) {
 +
        if (gPlicoRecord != "") {
 +
            record_drag()
 +
        }
  
    var ret = (({atomIndex=aIdx}.group != "PRO")
+
        # Move by rotation on rotor sets, smallest first
         or ({atomIndex=aIdx}.atomName == "CG"))
+
         gBusy = true
    switch({atomIndex=aIdx}.atomName) {
+
         background ECHO pink
    case "N":
+
         refresh
    case "CA":
 
    case "C":
 
    case "CB":
 
    case "O":
 
    case "O4\'":
 
         ret = FALSE
 
         break
 
    }
 
    return ret
 
}
 
  
function is_rotor_avail(i1idx, i2idx) {
+
        # If side chain mode
    var ret = TRUE
+
        if (gSCidx >= 0) {
    if (i1idx > i2idx) {
+
            drag_sc()
        var idx = @i1idx
 
        i1idx = @i2idx
 
        i2idx = @idx
 
    }
 
   
 
    for (var i = 1; i <= gFreeze.size; i += 2) {
 
        if ((gFreeze[i] == i1idx) and (gFreeze[i+1] == i2idx)) {
 
            ret = FALSE
 
            break
 
 
         }
 
         }
    }
 
   
 
    return ret
 
}
 
  
function collect_bb_rotors(nWard) {
+
         # Else
    var anchorNo = (nWard
+
         else if (not gTow) {
         ? ((gNanchorIdx >= 0) ? {atomIndex=gNanchorIdx}.atomno : gMinNo)
+
            gOK = true
         : ((gCanchorIdx >= 0) ? {atomIndex=gCanchorIdx}.atomno : gMaxNo))
+
             timeout ID"tug" 20.0 "timed_out(\"Tug timed out\")"
    var cargoNo = (nWard
+
            if ((gCrotors.size < gNrotors.size) or (gNanchorIdx < 0)) {
        ? ((gNcargoIdx >= 0) ? {atomIndex=gNcargoIdx}.atomno
+
                if (gCrotors.size > 4) {
        : {atomIndex=gCcargoIdx}.atomno)
+
                    tug_track_c()
        : {atomIndex=gCcargoIdx}.atomno)
 
    var rotors = array()
 
    if (cargoNo < anchorNo) {
 
 
 
        for (var iNo = cargoNo; iNo <= anchorNo; iNo++) {
 
             if ({(atomno=iNo) and (chain=gChain)}.atomName == "CA") {
 
                if (is_rotor_avail(iNo)) {
 
                    if (({(atomno=iNo) and (chain=gChain)}.group != "PRO") and (iNo > cargoNo)) { # phi
 
                        rotors += [{(atomno=@{get_cm_no(iNo-1)}) and (chain=gChain)}.atomIndex,
 
                            {(atomno=@{iNo-1}) and (chain=gChain)}.atomIndex]
 
                        rotors += [{(atomno=@{iNo}) and (chain=gChain)}.atomIndex,
 
                            {(atomno=@{iNo+1}) and (chain=gChain)}.atomIndex]
 
                    }
 
                    if (iNo != (anchorNo-1)) { # psi
 
                        rotors += [{(atomno=@{iNo-1}) and (chain=gChain)}.atomIndex,
 
                            {(atomno=@{iNo}) and (chain=gChain)}.atomIndex]
 
                        rotors += [{(atomno=@{iNo+1}) and (chain=gChain)}.atomIndex,
 
                            {(atomno=@{get_np_no(iNo+2)}) and (chain=gChain)}.atomIndex]
 
                    }
 
 
                 }
 
                 }
            }
+
                if (gOK and (gNrotors.size > 4)) {
        }
+
                     tug_track_n()
    }
+
                }
    else {
+
            }
 
+
            else {
        for (var iNo = cargoNo; iNo >= anchorNo; iNo--) {
+
                if (gNrotors.size > 4) {
            if ({(atomno=iNo) and (chain=gChain)}.atomName == "CA") {
+
                    tug_track_n()
                if (is_rotor_avail(iNo)) {
+
                }
                     if ((iNo != (anchorNo-1)) and (iNo < cargoNo)) { # psi
+
                if (gOK and (gCrotors.size > 4)) {
                        rotors += [{(atomno=@{get_np_no(iNo+2)}) and (chain=gChain)}.atomIndex,
+
                    tug_track_c()
                            {(atomno=@{iNo+1}) and (chain=gChain)}.atomIndex]
 
                        rotors += [{(atomno=@{iNo}) and (chain=gChain)}.atomIndex,
 
                            {(atomno=@{iNo-1}) and (chain=gChain)}.atomIndex]
 
                    }
 
                    if ({(atomno=iNo) and (chain=gChain)}.group != "PRO") { # phi
 
                        rotors += [{(atomno=@{iNo+1}) and (chain=gChain)}.atomIndex,
 
                            {(atomno=@{iNo}) and (chain=gChain)}.atomIndex]
 
                        rotors += [{(atomno=@{iNo-1}) and (chain=gChain)}.atomIndex,
 
                            {(atomno=@{get_cm_no(iNo-1)}) and (chain=gChain)}.atomIndex]
 
                    }
 
 
                 }
 
                 }
 
             }
 
             }
        }
+
            timeout ID"tug" OFF
    }
 
  
    if (nWard) {
+
            # If anchor angles acute, fail
        gNrotors = rotors
+
            if (gOK == true) {
    }
+
                if (gCanchorIdx >= 0) {
    else {
+
                    var ic = get_cward_bb_idx(gCanchorIdx, gChain)
        gCrotors = rotors
+
                    var in = get_nward_bb_idx(gCanchorIdx, gChain)
    }
+
                    if ((ic >= 0) and
}
+
                        angle({atomIndex=ic}, {atomIndex=gCanchorIdx}, {atomIndex=in})
 +
                        < 100.0) {
 +
                        gOK = false
 +
                    }
 +
                }
 +
                if (gNanchorIdx >= 0) {
 +
                    var ic = get_cward_bb_idx(gNanchorIdx, gChain)
 +
                    var in = get_nward_bb_idx(gNanchorIdx, gChain)
 +
                    if ((in >= 0) and
 +
                        angle({atomIndex=ic}, {atomIndex=gNanchorIdx}, {atomIndex=in})
 +
                        < 100.0) {
 +
                        gOK = false
 +
                    }
 +
                }
 +
            }
 +
 
 +
            # If too far
 +
            if (not gOK) {
 +
                timed_out("TUG TOO FAR!")
 +
            }
  
function collect_rotors() {
+
            # Else OK
    collect_bb_rotors(FALSE)
+
            else {
    collect_bb_rotors(TRUE)
 
}
 
  
function tug_sc(pt) {
+
                var idx = {
 +
                    (atomno=@{{(chain=gChain) and thisModel}.atomno.min})
 +
                    and (chain=gChain) and thisModel}.atomIndex
  
    # If destination atom defined
+
 
    if (gDestAtomIdx >= 0) {
+
                var ihc = 0
        var v = {atomIndex=gDestAtomIdx}.xyz - {atomIndex=gSCidx}.xyz
+
                for (ihc = 0; ihc < 10; ihc++) {
        if (abs(angle({atomIndex=gDestAtomIdx}.xyz, {0 0 0}, pt)) < 90) {
+
                    select ((atomno >= gNanchorNo) and (atomno <= gCanchorNo)
            pt = -v/20.0
+
                        and (chain = gChain) and thisModel)
        }
+
                    handle_collisions( idx)
        else {
+
                    if (count_collisions(({})).size == 0) {
             pt = v/20.0
+
                        break
 +
                    }
 +
                }
 +
                if (ihc == 10) {
 +
                    timed_out("Unable to handle all collisions!")
 +
                }
 +
             }
 
         }
 
         }
 +
        select {gCargoSet}
 +
        gBusy = false
 +
        background ECHO yellow
 +
        set bondPicking true
 +
        refresh
 
     }
 
     }
    gSCpt += pt
 
    draw arrow {atomIndex=gSCidx} @gSCpt
 
 
}
 
}
  
function set_colors() {
+
# Bound to ALT-SHIFT-LEFT-DRAG by tug_enable_drag
     select all
+
function tug_drag_2_mb() {
    color {selected} @gScheme
+
     tug_drag_mb(true)
    color {atomIndex=g1pivotIdx} green
 
    color {atomIndex=g2pivotIdx} green
 
    color @gCargoSet @gAltScheme
 
    select {(atomIndex=gCcargoIdx) or (atomIndex=gNcargoIdx)
 
        or (atomIndex=gCanchorIdx) or (atomIndex=gNanchorIdx)}
 
    halo on
 
    select {atomIndex=gDestAtomIdx}
 
    star on
 
    select none
 
 
}
 
}
  
function clear_atom_idxs() {
+
# Bound to ALT-LEFT-DRAG by tug_enable_drag
     gCcargoIdx = -1
+
function tug_drag_mb(alt) {
    gNcargoIdx = -1
+
     if (not gBusy) {
    gCanchorIdx = -1
+
        gBusy = true
    gNanchorIdx = -1
+
        var dx = (40.0 * (_mouseX - gMouseX))/_width
    g1pivotIdx = -1
+
        var dy = (40.0 * (_mouseY - gMouseY))/_height
    g2pivotIdx = -1
+
        var q = quaternion()
    g1dynamicIdx = -1
+
        var ptd = {@dx @dy 0}
    g2dynamicIdx = -1
+
        var pt = (!q)%ptd
    gDestAtomIdx = -1
+
        var caxis = {0 0 0}
    gSCidx = -1
+
        if (distance(pt,  {0 0 0}) > 0.004) {
}
+
            # If sidechain mode
 +
            if (gSCidx >= 0) {
 +
                if ({atomIndex=gSCidx}.atomName == "O") {
 +
                    if ({atomIndex=gSCidx}.group != "PRO") {
 +
                        var dir = ((abs(dx) > abs(dy))
 +
                            ? ((dx < 0) ? 10 : -10)
 +
                            : ((dy < 0) ? 1 : -1))
 +
                        counter_rotate(gSCidx, dir, not alt)
 +
                    }
 +
                }
 +
                else {
 +
                    gSCcheck = not alt
 +
                    tug_sc(pt)
 +
                }
 +
            }
  
function timed_out (s) {
+
            # Else
    timeout ID"tug" OFF
+
            else {
    p = prompt(format("%s - Undo?", s), "Yes|No", TRUE)
 
    if (p == "Yes") {
 
        gBusy = FALSE
 
        background ECHO yellow
 
        restore state gState
 
        connect
 
        select gCargoSet
 
        refresh
 
        quit
 
    }
 
}
 
  
function record_drag() {
+
                # If new drag
    var ls = format("select %s;", {selected})
+
                if (gNewDrag) {
    ls += format("gCanchorIdx = %d;", gCanchorIdx)
+
                    gNewDrag = false
    ls += format("gCanchorNo = %d;", gCanchorNo)
+
                    save state gState
    ls += format("gNanchorIdx = %d;", gNanchorIdx)
+
                }
    ls += format("gNanchorNo = %d;", gNanchorNo)
 
    ls += format("gCcargoIdx = %d;", gCcargoIdx)
 
    ls += format("gNcargoIdx = %d;", gNcargoIdx)
 
    ls += format("gCcargoNo = %d;", gCcargoNo)
 
    ls += format("gNcargoNo = %d;", gNcargoNo)
 
    ls += format("gDestAtomIdx = %d;", gDestAtomIdx)
 
    ls += format("g1pivotIdx = %d;", g1pivotIdx)
 
    ls += format("g2pivotIdx = %d;", g2pivotIdx)
 
    ls += format("gOkCollide = %s;", gOkCollide)
 
    ls += format("gChain = \"%s\";", gChain)
 
    ls += format("gMinNo = %d;", gMinNo)
 
    ls += format("gMaxNo = %d;", gMaxNo)
 
    ls += format("gCargoSet = %s;", gCargoSet)
 
    ls += format("gSCidx = %d;", gSCidx)
 
    ls += format("gSCcircle = %d;", gSCcircle)
 
    ls += format("gSCpt = %s;", gSCpt)
 
    ls += "collect_rotors();"
 
    ls += "tug_drag_done_mb();"
 
    plico_record(ls)
 
}
 
  
# Pick call-back for freeze
+
                # If destination atom defined
function tug_pick_cb() {
+
                if (gDestAtomIdx >= 0) {
 
+
                    var v = {atomIndex=gDestAtomIdx}.xyz - {selected}.xyz
    if (_pickInfo[3][6] == "bond") {
+
                    if (abs(angle({atomIndex=gDestAtomIdx}.xyz, {0 0 0}, pt)) < 90) {
        var sel = {selected}
+
                        pt = -v/20.0
        var i = _pickInfo.find(":")
+
                     }
        var iChain = _pickInfo[i+1]
+
                     else {
        i = _pickInfo.find("#")
+
                         pt = v/20.0
        var a1no = _pickInfo[i+1][i+3]
 
        j = _pickInfo[i+1][9999].find("#")
 
        var a2no = _pickInfo[i+j+1][i+j+3]
 
        var i1idx = {(atomno=a1no) and (chain=iChain)}.atomIndex
 
        var i2idx = {(atomno=a2no) and (chain=iChain)}.atomIndex
 
       
 
        if (({atomIndex=i1idx}.atomName == "CA")
 
            or ({atomIndex=i2idx}.atomName == "CA")) {
 
            if (({atomIndex=i1idx}.atomName != "CB")
 
                and ({atomIndex=i2idx}.atomName != "CB")) {
 
                if (i1idx > i2idx) {
 
                    idx = 0 + i1idx
 
                    i1idx = 0 + i2idx
 
                     i2idx = 0 + idx
 
                }
 
                select {atomIndex=i1idx} or {atomIndex=i2idx}
 
               
 
                for (i = 1; i <= gFreeze.size; i += 2) {
 
                     if ((gFreeze[i] == i1idx) and (gFreeze[i+1] == i2idx)) {
 
                         gFreeze[i] == -1
 
                        color bonds NONE
 
                        break
 
 
                     }
 
                     }
 
                 }
 
                 }
                if (i > gFreeze.size) {
 
                    gFreeze += i1idx
 
                    gFreeze += i2idx
 
                    color bonds lightblue
 
                }
 
            }
 
        }
 
        select {sel}
 
    }
 
}
 
  
# Bound to LEFT-UP by tug_enable_drag
+
                # Move the cargo
function tug_drag_done_mb() {
+
                select {gCargoSet}
    if (not gBusy) {
+
 
        if (gPlicoRecord != "") {
+
                # If pivots defined, rotate it
            record_drag()
+
                if (g1pivotIdx >= 0) {
        }
 
  
        # Move by rotation on rotor sets, smallest first
+
                    # If two pivots
        gBusy = TRUE
+
                    if (g2pivotIdx >= 0) {
        background ECHO pink
+
                        caxis = {atomIndex=g2pivotIdx}
        refresh
+
                    }
  
        # If side chain mode
+
                    # Else
        if (gSCidx >= 0) {
+
                    else {
            drag_sc()
+
                        caxis = cross(pt, {0 0 0}) + {atomIndex=g1pivotIdx}.xyz
        }
+
                    }
 +
 
 +
                    var dir = ((abs(dx) > abs(dy))
 +
                        ? ((dx < 0) ? 2 : -2)
 +
                        : ((dy < 0) ? 2 : -2))
 +
                    rotate_selected_record(g1pivotIdx, caxis, dir)
  
        # Else
 
        else if (not gTow) {
 
            gOK = TRUE
 
            timeout ID"tug" 20.0 "timed_out(\"Tug timed out\")"
 
            if ((gCrotors.size < gNrotors.size) or (gNanchorIdx < 0)) {
 
                if (gCrotors.size > 4) {
 
                    tug_track_c()
 
 
                 }
 
                 }
                 if (gOK and (gNrotors.size > 4)) {
+
 
                     tug_track_n()
+
                 # Else translate it
 +
                else {
 +
                     translate_selected_record(pt)
 
                 }
 
                 }
            }
 
            else {
 
                if (gNrotors.size > 4) {
 
                    tug_track_n()
 
                }
 
                if (gOK and (gCrotors.size > 4)) {
 
                    tug_track_c()
 
                }
 
            }
 
            timeout ID"tug" OFF
 
  
            # If anchor angles acute, fail
+
                # If collisions
            if (gOK == TRUE) {
+
                 var cNotSels = (within(kCtolerance, false, {selected})
                 if (gCanchorIdx >= 0) {
+
                     and not {gMovingSet})
                    var ic = get_cward_bb_idx(gCanchorIdx, gChain)
+
                if ((cNotSels) and (not alt)) {
                     var in = get_nward_bb_idx(gCanchorIdx, gChain)
+
                    gOk2 = true
                    if ((ic >= 0) and
+
                     for (var i = 1; i <= cNotSels.size;  i++) {
                        angle({atomIndex=ic}, {atomIndex=gCanchorIdx}, {atomIndex=in})
+
 
                        < 100.0) {
+
                        # If net collision vector same as move vector
                        gOK = FALSE
+
                        var cSels = (within(kCtolerance, false, cNotSels[i]) and {selected})
                     }
+
                        for (var j = 1; j <= cSels.size;  j++) {
                }
+
                            var v1 = cNotSels[i].xyz - cSels[j].xyz
                if (gNanchorIdx >= 0) {
+
                            if (abs(angle(v1, {0 0 0}, pt)) < 90) {
                    var ic = get_cward_bb_idx(gNanchorIdx, gChain)
 
                    var in = get_nward_bb_idx(gNanchorIdx, gChain)
 
                    if ((in >= 0) and
 
                        angle({atomIndex=ic}, {atomIndex=gNanchorIdx}, {atomIndex=in})
 
                        < 100.0) {
 
                        gOK = FALSE
 
                    }
 
                }
 
            }
 
  
            # If too far
+
                                # If tow mode
            if (not gOK) {
+
                                if (gTow) {
                timed_out("TUG TOO FAR!")
 
            }
 
  
            # Else OK
+
                                    # Make a dynamic pivot
            else {
+
                                    if (g1pivotIdx < 0) {
 
+
                                        g1pivotIdx = cSels[j].atomIndex
                select ((atomno >= gNanchorNo) and (atomno <= gCanchorNo)
+
                                        g1dynamicIdx = cNotSels[i].atomIndex
                    and (chain = gChain))
+
                                        color {atomIndex=g1pivotIdx} lightgreen
                var idx = {(atomno=@{{chain=gChain}.atomno.min})
+
                                        set_distance_idx(cNotSels[i].atomIndex,
                    and (chain=gChain)}.atomIndex
+
                                            cSels[j].atomIndex,
 
+
                                            kCtolerance + kDtolerance)
 
+
                                    }
                var ihc = 0
+
                                    else if (g2pivotIdx < 0) {
                for (ihc = 0; ihc < 10; ihc++) {
+
                                        g2pivotIdx = cSels[j].atomIndex
                    handle_collisions_2( idx)
+
                                        g2dynamicIdx = cNotSels[i].atomIndex
                    if (count_collisions(({})).size == 0) {
+
                                        color {atomIndex=g2pivotIdx} lightgreen
                        break
+
                                        set_distance_idx(cNotSels[i].atomIndex,
                    }
+
                                            cSels[j].atomIndex,
                }
+
                                            kCtolerance + kDtolerance)
                if (ihc == 10) {
+
                                    }
                    timed_out("Unable to handle all collisions!")
+
                                    else {
                }
+
                                        gOk2 = false
            }
+
                                    }
        }
+
                                }
        select {gCargoSet}
+
                                else {
        gBusy = FALSE
 
        background ECHO yellow
 
        refresh
 
    }
 
}
 
  
# Bound to ALT-SHIFT-LEFT-DRAG by tug_enable_drag
+
                                    # Try to resolve
function tug_drag_2_mb() {
+
                                    select @{cSels[j]}
    tug_drag_mb(TRUE)
+
                                    var idx = {(atomno=@{{(chain=gChain)
}
+
                                        and thisModel}.atomno.min})
 
+
                                        and (chain=gChain) and thisModel}.atomIndex
# Bound to ALT-LEFT-DRAG by tug_enable_drag
+
                                    handle_collisions( idx)
function tug_drag_mb(alt) {
+
                                }
    if (not gBusy) {
+
                            }
        gBusy = TRUE
+
                        } # endfor
        var dx = (40.0 * (_mouseX - gMouseX))/_width
+
                        if (not gOk2) {
        var dy = (40.0 * (_mouseY - gMouseY))/_height
+
                            break
        var q = quaternion()
+
                         }
        var ptd = {@dx @dy 0}
+
                     } # endfor
        var pt = (!q)%ptd
 
        var axis = {0 0 0}
 
        if (distance(pt,  {0 0 0}) > 0.004) {
 
            # If sidechain mode
 
            if (gSCidx >= 0) {
 
                if ({atomIndex=gSCidx}.atomName == "O") {
 
                    dir = ((abs(dx) > abs(dy))
 
                         ? ((dx < 0) ? 10 : -10)
 
                        : ((dy < 0) ? 1 : -1))
 
                    counter_rotate(gSCidx, dir, not alt)
 
                }
 
                else {
 
                    gSCcheck = not alt
 
                     tug_sc(pt)
 
                }
 
            }
 
  
            # Else
+
                    # If unable
            else {
+
                    if (not gOk2) {
  
                # If new drag
+
                        # Back off
                if (gNewDrag) {
+
                        background ECHO pink
                    gNewDrag = FALSE
+
                        delay 1
                    save state gState
+
                        if (g1pivotIdx >= 0) {
                }
+
                            rotate_selected_record(g1pivotIdx, caxis, -a)
 
+
                        }
                # If destination atom defined
+
                        else {
                if (gDestAtomIdx >= 0) {
+
                            translate_selected_record(-pt)
                    var v = {atomIndex=gDestAtomIdx}.xyz - {selected}.xyz
+
                         }
                    if (abs(angle({atomIndex=gDestAtomIdx}.xyz, {0 0 0}, pt)) < 90) {
+
                        background ECHO yellow
                         pt = -v/20.0
+
                         set bondPicking true
                    }
 
                    else {
 
                         pt = v/20.0
 
 
                     }
 
                     }
 
                 }
 
                 }
 +
            }
  
                # Move the cargo
+
            # If dynamic pivots
                select {gCargoSet}
+
            if (g1dynamicIdx >= 0) {
 
+
                var v1 = {atomIndex=g1dynamicIdx}.xyz - {atomIndex=g1pivotIdx}.xyz
                # If pivots defined, rotate it
+
                if (abs(angle(v1, {0 0 0}, pt)) > 90) {
                if (g1pivotIdx >= 0) {
+
                    color {atomIndex=g1pivotIdx} @gAltScheme
 
+
                     g1pivotIdx = -1
                    # If two pivots
+
                     g1dynamicIdx = -1
                    if (g2pivotIdx >= 0) {
 
                        axis = {atomIndex=g2pivotIdx}
 
                    }
 
 
 
                    # Else
 
                    else {
 
                        axis = cross(pt, {0 0 0}) + {atomIndex=g1pivotIdx}.xyz
 
                     }
 
 
 
                     dir = ((abs(dx) > abs(dy))
 
                        ? ((dx < 0) ? 2 : -2)
 
                        : ((dy < 0) ? 2 : -2))
 
                    rotate_selected_record(g1pivotIdx, axis, dir)
 
  
 
                 }
 
                 }
 
+
            }
                # Else translate it
+
            if (g2dynamicIdx >= 0) {
                 else {
+
                 var v1 = {atomIndex=g2dynamicIdx}.xyz - {atomIndex=g2pivotIdx}.xyz
                    translate_selected_record(pt)
+
                if (abs(angle(v1, {0 0 0}, pt)) > 90) {
 +
                    color {atomIndex=g2pivotIdx} @gAltScheme
 +
                    g2pivotIdx = -1
 +
                    g2dynamicIdx = -1
 
                 }
 
                 }
 +
            }
  
                # If collisions
+
            gMouseX = _mouseX
                var cNotSels = (within(kCtolerance, FALSE, {selected})
+
            gMouseY = _mouseY
                    and not {gMovingSet})
+
        }
                if ((cNotSels.size > 0) and (not alt)) {
+
        select {gCargoSet}
                    gOk2 = TRUE
+
        gBusy = false
                    for (var i = 1; i <= cNotSels.size;  i++) {
+
    }
 +
}
  
                        # If net collision vector same as move vector
+
# Bound to ALT-LEFT-DOWN by tug_enable_drag
                        cSels = (within(kCtolerance, FALSE, cNotSels[i]) and {selected})
+
function tug_mark_mb() {
                        for (var j = 1; j <= cSels.size;  j++) {
+
    gMouseX = _mouseX
                            var v1 = cNotSels[i].xyz - cSels[j].xyz
+
    gMouseY = _mouseY
                            if (abs(angle(v1, {0 0 0}, pt)) < 90) {
+
    gNewDrag = true
 +
}
  
                                # If tow mode
+
# Called by tug_cargo_mb
                                if (gTow) {
+
function tug_enable_drag() {
 +
    gEcho = "__________TUG__________|ALT-CLICK=mark block|SHIFT-CLICK=anchors" +
 +
        "|ALT-CTRL-CLICK=pivots|ALT-SHIFT-CLICK=dest atom|ALT-DRAG=move" +
 +
        "|ALT-SHIFT-DRAG=alt move|CLICK bond=freeze|ALT-DOUBLE-CLICK=undo" +
 +
        "|SHIFT-DOUBLE-CLICK=exit"
 +
    echo @gEcho
  
                                    # Make a dynamic pivot
+
    # Allow atoms to be dragged
                                    if (g1pivotIdx < 0) {
+
    bind "ALT-LEFT-DOWN" "tug_mark_mb";
                                        g1pivotIdx = cSels[j].atomIndex
+
    bind "ALT-LEFT-UP" "tug_drag_done_mb";
                                        g1dynamicIdx = cNotSels[i].atomIndex
+
    bind "ALT-SHIFT-LEFT-DOWN" "tug_mark_mb";
                                        color {atomIndex=g1pivotIdx} lightgreen
+
    bind "ALT-LEFT-DRAG" "tug_drag_mb";
                                        set_distance_idx(cNotSels[i].atomIndex,
+
    bind "ALT-SHIFT-LEFT-DRAG" "tug_drag_2_mb";
                                            cSels[j].atomIndex,
 
                                            kCtolerance + kDtolerance)
 
                                    }
 
                                    else if (g2pivotIdx < 0) {
 
                                        g2pivotIdx = cSels[j].atomIndex
 
                                        g2dynamicIdx = cNotSels[i].atomIndex
 
                                        color {atomIndex=g2pivotIdx} lightgreen
 
                                        set_distance_idx(cNotSels[i].atomIndex,
 
                                            cSels[j].atomIndex,
 
                                            kCtolerance + kDtolerance)
 
                                    }
 
                                    else {
 
                                        gOk2 = FALSE
 
                                    }
 
                                }
 
                                else {
 
  
                                    # Try to resolve
+
    unbind "SHIFT-LEFT-CLICK"
                                    select cSels[j]
+
    bind "SHIFT-LEFT-CLICK" "_pickAtom";
                                    var idx = {(atomno=@{{chain=gChain}.atomno.min})
+
    bind "SHIFT-LEFT-CLICK" "+:tug_anchor_mb";
                                        and (chain=gChain)}.atomIndex
 
                                    handle_collisions_2( idx)
 
                                }
 
                            }
 
                        } # endfor
 
                        if (not gOk2) {
 
                            break
 
                        }
 
                    } # endfor
 
  
                    # If unable
+
    bind "ALT-CTRL-LEFT-CLICK" "_pickAtom";
                    if (not gOk2) {
+
    bind "ALT-CTRL-LEFT-CLICK" "+:tug_pivot_mb";
  
                        # Back off
+
    bind "ALT-SHIFT-LEFT-CLICK" "_pickAtom";
                        background ECHO pink
+
    bind "ALT-SHIFT-LEFT-CLICK" "+:tug_dest_atom_mb";
                        delay 1
+
}
                        if (g1pivotIdx >= 0) {
 
                            rotate_selected_record(g1pivotIdx, axis, -a)
 
                        }
 
                        else {
 
                            translate_selected_record(-pt)
 
                        }
 
                        background ECHO yellow
 
                    }
 
                }
 
            }
 
  
            # If dynamic pivots
+
# Bound to SHIFT-LEFT-CLICK by tug_cargo_mb
            if (g1dynamicIdx >= 0) {
+
function tug_anchor_mb() {
                var v1 = {atomIndex=g1dynamicIdx}.xyz - {atomIndex=g1pivotIdx}.xyz
+
    if ({atomIndex=_atomPicked}.chain == gChain) {
                if (abs(angle(v1, {0 0 0}, pt)) > 90) {
+
        var aPidx = get_sc_bb_idx( _atomPicked, gChain)
                    color {atomIndex=g1pivotIdx} @gAltScheme
 
                    g1pivotIdx = -1
 
                    g1dynamicIdx = -1
 
  
                 }
+
        var pno = {atomIndex=aPidx}.atomno
 +
        if (pno > {atomIndex=gCcargoIdx}.atomno) {
 +
            select {atomIndex=gCanchorIdx}
 +
            halo off
 +
            if (gCanchorIdx == aPidx) {
 +
                gCanchorIdx = -1
 +
                gCanchorNo = gMaxNo + 1
 +
            }
 +
            else {
 +
                 gCanchorIdx = aPidx
 +
                gCanchorNo = {atomIndex=gCanchorIdx}.atomno
 +
                select {atomIndex=gCanchorIdx}
 +
                halo on
 
             }
 
             }
             if (g2dynamicIdx >= 0) {
+
             collect_bb_rotors(false)
                var v1 = {atomIndex=g2dynamicIdx}.xyz - {atomIndex=g2pivotIdx}.xyz
+
        }
                if (abs(angle(v1, {0 0 0}, pt)) > 90) {
+
        else if (pno < {atomIndex=gNcargoIdx}.atomno) {
                    color {atomIndex=g2pivotIdx} @gAltScheme
+
            select {atomIndex=gNanchorIdx}
                    g2pivotIdx = -1
+
            halo off
                    g2dynamicIdx = -1
+
            if (gNanchorIdx == aPidx) {
                 }
+
                gNanchorIdx = -1
 +
                gNanchorNo = gMinNo - 1
 +
            }
 +
            else {
 +
                gNanchorIdx = aPidx
 +
                gNanchorNo = {atomIndex=gNanchorIdx}.atomno
 +
                 select {atomIndex=gNanchorIdx}
 +
                halo on
 
             }
 
             }
 +
            collect_bb_rotors(true)
 +
        }
 +
        else {
 +
            tow_cargo_mb()
 +
        }
  
            gMouseX = _mouseX
+
         # Get moving atoms set
            gMouseY = _mouseY
+
         gMovingSet = {((atomno < gCanchorNo) and (atomno > gNanchorNo)
         }
+
            and (chain=gChain) and thisModel)}
         select {gCargoSet}
 
        gBusy = FALSE
 
 
     }
 
     }
 +
    select {gCargoSet}
 
}
 
}
  
# Bound to ALT-LEFT-DOWN by tug_enable_drag
+
# Bound to ALT-SHIFT-LEFT-CLICK by tug_cargo_mb
function tug_mark_mb() {
+
function tug_dest_atom_mb() {
     gMouseX = _mouseX
+
     var aOk = true
     gMouseY = _mouseY
+
     if ({atomIndex=_atomPicked}.chain == gChain) {
     gNewDrag = TRUE
+
 
 +
        var pno = {atomIndex=_atomPicked}.atomno
 +
        if ((pno <= {atomIndex=gCcargoIdx}.atomno)
 +
            and (pno >= {atomIndex=gNcargoIdx}.atomno)) {
 +
            aOk = false
 +
        }
 +
     }
 +
    if (aOk) {
 +
        select {atomIndex=gDestAtomIdx}
 +
        star off
 +
        if (gDestAtomIdx == _atomPicked) {
 +
            gDestAtomIdx = -1
 +
        }
 +
        else {
 +
            gDestAtomIdx = _atomPicked
 +
            select {atomIndex=gDestAtomIdx}
 +
            star on
 +
        }
 +
        select {gCargoSet}
 +
    }
 
}
 
}
  
# Called by tug_cargo_mb
+
# Bound to CTRL-LEFT-CLICK by tug_cargo_mb
function tug_enable_drag() {
+
function tug_pivot_mb() {
     gEcho = "__________TUG__________|ALT-CLICK=mark block|SHIFT-CLICK=anchors" +
+
     if (g1pivotIdx == _atomPicked) {
         "|ALT-CTRL-CLICK=pivots|ALT-SHIFT-CLICK=dest atom|ALT-DRAG=move" +
+
        color {atomIndex=g1pivotIdx} @gScheme
         "|SHIFT-ALT-DRAG=alt move|CLICK bond=freeze|DOUBLE-CLICK=exit"
+
         if (g2pivotIdx >= 0) {
     echo @gEcho
+
            g1pivotIdx = g2pivotIdx
 +
            g2pivotIdx = -1
 +
            g2dynamicIdx = -1
 +
        }
 +
        else {
 +
            g1pivotIdx = -1
 +
            g1dynamicIdx = -1
 +
        }
 +
    }
 +
    else if (g2pivotIdx == _atomPicked) {
 +
         color {atomIndex=g2pivotIdx} @gScheme
 +
        g2pivotIdx = -1
 +
        g2dynamicIdx = -1
 +
     }
 +
    else if (g1pivotIdx >= 0) {
 +
        if (g2pivotIdx >= 0) {
 +
            color {atomIndex=g2pivotIdx} @gScheme
 +
        }
  
    # Allow atoms to be dragged
+
        g2pivotIdx = _atomPicked
    bind "ALT-LEFT-DOWN" "tug_mark_mb";
+
        g2dynamicIdx = -1
    bind "ALT-LEFT-UP" "tug_drag_done_mb";
+
        color {atomIndex=g2pivotIdx} green
    bind "ALT-SHIFT-LEFT-DOWN" "tug_mark_mb";
+
     }
    bind "ALT-SHIFT-LEFT-UP" "tug_drag_done_mb";
+
     else {
    bind "ALT-LEFT-DRAG" "tug_drag_mb";
+
        g1pivotIdx = _atomPicked
    bind "ALT-SHIFT-LEFT-DRAG" "tug_drag_2_mb";
+
        g1dynamicIdx = -1
 
+
        color {atomIndex=g1pivotIdx} green
    unbind "SHIFT-LEFT-CLICK"
+
     }
     bind "SHIFT-LEFT-CLICK" "_pickAtom";
+
     select {gCargoSet}
     bind "SHIFT-LEFT-CLICK" "+:tug_anchor_mb";
 
 
 
    bind "ALT-CTRL-LEFT-CLICK" "_pickAtom";
 
    bind "ALT-CTRL-LEFT-CLICK" "+:tug_pivot_mb";
 
 
 
     bind "ALT-SHIFT-LEFT-CLICK" "_pickAtom";
 
     bind "ALT-SHIFT-LEFT-CLICK" "+:tug_dest_atom_mb";
 
 
}
 
}
  
# Bound to SHIFT-LEFT-CLICK by tug_cargo_mb
+
# Bound to SHIFT-LEFT-CLICK by plico_tug
function tug_anchor_mb() {
+
function tow_cargo_mb() {
     if ({atomIndex=_atomPicked}.chain == gChain) {
+
     gTow = true
        var aPidx = get_sc_bb_idx( _atomPicked, gChain)
+
    gChain = {atomIndex=_atomPicked}.chain
 +
    gMinNo = {(chain=gChain) and thisModel}.atomno.min
 +
    gMaxNo = {(chain=gChain) and thisModel}.atomno.max
 +
    gCcargoIdx = -1
 +
    gNcargoIdx = -1
 +
    gCanchorIdx = -1
 +
    gCanchorNo = gMaxNo + 1
 +
    gNanchorIdx = -1
 +
    gNanchorNo = gMinNo - 1
 +
 
 +
    # Highlight cargo cluster
 +
    select {(chain=gChain) and thisModel}
 +
    gCargoSet = {selected}
 +
    gMovingSet = {selected}
 +
    set_colors()
  
        var pno = {atomIndex=aPidx}.atomno
+
    # Enable dragging
        if (pno > {atomIndex=gCcargoIdx}.atomno) {
+
    tug_enable_drag()
            select {atomIndex=gCanchorIdx}
+
    select {gCargoSet}
            halo off
+
    halo off
            if (gCanchorIdx == aPidx) {
+
    var es = gEcho.replace("anchors","mark chain")
                gCanchorIdx = -1
+
    echo @es
                gCanchorNo = gMaxNo + 1
+
    unbind "SHIFT-LEFT-CLICK"
            }
+
     bind "SHIFT-LEFT-CLICK" "_pickAtom";
            else {
+
     bind "SHIFT-LEFT-CLICK" "+:tow_cargo_mb";
                gCanchorIdx = aPidx
 
                gCanchorNo = {atomIndex=gCanchorIdx}.atomno
 
                select {atomIndex=gCanchorIdx}
 
                halo on
 
            }
 
            collect_bb_rotors(FALSE)
 
        }
 
        else if (pno < {atomIndex=gNcargoIdx}.atomno) {
 
            select {atomIndex=gNanchorIdx}
 
            halo off
 
            if (gNanchorIdx == aPidx) {
 
                gNanchorIdx = -1
 
                gNanchorNo = gMinNo - 1
 
            }
 
            else {
 
                gNanchorIdx = aPidx
 
                gNanchorNo = {atomIndex=gNanchorIdx}.atomno
 
                select {atomIndex=gNanchorIdx}
 
                halo on
 
            }
 
            collect_bb_rotors(TRUE)
 
        }
 
        else {
 
            tow_cargo_mb()
 
        }
 
 
 
        # Get moving atoms set
 
        gMovingSet = {((atomno < gCanchorNo) and (atomno > gNanchorNo)
 
            and (chain=gChain))}
 
     }
 
     select {gCargoSet}
 
 
}
 
}
  
# Bound to ALT-SHIFT-LEFT-CLICK by tug_cargo_mb
+
# Bound to ALT-LEFT-CLICK by plico_tug or called by plicotoab.toabCargoMB
function tug_dest_atom_mb() {
+
function tug_cargo_mb() {
    var aOk = TRUE
 
    if ({atomIndex=_atomPicked}.chain == gChain) {
 
  
        var pno = {atomIndex=_atomPicked}.atomno
+
    # If O or movable side chain atom picked
         if ((pno <= {atomIndex=gCcargoIdx}.atomno) and (pno >= {atomIndex=gNcargoIdx}.atomno)) {
+
    if ((({atomIndex=_atomPicked}.atomName = "O")
             aOk = FALSE
+
         and ({atomIndex=_atomPicked}.group != "PRO"))
 +
        or (is_moveable_sc( _atomPicked))) {
 +
        if (gSCidx >= 0) {
 +
             draw gSCcircle DELETE
 
         }
 
         }
    }
+
         if (gSCidx == _atomPicked) {
    if (aOk) {
+
             gSCidx = -1
        select {atomIndex=gDestAtomIdx}
 
        star off
 
         if (gDestAtomIdx == _atomPicked) {
 
             gDestAtomIdx = -1
 
 
         }
 
         }
 
         else {
 
         else {
             gDestAtomIdx = _atomPicked
+
             gSCidx = _atomPicked
             select {atomIndex=gDestAtomIdx}
+
             gSCpt = {atomIndex=gSCidx}.xyz
             star on
+
             draw gSCcircle CIRCLE {atomIndex=gSCidx} MESH NOFILL
 
         }
 
         }
        select {gCargoSet}
 
 
     }
 
     }
}
+
    else {
 
+
        if ({atomIndex=_atomPicked}.chain != gChain) {
# Bound to CTRL-LEFT-CLICK by tug_cargo_mb
+
            if (gTow) {
function tug_pivot_mb() {
+
                select {(chain=gChain) and thisModel}
    if (g1pivotIdx == _atomPicked) {
+
                color {selected} @gScheme
        color {atomIndex=g1pivotIdx} @gScheme
+
            }
        if (g2pivotIdx >= 0) {
+
            gChain = {atomIndex=_atomPicked}.chain
             g1pivotIdx = g2pivotIdx
+
            select ({atomIndex=gCcargoIdx} or {atomIndex=gNcargoIdx}
             g2pivotIdx = -1
+
                or {atomIndex=gCanchorIdx} or {atomIndex=gNanchorIdx})
             g2dynamicIdx = -1
+
             halo off
 +
            gCcargoIdx = -1
 +
            gNcargoIdx = -1
 +
             gCanchorIdx = -1
 +
             gNanchorIdx = -1
 
         }
 
         }
         else {
+
         gTow = false
            g1pivotIdx = -1
+
        gMinNo = {(chain=gChain) and thisModel}.atomno.min
             g1dynamicIdx = -1
+
        gMaxNo = {(chain=gChain) and thisModel}.atomno.max
 +
        if (gNanchorIdx < 0) {
 +
             gNanchorNo = gMinNo - 1
 
         }
 
         }
    }
+
         if (gCanchorIdx < 0) {
    else if (g2pivotIdx == _atomPicked) {
+
             gCanchorNo = gMaxNo + 1
        color {atomIndex=g2pivotIdx} @gScheme
 
        g2pivotIdx = -1
 
         g2dynamicIdx = -1
 
    }
 
    else if (g1pivotIdx >= 0) {
 
        if (g2pivotIdx >= 0) {
 
             color {atomIndex=g2pivotIdx} @gScheme
 
 
         }
 
         }
 +
        var aPidx = get_sc_bb_idx( _atomPicked, gChain)
  
         g2pivotIdx = _atomPicked
+
         gSCidx = -1
        g2dynamicIdx = -1
+
         draw gSCcircle DELETE
         color {atomIndex=g2pivotIdx} green
+
 
    }
+
         # If existing cWard cargo picked
    else {
+
         if (gCcargoIdx == aPidx) {
         g1pivotIdx = _atomPicked
 
         g1dynamicIdx = -1
 
        color {atomIndex=g1pivotIdx} green
 
    }
 
    select {gCargoSet}
 
}
 
  
# Bound to SHIFT-LEFT-CLICK by plico_tug
+
            # Clear the highlight
function tow_cargo_mb() {
+
            select {atomIndex=gCcargoIdx}
    gTow = TRUE
+
            halo off
    gChain = {atomIndex=_atomPicked}.chain
 
    gMinNo = {chain=gChain}.atomno.min
 
    gMaxNo = {chain=gChain}.atomno.max
 
    gCcargoIdx = -1
 
    gNcargoIdx = -1
 
    gCanchorIdx = -1
 
    gCanchorNo = gMaxNo + 1
 
    gNanchorIdx = -1
 
    gNanchorNo = gMinNo - 1
 
  
    # Highlight cargo cluster
+
            # If nWard cargo exists, mark it as the cWard cargo
    select {chain=gChain}
+
            if (gNcargoIdx != gCcargoIdx) {
    gCargoSet = {selected}
+
                gCcargoIdx = get_cp_idx(gNcargoIdx)
    gMovingSet = {selected}
+
                gCcargoNo = {atomIndex=gCcargoIdx}.atomno
    set_colors()
+
            }
 
+
            else {
    # Enable dragging
+
                gCcargoIdx = -1
    tug_enable_drag()
+
                gNcargoIdx = -1
    select {gCargoSet}
+
            }
    halo off
+
        }
    var es = gEcho.replace("anchors","mark chain")
+
        else if (gNcargoIdx == aPidx) {
    echo @es
+
            select {atomIndex=gNcargoIdx}
    unbind "SHIFT-LEFT-CLICK"
+
            halo off
    bind "SHIFT-LEFT-CLICK" "_pickAtom";
+
            gNcargoIdx = get_nm_idx(gCcargoIdx)
    bind "SHIFT-LEFT-CLICK" "+:tow_cargo_mb";
+
            gNcargoNo = {atomIndex=gNcargoIdx}.atomno
}
+
        }
 +
        else if (gCcargoIdx >= 0) {
 +
 
 +
            var no = {atomIndex=aPidx}.atomno
  
# Bound to ALT-LEFT-CLICK by plico_tug or called by plicotoab.toabCargoMB
+
            # If pick is nWard of it
function tug_cargo_mb() {
+
            if (no < {atomIndex=gCcargoIdx}.atomno) {
  
    # If O or movable side chain atom picked
+
                # If exists, clear its highlight
    if (({atomIndex=_atomPicked}.atomName = "O")
+
                if (gNcargoIdx != gCcargoIdx) {
        or (is_moveable_sc( _atomPicked))) {
+
                    select {atomIndex=gNcargoIdx}
        if (gSCidx >= 0) {
+
                    halo off
            draw gSCcircle DELETE
+
                }
        }
+
 
        if (gSCidx == _atomPicked) {
+
                # Set new nWard cargo and highlight it
             gSCidx = -1
+
                gNcargoIdx = get_nm_idx(aPidx)
 +
                gNcargoNo = {atomIndex=gNcargoIdx}.atomno
 +
            }
 +
 
 +
            # Else cWard
 +
            else {
 +
 
 +
                # Clear its old highlight
 +
                select {atomIndex=gCcargoIdx}
 +
                if (gNcargoIdx != gCcargoIdx) {
 +
                    halo off
 +
                }
 +
 
 +
                # Set new cWard cargo and highlight
 +
                gCcargoIdx = get_cp_idx(aPidx)
 +
                gCcargoNo = {atomIndex=gCcargoIdx}.atomno
 +
             }
 
         }
 
         }
 +
 +
        # Else no cWard cargo
 
         else {
 
         else {
             gSCidx = _atomPicked
+
 
             gSCpt = {atomIndex=gSCidx}.xyz
+
            # Set new cWard cargo and highlight
             draw gSCcircle CIRCLE {atomIndex=gSCidx} MESH NOFILL
+
             gCcargoIdx = get_cp_idx(aPidx)
 +
             gCcargoNo = {atomIndex=gCcargoIdx}.atomno
 +
            gNcargoIdx = get_nm_idx(gCcargoIdx)
 +
             gNcargoNo = {atomIndex=gNcargoIdx}.atomno
 
         }
 
         }
    }
+
 
    else {
+
        # If any anchor now inside cargo cluster, kill it
         if ({atomIndex=_atomPicked}.chain != gChain) {
+
         if ({atomIndex=gCanchorIdx}.atomno <= {atomIndex=gCcargoIdx}.atomno) {
            if (gTow) {
 
                select {chain=gChain}
 
                color {selected} @gScheme
 
            }
 
            gChain = {atomIndex=_atomPicked}.chain
 
            select ({atomIndex=gCcargoIdx} or {atomIndex=gNcargoIdx}
 
                or {atomIndex=gCanchorIdx} or {atomIndex=gNanchorIdx})
 
            halo off
 
            gCcargoIdx = -1
 
            gNcargoIdx = -1
 
 
             gCanchorIdx = -1
 
             gCanchorIdx = -1
 +
            gCanchorNo = gMaxNo + 1
 +
        }
 +
        if ({atomIndex=gNanchorIdx}.atomno >= {atomIndex=gNcargoIdx}.atomno) {
 
             gNanchorIdx = -1
 
             gNanchorIdx = -1
        }
 
        gTow = FALSE
 
        gMinNo = {chain=gChain}.atomno.min
 
        gMaxNo = {chain=gChain}.atomno.max
 
        if (gNanchorIdx < 0) {
 
 
             gNanchorNo = gMinNo - 1
 
             gNanchorNo = gMinNo - 1
 
         }
 
         }
        if (gCanchorIdx < 0) {
 
            gCanchorNo = gMaxNo + 1
 
        }
 
        var aPidx = get_sc_bb_idx( _atomPicked, gChain)
 
  
         gSCidx = -1
+
         # Highlight cargo cluster
         draw gSCcircle DELETE
+
        select_nward_idx(gCcargoIdx, gNcargoIdx)
 +
        gCargoSet = {selected}
 +
        set_colors()
 +
 
 +
        # Collect the rotor sets
 +
         collect_rotors()
  
         # If existing cWard cargo picked
+
         # Get moving atoms set
         if (gCcargoIdx == aPidx) {
+
         gMovingSet = {((atomno < gCanchorNo) and (atomno > gNanchorNo)
 +
            and (chain=gChain) and thisModel)}
 +
    }
  
            # Clear the highlight
+
    # Enable dragging
            select {atomIndex=gCcargoIdx}
+
    if (gToab) {
            halo off
+
        to_ab_enable_drag()
 +
    }
 +
    else {
 +
        tug_enable_drag()
 +
    }
  
            # If nWard cargo exists, mark it as the cWard cargo
+
    select {gCargoSet}
            if (gNcargoIdx != gCcargoIdx) {
+
}
                gCcargoIdx = get_cp_idx(gNcargoIdx)
 
                gCcargoNo = {atomIndex=gCcargoIdx}.atomno
 
            }
 
            else {
 
                gCcargoIdx = -1
 
                gNcargoIdx = -1
 
            }
 
        }
 
        else if (gNcargoIdx == aPidx) {
 
            select {atomIndex=gNcargoIdx}
 
            halo off
 
            gNcargoIdx = get_nm_idx(gCcargoIdx)
 
            gNcargoNo = {atomIndex=gNcargoIdx}.atomno
 
        }
 
        else if (gCcargoIdx >= 0) {
 
  
            var no = {atomIndex=aPidx}.atomno
+
function tug_undo_mb() {
 +
    if (prompt("Undo", "Yes|No", true) == "Yes") {
 +
        restore state gState
 +
    }
 +
}
  
            # If pick is nWard of it
+
# Top level of Tug
            if (no < {atomIndex=gCcargoIdx}.atomno) {
+
function plico_tug() {
  
                # If exists, clear its highlight
+
    # Load common functions if not already
                if (gNcargoIdx != gCcargoIdx) {
+
    if (kCommon < 7) {
                    select {atomIndex=gNcargoIdx}
+
        script $SCRIPT_PATH$plicoCommon.spt
                    halo off
+
        if (kCommon < 7) {
                }
+
            prompt ("A newer version of plicoCommon.SPT is required")
 +
            quit
 +
        }
 +
    }
  
                # Set new nWard cargo and highlight it
+
    gPlico = "TUG"
                gNcargoIdx = get_nm_idx(aPidx)
+
    plico_prelim(true, true)
                gNcargoNo = {atomIndex=gNcargoIdx}.atomno
+
   
            }
+
    gBondPicking = bondPicking
 +
    set bondPicking true
 +
    set PickCallback "jmolscript:tug_pick_cb"
  
            # Else cWard
+
    gEcho = ("_________TUG_________|ALT-CLICK=mark block|SHIFT-CLICK=mark chain" +
            else {
+
        "|CLICK bond=freeze|ALT-DOUBLE-CLICK=undo|SHIFT-DOUBLE-CLICK=exit")
 +
    echo @gEcho
 +
    gCrotors = array()
 +
    gNrotors = array()
 +
    clear_atom_idxs()
 +
    gToab = false
  
                # Clear its old highlight
+
    bind "ALT-LEFT-CLICK" "_pickAtom";
                select {atomIndex=gCcargoIdx}
+
    bind "ALT-LEFT-CLICK" "+:tug_cargo_mb";
                if (gNcargoIdx != gCcargoIdx) {
+
    bind "SHIFT-LEFT-CLICK" "_pickAtom";
                    halo off
+
    bind "SHIFT-LEFT-CLICK" "+:tow_cargo_mb";
                }
+
    bind "ALT-LEFT-DOUBLE" "tug_undo_mb";
 +
    bind "SHIFT-DOUBLE" "tug_exit(true)";
 +
    bind "LEFT-CLICK" "+:plico_menu_toggle";
 +
}
  
                # Set new cWard cargo and highlight
+
# Bound to DOUBLE by plico_tug
                gCcargoIdx = get_cp_idx(aPidx)
+
function tug_exit() {
                gCcargoNo = {atomIndex=gCcargoIdx}.atomno
+
    if (plico_exit()) {
            }
+
        set bondPicking gBondPicking
         }
+
        set PickCallback NONE
 
+
        select all
         # Else no cWard cargo
+
        color bonds none
         else {
+
          
 
+
        reset kTug
            # Set new cWard cargo and highlight
+
         reset gCanchorIdx 
            gCcargoIdx = get_cp_idx(aPidx)
+
         reset gCanchorNo 
            gCcargoNo = {atomIndex=gCcargoIdx}.atomno
+
        reset gPlico     
            gNcargoIdx = get_nm_idx(gCcargoIdx)
+
        reset gNanchorIdx 
            gNcargoNo = {atomIndex=gNcargoIdx}.atomno
+
        reset gNanchorNo 
 
+
        reset gCcargoIdx  
            # Set default cWard anchor at cWard N
+
        reset gNcargoIdx  
            var iNo = gMaxNo
+
        reset gCcargoNo   
            for (; iNo > 0; iNo--) {
+
        reset gNcargoNo  
                if ({(atomno=iNo) and (chain=gChain)}.atomName == "N") {
+
        reset gDestAtomIdx
                    break;
+
        reset g1pivotIdx 
                }
+
        reset g2pivotIdx 
            }
+
        reset gSelSaves   
            gCanchorIdx = {(atomno=iNo) and (chain=gChain)}.atomIndex
+
        reset gCrotors   
            gCanchorNo = {atomIndex=gCanchorIdx}.atomno
+
        reset gNrotors   
         }
+
        reset gOkCollide 
 
+
        reset gChain     
         # If any anchor now inside cargo cluster, kill it
+
        reset gMinNo     
         if ({atomIndex=gCanchorIdx}.atomno <= {atomIndex=gCcargoIdx}.atomno) {
+
        reset gMaxNo      
            gCanchorIdx = -1
+
        reset gCargoSet   
            gCanchorNo = gMaxNo + 1
+
        reset gMovingSet 
         }
+
        reset gSCidx     
         if ({atomIndex=gNanchorIdx}.atomno >= {atomIndex=gNcargoIdx}.atomno) {
+
        reset gSCcircle   
            gNanchorIdx = -1
+
        reset gSCpt       
            gNanchorNo = gMinNo - 1
+
        reset gTargetPt   
         }
+
        reset gNewDrag   
 
+
        reset gTow       
         # Highlight cargo cluster
+
        reset g1dynamicIdx
         select_nward_idx(gCcargoIdx, gNcargoIdx)
+
        reset g2dynamicIdx
         gCargoSet = {selected}
+
        reset gSCcheck   
         set_colors()
+
        reset gBondPicking
 
+
        reset gFreeze     
         # Collect the rotor sets
+
        reset gToab       
         collect_rotors()
+
        reset function "get_cp_idx"
 
+
        reset function "get_cm_no"
         # Get moving atoms set
+
        reset function "get_nm_idx"
         gMovingSet = {((atomno < gCanchorNo) and (atomno > gNanchorNo)
+
        reset function "get_np_no"
            and (chain=gChain))}
+
        reset function "get_cb_idx"
    }
+
        reset function "get_o_idx"
 
+
        reset function "get_nward_bb_idx"
    # Enable dragging
+
        reset function "get_cward_bb_idx"
    if (gToab) {
+
        reset function "get_sc_set"
         toabEnableDrag()
+
        reset function "get_sc_bb_idx"
    }
+
        reset function "is_bb_idx"
    else {
+
        reset function "is_sc_idx"
         tug_enable_drag()
+
        reset function "select_add_sc"
    }
+
         reset function "handle_collisions"
   
+
        reset function "tug_track_idx"
    select {gCargoSet}
+
         reset function "do_counter_rotate"
}
+
         reset function "counter_rotate"
 +
        reset function "counter_rotate_2"
 +
        reset function "repair_proline"
 +
         reset function "repair_sc"
 +
         reset function "tug_track_c"
 +
        reset function "tug_track_n"
 +
        reset function "translate_selected_record"
 +
         reset function "rotate_selected_record"
 +
        reset function "collect_sc_rotors"
 +
         reset function "drag_sc"
 +
         reset function "fix_sc_collision_2"
 +
         reset function "is_moveable_sc"
 +
         reset function "is_rotor_avail"
 +
        reset function "xcollect_bb_rotors"
 +
         reset function "collect_bb_rotors"
 +
         reset function "collect_rotors"
 +
        reset function "tug_sc"
 +
         reset function "set_colors"
 +
         reset function "clear_atom_idxs"
 +
        reset function "timed_out"
 +
        reset function "record_drag"
 +
        reset function "tug_pick_cb"
 +
        reset function "tug_drag_done_mb"
 +
        reset function "tug_drag_2_mb"
 +
         reset function "tug_drag_mb"
 +
        reset function "tug_mark_mb"
 +
        reset function "tug_anchor_mb"
 +
         reset function "tug_enable_drag"
 +
        reset function "tug_dest_atom_mb"
 +
        reset function "tug_pivot_mb"
 +
        reset function "tow_cargo_mb"
 +
        reset function "tug_cargo_mb"
 +
        reset function "tug_undo_mb"
 +
        reset function "plico_tug"
  
# Top level of Tug
 
function plico_tug() {
 
  
    # Load common functions if not already
 
    if (kCommon < 2) {
 
        script $SCRIPT_PATH$plicoCommon.spt
 
        if (kCommon < 2) {
 
            prompt ("A newer version of plicoCommon.SPT is required")
 
            quit
 
        }
 
 
     }
 
     }
   
 
    gPlico = "TUG"
 
    plico_prelim()
 
    gBondPicking = bondPicking
 
    set bondPicking TRUE
 
    set PickCallback "jmolscript:tug_pick_cb"
 
           
 
    gEcho = ("_________TUG_________|ALT-CLICK=mark block|SHIFT-CLICK=mark chain" +
 
        "|CLICK bond=freeze|DOUBLE-CLICK=exit")
 
    echo @gEcho
 
    gCrotors = array()
 
    gNrotors = array()
 
    clear_atom_idxs()
 
 
    bind "ALT-LEFT-CLICK" "_pickAtom";
 
    bind "ALT-LEFT-CLICK" "+:tug_cargo_mb";
 
    bind "SHIFT-LEFT-CLICK" "_pickAtom";
 
    bind "SHIFT-LEFT-CLICK" "+:tow_cargo_mb";
 
    bind "DOUBLE" "tug_exit";
 
}
 
 
# Bound to DOUBLE by plico_tug
 
function tug_exit() {
 
    set bondPicking gBondPicking
 
    set PickCallback NONE
 
    plico_exit()
 
 
}
 
}
  
# End of TUG.SPT</pre>
+
# End of TUG.SPT
 +
</pre>

Latest revision as of 17:15, 12 April 2016

Tug allows the user to pull or push by mouse actions to move or rotate one part of a polypeptide against the rest by rotation on its psi and phi bonds with collision detection and restriction. It also allows the user to move an entire chain to nest against another chain. A full description of its capabilities can be found here.

Tug is a member of the Plico suite of protein folding tools described in User:Remig/plico . It may be installed and accessed as a macro with the file:

Title=PLICO Tug
Script=script <path to your scripts directory>/tug.spt;plico_tug

saved as plicotug.macro in your .jmol/macros directory as described in Macro.

Copy and paste the following into a text editor and save in your scripts directory as tug.spt.

#   tug - Jmol script by Ron Mignery
#   v1.20 beta    4/12/2016 -axis is now a reserved word
#
#   Translate or rotate a stretch of a polypeptide against itself
#    or against other chains by mouse actions
#
kTug = 3
gCanchorIdx = -1
gCanchorNo = -1
gPlico = "TUG"
gNanchorIdx = -1
gNanchorNo = -1
gCcargoIdx = -1
gNcargoIdx = -1
gCcargoNo = -1
gNcargoNo = -1
gDestAtomIdx = -1
g1pivotIdx = -1
g2pivotIdx = -1
gSelSaves = ({})
gCrotors = array()
gNrotors = array()
gOkCollide = ({})
gChain = ""
gMinNo = 1
gMaxNo = 9999
gCargoSet = ({})
gMovingSet = ({})
gBusy = false
gSCidx = -1
gSCcircle = -1
gSCpt = {0 0 0}
gTargetPt = {0 0 0}
gNewDrag = false
gTow = false
g1dynamicIdx = -1
g2dynamicIdx = -1
gSCcheck = true
gBondPicking = false
gFreeze = array()
gToab = false


function get_cp_idx (idx) {
    var no = {atomIndex=idx}.atomno
    while ((no < gMaxNo) and ({(atomno=no) and (chain=gChain)
        and thisModel}.atomName != "C")) {
        no++
    }
    return ({(atomno=no) and (chain=gChain) and thisModel}.atomIndex)
}

function get_cm_no (iNo) {
    while ((iNo > 0) and ({(atomno=iNo) and (chain=gChain)
        and thisModel}.atomName != "C")) {
        iNo--
    }
    return iNo
}

function get_nm_idx (idx) {
    var no = {atomIndex=idx}.atomno
    while ((no > 0) and ({(atomno=no) and (chain=gChain)
        and thisModel}.atomName != "N")) {
        no--
    }
    return ({(atomno=no) and (chain=gChain) and thisModel}.atomIndex)
}

function get_np_no (iNo) {
    while ((iNo < gMaxNo) and ({(atomno=iNo) and (chain=gChain)
        and thisModel}.atomName != "N")) {
        iNo++
    }
    return iNo
}

function get_cb_idx (BBidx) {
    var no = {atomIndex=BBidx}.atomno
    var i = 1
    for (; i < 5; i++) {
        if ({(atomno=@{no+i}) and (chain=gChain)
            and thisModel}.atomName == "CB") {
            break
        }
    }
    return {(atomno=@{no+i}) and (chain=gChain) and thisModel}.atomIndex
}

function get_o_idx (BBidx) {
    var no = {atomIndex=BBidx}.atomno
    var i = 1
    for (; i < 4; i++) {
        if ({(atomno=@{no+i}) and (chain=gChain)
            and thisModel}.atomName == "O") {
            break
        }
    }
    return {(atomno=@{no+i}) and (chain=gChain) and thisModel}.atomIndex
}

function get_nward_bb_idx (idx, iChain) {
    var no = {atomIndex=idx}.atomno - 1
    for (; no >= 0; no--) {
        var atomName = {(atomno=no) and (chain=iChain)
            and thisModel}.atomName
        if ((atomName = "N") or (atomName = "C") or (atomName = "CA")) {
            break
        }
    }
    return ((no >= 0) ? ({(atomno=no) and (chain=iChain)
        and thisModel}.atomIndex) : -1)
}

function get_cward_bb_idx (idx, iChain) {
    var no = {atomIndex=idx}.atomno + 1
    for (; no < gMaxNo; no++) {
        var atomName = {(atomno=no) and (chain=iChain)
            and thisModel}.atomName
        if ((atomName = "N") or (atomName = "C") or (atomName = "CA")) {
            break
        }
    }
    return ((no >= 0) ? ({(atomno=no) and (chain=iChain)
        and thisModel}.atomIndex) : -1)
}

function get_sc_set (scIdx, iChain) {
    var scSet = ({})
    var idx = get_sc_bb_idx(scIdx, iChain)
    var iNo = {atomIndex=idx}.atomno + 3

    for (var i = 1; i < 20; i++) {
        idx = {(atomno=@{iNo+i}) and (chain=iChain)
            and thisModel}.atomIndex
        if (is_bb_idx(idx)) {
            break
        }
        scSet = scSet or {atomIndex=idx}
    }
    return scSet
}

function get_sc_bb_idx (idx, iChain) {
    var no = {atomIndex=idx}.atomno
    for (; no > 0; no--) {
        if ({(atomno=no) and (chain=iChain)
            and thisModel}.atomName == "CA") {
            break
        }
        else if ({(atomno=no) and (chain=iChain)
            and thisModel}.atomName == "C") {
            break
        }
        else if ({(atomno=no) and (chain=iChain)
            and thisModel}.atomName == "N") {
            break
        }
        else if ({(atomno=no) and (chain=iChain)
            and thisModel}.atomName == "CB") {
            no -= 3
            break
        }
    }
    return {(atomno=no) and (chain=iChain) and thisModel}.atomIndex
}

function is_bb_idx(aIdx) {
    var ret = false
    switch({atomIndex=aIdx}.atomName) {
    case "N":
    case "CA":
    case "C":
        ret = true
        break
    }
    return ret
}

function is_sc_idx(aIdx) {

    var ret = false
    if (not is_bb_idx(aIDx)) {

        ret = true
        switch({atomIndex=aIdx}.atomName) {
        case "O":
        case "CB":
            ret = false
            break
        }
    }
    return ret
}

function select_add_sc(fromIdx) {
    var iNo = {atomIndex=fromIdx}.atomno
    var iChain = {atomIndex=fromIdx}.chain
    select none
    while ({(atomno=iNo) and (chain=iChain)
        and thisModel and sidechain}) {
        var a = {(atomno=iNo) and (chain=iChain)and thisModel}
        a.selected = true
        iNo++
    }
}

# Resolve collisions on selection
function handle_collisions( targetIdx) {

    # For all selected atoms
    for (var iNo = {selected}.min.atomno; iNo <= {selected}.max.atomno; iNo++) {
        var idx = {(atomno=iNo) and (chain=gchain)
            and thisModel}.atomIndex
        if ({atomindex=idx}.selected) {

            # Collect local colliders
            var lcAtoms = (within(kCtolerance, false, {atomIndex=idx})
                and not {atomIndex=idx}
                and not {gOkCollide}
                and not connected({atomIndex=idx}))
            if (lcAtoms) {
                # Ignore kinked BB
                try {
                    if (is_bb_idx(idx) and (angle(
                        {atomIndex=@{get_cward_bb_idx(idx, gChain)}}, {atomIndex=idx},
                        {atomIndex=@{get_nward_bb_idx(idx, gChain)}}) < 100.0)) {
                        continue
                    }
                }
                catch {
                }

                # For all local colliders
                for (var c = 1; c <= lcAtoms.size; c++ ) {
                    var cidx = lcAtoms[c].atomIndex

                    # If it is with water, delete it
                    if (lcAtoms[c].group = "HOH") {
                        delete {atomIndex=cidx}
                    }

                    # else if it is with side chain not proline, fix it
                    else if (is_sc_idx(cidx) and ({atomIndex=cidx}.group != "PRO")) {
                        fix_sc_collision_2(cidx)
                        
                        # If not fixed, exit fail
                        if (not gOk2) {
                            return # early exit (break n jmol bug)
                        }
                    }

                    # else if it is itself a side chain not proline, fix it
                    else if (is_sc_idx(idx) and ({atomIndex=idx}.group != "PRO")) {
                        fix_sc_collision_2(idx)

                        # If not fixed, exit fail
                        if (not gOk2) {
                            return # early exit (break n jmol bug)
                        }
                    }

                    # Else if it is with O, counter-rotate
                    else if (lcAtoms[c].atomName = "O") {
                        counter_rotate_2(lcAtoms[c].atomIndex,
                            {atomIndex=idx}.xyz, targetIdx, false)

                        # If not fixed, exit fail
                        if (not gOk2) {
                            return # early exit (break n jmol bug)
                        }
                    }

                    # Else if it is itself O, counter-rotate
                    else if ({atomIndex=idx}.atomName = "O") {
                        counter_rotate_2(idx, lcAtoms[c].xyz, targetIdx, false)

                        # If not fixed, exit fail
                        if (not gOk2) {
                            return # early exit (break n jmol bug)
                        }
                    }

                    else {    # Else not fixed, exit fail
                        gOk2 = false
                        return # early exit (break n jmol bug)
                    }
                } # endfor
            }
        }
    } # endfor iNo
}

# Rotate rotor set to move target atom to its proper place
function tug_track_idx(targetIdx, targetPt, nWard, cDetect) {
    gOK = false
    var pt = targetPt
    var dist = distance(pt, {atomIndex=targetIdx}.xyz)

    var rotors = (nWard ? gNrotors : gCrotors)

    # For a number of passes
    for (var pass1 = 0; pass1 < 20; pass1++) {
        var blocked = ({})
        for (var pass2 = 0; pass2 < (rotors.size/4); pass2++) {

            var v1 = {atomIndex=targetIdx}.xyz - pt

            # Find the most orthgonal unused rotor
            var imax = 0
            var smax = 0.5
            for (var i = 1; i < rotors.size; i += 4) {
                var i2 = rotors[i+1]
                var i3 = rotors[i+2]
                var i4 = rotors[i+3]
                if ((i2 != targetIdx) and (i3 != targetIdx) and (i4 != targetIdx)) {
                    if ({blocked and {atomIndex=i2}}.count == 0) {
                        var v2 = {atomIndex=i3}.xyz - {atomIndex=i2}.xyz

                        var s = sin(abs(angle(v1, {0 0 0}, v2)))
                        if (s > smax) {
                            smax = s
                            imax = i
                        }
                    }
                }
            }

            # If no more rotors, break to next full try
            if (imax == 0) {
               break
            }
            var i1 = rotors[imax+0]
            var i2 = rotors[imax+1]
            var i3 = rotors[imax+2]
            var i4 = rotors[imax+3]

            # Get dihedral of rotor with target point
            var dt = angle({atomIndex=targetIdx}, {atomIndex=i2}, {atomIndex=i3}, pt)
            var dh = angle({atomIndex=i1}, {atomIndex=i2}, {atomIndex=i3}, {atomIndex=i4})
            if (abs(dh).type == "string") {
                dh = -50
            }
            var psi = dh + dt
            var phi = dh + dt

            # Compute resultant psi and phi
            #  and select from target atom to first half of rotor
            var movePt = false
            if (nWard) {
                if ({atomIndex=i2}.atomName="CA") {
                    psi = angle({atomIndex=@{get_cward_bb_idx(i1, gChain)}}, {atomIndex=i1},
                        {atomIndex=i2}, {atomIndex=i3}) + dt
                }
                else {
                    phi = angle({atomIndex=i1}, {atomIndex=i2},
                        {atomIndex=i3}, {atomIndex=@{get_nward_bb_idx(i3, gChain)}}) + dt
                }

                if ({atomIndex=i2}.atomno > {atomIndex=targetIdx}.atomno) {
                    movePt = true
                    select_nward_idx(i3, get_cward_bb_idx(targetIdx, gChain))
                    {atomIndex=targetIdx}.selected = true
                }
                else {
                    select_cward_idx(i2, targetIdx)
                }
            }
            else {
                if (({atomIndex=i2}.atomName="CA")) {
                    phi = angle({atomIndex=@{get_nward_bb_idx(i1, gChain)}}, {atomIndex=i1},
                        {atomIndex=i2}, {atomIndex=i3}) + dt
                }
                else {
                    psi = angle({atomIndex=i2}, {atomIndex=i3},
                        {atomIndex=i4}, {atomIndex=@{get_cward_bb_idx(i4, gChain)}}) + dt
                }

                if ({atomIndex=i2}.atomno < {atomIndex=targetIdx}.atomno) {
                    movePt = true
                    select_cward_idx(i3, get_nward_bb_idx(targetIdx, gChain))
                    {atomIndex=targetIdx}.selected = true
                }
                else {
                    select_nward_idx(i2, targetIdx)
                }
            }

            # Relax rules if desperate
            if (pass1 > 10) {
                phi = -50
            }

            # If rotation within ramachandran limits
            if ((abs(dt) >= 0.1) and
                (({atomIndex=i2}.group=="GLY") or (phi < 0))) {

                # If moving target point, put the target atom there
                var cp = {atomIndex=targetIdx}.xyz
                if (movePt) {
                    dt = -dt
                    {atomIndex=targetIdx}.xyz = pt
                }

                # Rotate to minimize vector ====================
                rotateSelected {atomIndex=i2} {atomIndex=i3} @dt

                # If collision checking
                if (cDetect) {

                    # If collision, back off by eighths
                    var wasCollision = false
                    for (var ci = 0; ci < 4; ci++) {
                        if (ci < 3) {
                            dt /= 2
                        }
                        handle_collisions( targetIdx)
                        if (not gOk2) {
                            wasCollision = true
                            rotateSelected {atomIndex=i2} {atomIndex=i3} @{-dt}
                        }
                        else if (wasCollision) {
                            if (ci <3) {
                                rotateSelected {atomIndex=i2} {atomIndex=i3} @{dt}
                            }
                        }
                        else {
                            break
                        }

                        if (dt < 0.01) {
                            break
                        }
                    } # endfor
                }

                # If moving target point, put the target atom back
                if (movePt) {
                    pt = {atomIndex=targetIdx}.xyz
                    {atomIndex=targetIdx}.xyz = cp
                }

            }

            # If close enough, stop
            if (distance(pt, {atomIndex=targetIdx}) < kDtolerance) {
                gOK = true
                gTargetPt = pt
                break
            }

            # Block rotor
            blocked |= {atomIndex=i2}

        }   # endfor num rotors passes

        if (gOK) {
            break
        }
    }   # endfor 20 passes
}

# Counter rotate bonds on either side of a BB O
function do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, nWard) {

    # Rotate psi
    {atomIndex=nIdx}.selected = nWard
    {atomIndex=cIdx}.selected = nWard
    {atomIndex=oIdx}.selected = nward
    rotateSelected {atomIndex=caPsiIdx} {atomIndex=cIdx} @{dir}

    # Counter-rotate phi
    {atomIndex=nIdx}.selected = not nWard
    {atomIndex=cIdx}.selected = not nWard
    {atomIndex=oIdx}.selected = not nward
    rotateSelected {atomIndex=nIdx} {atomIndex=caPhiIdx} @{-dir}
}

function counter_rotate(oIdx, dir, nWard) {

    var iChain = {atomIndex=oIdx}.chain
    var selsave = {selected}
    var cIdx = get_sc_bb_idx(oIdx, iChain)
    var nIdx = get_cward_bb_idx(cIdx, iChain)
    var caPhiIdx = get_cward_bb_idx(nIdx, iChain)
    var caPsiIdx = get_nward_bb_idx(cIdx, iChain)

    if (nWard) {
        var nNo = {(chain=iChain) and thisModel}.atomno.min
        select_nward_idx(caPsiIdx, {(atomno=nNo) and (chain=iChain)
            and thisModel}.atomIndex)
    }
    else {
        var cNo = {(chain=iChain) and thisModel}.atomno.max
        select_cward_idx(caPhiIdx, {(atomno=cNo) and (chain=iChain)
            and thisModel}.atomIndex)
    }

    # Counter-rotate
    do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, not nWard)
    select selsave
}

function counter_rotate_2(oIdx, toPt, terminalIdx, oDrag) {

    var iChain = {atomIndex=oIdx}.chain
    var selsave = {selected}
    var gOk2 = true
    var cIdx = get_sc_bb_idx(oIdx, iChain)
    var nIdx = get_cward_bb_idx(cIdx, iChain)
    var caPhiIdx = get_cward_bb_idx(nIdx, iChain)
    var caPsiIdx = get_nward_bb_idx(cIdx, iChain)

    var nTward = ({atomIndex=oIdx}.atomno < {atomIndex=terminalIdx}.atomno)
    if (nTward) {
        select_cward_idx(cIdx, terminalIdx)
    }
    else {
        select_nward_idx(nIdx, terminalIdx)
    }

    # Until all collisions cancelled
    var dir = 5
    var ang = angle(toPt, {atomIndex=oIdx}, {atomIndex=cIdx})
    var tcount = 0
    while (oDrag or (within(kCtolerance, false, {atomIndex=oIdx})
            and not {atomIndex=oIdx} and not connected({atomIndex=oIdx})
            and not {gOkCollide} > 0)) {

        # Counter-rotate
        do_counter_rotate(caPhiIdx, nIdx, cIdx, oIdx, caPsiIdx, dir, nTward)
        var newang = angle(toPt, {atomIndex=oIdx}, {atomIndex=cIdx})

        # If wrong direction once, undo and reverse
        if (newang > ang) {
            do_counter_rotate(caPhiIDx, nIdx, cIdx, oIdx, caPsiIdx, -dir, nTward)

            # If first time, continue in opposite direction
            dir *= -1
            if (dir < 0) {
                continue
            }
        }

        if (oDrag) {
            break
        }

        # If no go, undo and exit
        tcount++
        if (tcount > (360/abs(dir))) {
            gOk2 = false
            break
        }

    } # endwhile
    select selsave
}

# Repair proline
function repair_proline(BBidx) {
    var cbidx = get_cb_idx(BBidx)
    var cbno = {atomIndex=cbidx}.atomno
    var cgidx = {(atomno=@{cbno+1}) and (chain=gChain)
        and thisModel}.atomIndex
    var cdidx = {(atomno=@{cbno+2}) and (chain=gChain)
        and thisModel}.atomIndex
    var caidx = {(atomno=@{cbno-3}) and (chain=gChain)
        and thisModel}.atomIndex
    var nidx = {(atomno=@{cbno-4}) and (chain=gChain)
        and thisModel}.atomIndex

    select {atomIndex=cbidx}
    set_angle_idx(nidx, caidx, cbidx, 109.5)

    select {atomIndex=cdidx}
    set_distance_idx(nidx, cdidx, 1.47)
    set_angle_idx(caidx, nidx, cdidx, 102.7)
    set_dihedral_idx(cbidx, caidx, nidx, cdidx, 16.2)

    select {atomIndex=cgidx}
    set_distance_idx(cdidx, cgidx, 1.51)
    set_angle_idx(nidx, cdidx, cgidx, 106.4)
    set_dihedral_idx(caidx, nidx, cdidx, cgidx, 16.2)
}

# Repair side chain
function repair_sc(targetIdx, nWard) {

    var idx = (nWard ? get_cward_bb_idx(targetIdx, gChain) : get_nward_bb_idx(targetIdx, gChain))

    if (({atomIndex=targetIdx}.atomName == "CA")
        and ({atomIndex=targetIdx}.group != "GLY")) {
        var cbidx = get_cb_idx(targetIdx)
        select none
        select_add_sc(cbidx)
        set_angle_idx(idx, targetIdx, cbidx, 110.0)
        set_distance_idx(targetIdx, cbidx, 1.5)
        if ({atomIndex=targetIdx}.group != "PRO") {
            var colliders = (within(kCtolerance, false, {selected})
                and not {atomIndex=targetIdx} and not {selected})
            if (colliders) {
                if ({atomIndex=targetIdx}.group != "ALA") {
                    fix_sc_collision_2(cbidx)
                }
            }
        }
        else {
            if (nWard) {
            }
            else {
                set_dihedral_idx(get_nward_bb_idx(idx, gChain), idx, targetIdx, cbidx, 174.2)
            }
        }
    }

    else if ({atomIndex=targetIdx}.atomName == "C") {
        var oidx = get_o_idx(targetIdx)
        select {atomIndex=oidx}
        set_angle_idx(idx, targetIdx, oidx, 120.0)
        set_distance_idx(targetIdx, oidx, 1.21)
        if (nWard) {
            set_dihedral_idx(get_cward_bb_idx(idx, gChain), idx, targetIdx, oidx, 0.0)
        }
        if ({atomIndex=idx}.group == "PRO") {
            repair_proline(idx)
            var dNo = {atomIndex=targetIdx}.atomno + 4
            var dIdx = {(atomno=dNO) and (chain=gChain)
                and thisModel}.atomIndex
            var colliders = (within(kCtolerance, false, {atomIndex=dIdx})
                and not connected({atomIndex=dIdx})
                and not {atomIndex=dIdx})
            for (var i = 1; i <= colliders.size; i++) {
                if (colliders[i].atomName == "O") {
                    counter_rotate_2(colliders[i].atomIndex,
                        {atomIndex=dIdx}.xyz, targetIdx, false)
                }
            }
        }
    }
}

# Rebuild Cward rotors set
function tug_track_c() {

    # For all bb atoms cWard of cargo
    var targetIdx = gCcargoIdx
    var okCount = 0

    # Allow collisions with cargo
    gOkCollide = gCargoSet
    var tcount = 0
    while (targetIdx != gNanchorIdx) {

        # Step to next atom
        targetIdx = get_cward_bb_idx(targetIdx, gChain)
        if (targetIdx < 0) {
            break
        }

        # No collision with cargo allowed after two atoms placed
        if (tcount == 2) {
           gOkCollide = ({})
        }
        tcount++

        # Compute targets desired coords
        try {
            var c1idx = get_cward_bb_idx(targetIdx, gChain)
            var n1idx = get_nward_bb_idx(targetIdx, gChain )
            var n2idx = get_nward_bb_idx(n1Idx, gChain)
            var n3idx = get_nward_bb_idx(n2Idx, gChain)
            var pt = {0 0 0}
            if ({atomIndex=targetIdx}.atomName == "N") {
                var oidx = get_o_idx(n1idx)
                select {atomIndex=oidx}
    
                # Desired target location is trigonal O
                set_distance_idx(n1idx, oidx, 1.5)
                pt = get_trigonal_idx(n2idx, n1idx, oidx, 1.37)
                set_distance_idx(n1idx, oidx, 1.21)
            }
            else if (({atomIndex=targetIdx}.atomName == "C")
                and ({atomIndex=targetIdx}.group != "GLY")) {
    
                # Desired target location is tetragonal CB
                var cbidx = get_cb_idx(n1idx)
                pt = get_tet_idx(n2idx, n1idx, cbidx, 1.5)
            }
            else { # CA (or GLY C)
    
                # Save current target coords
                var cp = {atomIndex=targetIdx}.xyz
    
                # Set target atom at desired distance and angle
                select {atomIndex=targetIdx}
                set_distance_idx(n1idx, targetIdx, 1.5)
                set_angle_idx(n2idx, n1idx, targetIdx, 120.0)
                if ({atomIndex=targetIdx}.atomName == "CA") {
                    set_dihedral_idx(n3idx, n2idx, n1idx, targetIdx, 180)
                }
    
                # Record and restore target
                pt = {atomIndex=targetIdx}.xyz
                {atomIndex=targetIdx}.xyz = cp
            }
    
            # If target not at desired location
            if (distance(pt, {atomIndex=targetIdx}) > kDtolerance) {
                okCount = 0
                gTargetPt = pt
                var xcount = 0
                gOK = false
                while ((xcount < 20) and (not gOK)) {
    
                    # Rotate on cWard rotor set to move it there
                    tug_track_idx(targetIdx, pt, false, false)
                    xcount++
                }
            }
            else {
                gOK = true
                okCount++
            }
        }
        catch {
        }

        # If successful
        if (gOK == true) {

            # Adust any side atoms
            repair_sc(targetIdx, false)
        }

        # Else fail
        else {
            break
        }

        # If no movement in 4 tries, we are done
        if (okCount > 3) {
            break
        }
    } # endwhile (targetIdx != gCanchorIdx) {
}

# Rebuild Nward rotors set
function tug_track_n() {

    gOK = true

    # For all bb atoms nWard of cargo
    var targetIdx = gNcargoIdx
    var okCount = 0

    # Allow collisions with cargo
    gOkCollide = gCargoSet
    var tcount = 0
    while (targetIdx != gNanchorIdx) {

        # Step to next atom
        targetIdx = get_nward_bb_idx(targetIdx, gChain)
        if (targetIdx < 0) {
            break
        }
        
        # No collision with cargo allowed after two atoms placed
        if (tcount == 2) {
           gOkCollide = ({})
        }
        tcount++

        # Compute targets desired coords
        var n1idx = get_nward_bb_idx(targetIdx, gChain)
        var c1idx = get_cward_bb_idx(targetIdx, gChain)
        var c2idx = get_cward_bb_idx(c1idx, gChain)
        var c3idx = get_cward_bb_idx(c2idx, gChain)
        var pt = {0 0 0}
        if ({atomIndex=targetIdx}.atomName == "CA") {

            # Desired target location is trigonal O
            var oidx = get_o_idx(c1idx)
            select {atomIndex=oidx}
            set_distance_idx(c1idx, oidx, 1.39)
            pt = get_trigonal_idx(c2idx, c1idx, oidx, 1.41)
            set_distance_idx(c1idx, oidx, 1.21)
        }
        else if (({atomIndex=targetIdx}.atomName == "N")
            and ({atomIndex=targetIdx}.group != "GLY")) {

            # Desired target location is r-tetragonal CB
            var cbidx = get_cb_idx(c1idx)
            pt = get_tet_idx(cbidx, c1idx, c2idx, 1.5)
        }
        else { # C

            # Save current target coords
            var cp = {atomIndex=targetIdx}.xyz

            # Set target atom at desired distance and angle
            select {atomIndex=targetIdx}
            set_distance_idx(c1idx, targetIdx, 1.37)
            set_angle_idx(c2idx, c1idx, targetIdx, 110.0)

            if ({atomIndex=targetIdx}.group == "PRO") {
                set_dihedral_idx(c3idx, c2idx, c1idx, targetIdx, -57.0)
            }

            # Record and restore target
            pt = {atomIndex=targetIdx}.xyz
            {atomIndex=targetIdx}.xyz = cp
        }

        # If target not at desired location
        if (distance(pt, {atomIndex=targetIdx}) > kDtolerance) {
            var okCount = 0
            gTargetPt = pt
            var xcount = 0
            gOK = false
            while ((xcount < 20) and (not gOK)) {

                # Rotate on nWard rotor set to move it there
                tug_track_idx(targetIdx, pt, true, false)
                xcount++
            }
        }
        else {
            gOK = true
            okCount++
        }

        # If sucessful
        if (gOK == true) {

            # Adust any side atoms
            repair_sc(targetIdx, true)
        }

        # Else fail
        else {
            break
        }

        # If no movement in 4 tries, we are done
        if (okCount > 3) {
            break
        }

    }   # endwhile (targetIdx != gNanchorIdx) {
}

# gPlicoRecord is maintained by the macro pilcoRecord
function translate_selected_record(pt) {
    if (gPlicoRecord != "") {
        plico_record(format("select %s;translateSelected %s;", {selected}, pt))
    }
    translateSelected @pt
}

# gPlicoRecord is maintained by the macro pilcoRecord
function rotate_selected_record(pivotIdx, caxis, a) {
    if (gPlicoRecord != "") {
        plico_record(format("select %s;", {selected}))
        plico_record(format("rotateSelected {atomIndex=%d} @%s @%s;",
            pivotIdx, caxis, a))
    }
    rotateSelected {atomIndex=pivotIdx} @caxis @a
}

function collect_sc_rotors(no, iChain) {
    var scBondIdxs = array()
    for (var iNo = no; iNo >= 0; iNo--) {
        var ile = 0
        switch ({(atomno=iNo) and (chain=iChain)
            and thisModel}.atomName) {
        case "CA" :
            return scBondIdxs # Early exit since break 1 appears broken
        case "CZ" :
            if ({(atomno=iNo) and (chain=iChain)
                and thisModel}.group == "TYR") {
                break
            }
        case "CE" :
            if ({(atomno=iNo) and (chain=iChain)
                and thisModel}.group == "MET") {
                break
            }
        case "CG1" :
            if ({(atomno=iNo) and (chain=iChain)
                and thisModel}.group == "VAL") {
                break
            }
            if ({(atomno=iNo) and (chain=iChain)
                and thisModel}.group == "ILE") {
                ile = 1
            }
        case "NE" :
        case "CD" :
        case "SD" :
        case "CG" :
        case "CB" :
            scBondIdxs += {(atomno=@{iNo+1+ile}) and (chain=iChain)
                and thisModel}.atomIndex
            scBondIdxs += {(atomno=@{iNo+0}) and (chain=iChain)
                and thisModel}.atomIndex
            if ({(atomno=iNo) and (chain=iChain)
                and thisModel}.atomName%2 == "CG") {
                scBondIdxs += {(atomno=@{iNo-1}) and (chain=iChain)
                    and thisModel}.atomIndex
                scBondIdxs += {(atomno=@{iNo-4}) and (chain=iChain)
                    and thisModel}.atomIndex
            }
            else if ({(atomno=iNo) and (chain=iChain)
                and thisModel}.atomName == "CB") {
                scBondIdxs += {(atomno=@{iNo-3}) and (chain=iChain)
                    and thisModel}.atomIndex
                scBondIdxs += {(atomno=@{iNo-4}) and (chain=iChain)
                    and thisModel}.atomIndex
            }
            else {
                scBondIdxs += {(atomno=@{iNo-1}) and (chain=iChain)
                    and thisModel}.atomIndex
                scBondIdxs += {(atomno=@{iNo-2}) and (chain=iChain)
                    and thisModel}.atomIndex
            }
            break
        }

    }

    return scBondIdxs
}

# Drag Side Chain
function drag_sc() {
    var iNo = {atomIndex=gSCidx}.atomno
    var iChain  = {atomIndex=gSCidx}.chain
    if ({atomIndex=gSCidx}.group != "PRO") {

        var scBondIdxs = collect_sc_rotors( iNo, iChain)
        var numChi = scBondIdxs.size / 4
        var dist = distance({atomIndex=gSCidx}.xyz, gSCpt)
        var scSet = get_sc_set(gSCidx, iChain)

        # For all rotor combinations
        var dh = array()
        for (var i = 0; i < numChi; i++) {
            dh += angle({atomIndex=@{scBondIdxs[4+(4*i)]}},
                {atomIndex=@{scBondIdxs[3+(4*i)]}},
                {atomIndex=@{scBondIdxs[2+(4*i)]}},
                {atomIndex=@{scBondIdxs[1+(4*i)]}})
        }
        for (var i = 0; i < numChi; i++) {
            var rot = -120
            for (var j = 0; j < 6; j++) {
                rot += 60*j
                select_add_sc(scBondIdxs[1+(4*i)])
                set_dihedral_idx(scBondIdxs[4+(4*i)], scBondIdxs[3+(4*i)],
                    scBondIdxs[2+(4*i)], scBondIdxs[1+(4*i)], rot)
                var newDist = distance({atomIndex=gSCidx}.xyz, gSCpt)
                if (gSCcheck) {
                    var colliders = (within(kCtolerance, false, scSet)
                        and not connected(scSet) and not {scSet})
                    if (colliders) {
                        continue
                    }
                }

                # Find the best
                if (newDist < dist) {
                    dist = newDist
                    for (var k = 0; k < numChi; k++) {
                        dh[k+1] = angle({atomIndex=@{scBondIdxs[4+(4*k)]}},
                        {atomIndex=@{scBondIdxs[3+(4*k)]}},
                        {atomIndex=@{scBondIdxs[2+(4*k)]}},
                        {atomIndex=@{scBondIdxs[1+(4*k)]}})
                    }
                }
            }
        }

        # Now set the best
        for (var i = 0; i < numChi; i++) {
            select_add_sc(scBondIdxs[1+(4*i)])
            set_dihedral_idx(scBondIdxs[4+(4*i)], scBondIdxs[3+(4*i)],
                scBondIdxs[2+(4*i)], scBondIdxs[1+(4*i)], dh[i+1])
        }
        
        if (gSCcheck = false) {
            plico_minimize( scSet)
        }
    }
    else { # PRO - toggle between puckers up and down
        var icd = {(atomno=@{iNo+1}) and (chain=iChain)
            and thisModel}.atomIndex
        var icb = {(atomno=@{iNo-1}) and (chain=iChain)
            and thisModel}.atomIndex
        var ica = {(atomno=@{iNo-4}) and (chain=iChain)
            and thisModel}.atomIndex
        var in = {(atomno=@{iNo-5}) and (chain=iChain)
            and thisModel}.atomIndex
        select {atomIndex=gSCidx}

        if (angle({atomIndex=ica}, {atomIndex=in},
            {atomIndex=icd}, {atomIndex=gSCidx}) < -10.0) {
            set_dihedral_idx(ica, in, icd, gSCidx, 8.7)
            set_angle_idx(in, icd, gSCidx, 110.0)
            set_distance_idx(icd, gSCidx, 1.5)
        }
        else {
            set_dihedral_idx(ica, in, icd, gSCidx, -29.5)
            set_angle_idx(in, icd, gSCidx, 108.8)
            set_distance_idx(icd, gSCidx, 1.5)
        }
    }

    draw gSCcircle CIRCLE {atomIndex=gSCidx} MESH NOFILL
    gSCpt = {atomIndex=gSCidx}.xyz
}

# Fix side chain collisions
function fix_sc_collision_2(idx) {
    gOk2 = false
    var iNo = {atomIndex=idx}.atomno
    var iChain = {atomIndex=idx}.chain
    var resno = {(atomno=iNo) and (chain=iChain)
        and thisModel}.resno

    # Get SC terminus
    while (resno == {(atomno=iNo) and (chain=iChain)
        and thisModel}.resno) {
        iNo++
    }
    iNo--

    var sc = array()
    var iBno = iNo
    while ({(atomno=iBno) and (chain=iChain)
        and thisModel}.atomName != "CB") {
        sc += {(atomno=iBno) and (chain=iChain)
            and thisModel}
        iBno--
    }
    var cbidx = {(atomno=iBno) and (chain=iChain)
        and thisModel}.atomIndex

    var scBondIdxs = collect_sc_rotors( iNo, iChain)
    var numChi = scBondIdxs.size / 4

    # For all rotor combinations
    for (var i = 0; i < numChi; i++) {
        var rot = -120
        for (var j = 0; j < 6; j++) {
            rot += 60
            select_add_sc(scBondIdxs[1+(4*i)])
            set_dihedral_idx(scBondIdxs[1+(4*i)], scBondIdxs[2+(4*i)],
                scBondIdxs[3+(4*i)], scBondIdxs[4+(4*i)], rot)

            # If no collision, exit
            var colliders = (within(kCtolerance, false, {sc})
                and not {atomIndex=cbidx} and not {sc})

            # If it is with water, delete the water
            for (var c = 1; c < colliders.size; c++ ) {
                if (colliders[c].group = "HOH") {
                    delete {atomIndex=@{colliders[c].atomIndex}}
                    colliders = {colliders and not @{colliders[c]}}
                }
            }

            if (colliders.size == 0) {
                gOk2 = true
                return # Early exit since break 1 appears broken
            }

        }
    }
}

function is_moveable_sc(aIdx) {

    var ret = (({atomIndex=aIdx}.group != "PRO")
        or ({atomIndex=aIdx}.atomName == "CG"))
    switch({atomIndex=aIdx}.atomName) {
    case "N":
    case "CA":
    case "C":
    case "CB":
    case "O":
    case "O4\'":
        ret = false
        break
    }
    return ret
}

function is_rotor_avail(i1idx, i2idx) {
    var ret = true
    if (i1idx > i2idx) { # frozen bonds are kept as lo-hi
        var idx = @i1idx
        i1idx = @i2idx
        i2idx = @idx
    }

    for (var i = 1; i <= gFreeze.size; i += 2) {
        if ((gFreeze[i] == i1idx) and (gFreeze[i+1] == i2idx)) {
            ret = false
            break
        }
    }

    return ret
}

function xcollect_bb_rotors(nWard) {
    var anchorNo = (nWard
        ? ((gNanchorIdx >= 0) ? {atomIndex=gNanchorIdx}.atomno : gMinNo)
        : ((gCanchorIdx >= 0) ? {atomIndex=gCanchorIdx}.atomno : gMaxNo))
    var cargoNo = (nWard
        ? ((gNcargoIdx >= 0) ? {atomIndex=gNcargoIdx}.atomno
        : {atomIndex=gCcargoIdx}.atomno)
        : {atomIndex=gCcargoIdx}.atomno)
    var rotors = array()
    if (cargoNo < anchorNo) {

        for (var iNo = cargoNo; iNo <= anchorNo; iNo++) {
            if ({(atomno=iNo) and (chain=gChain)
                and thisModel}.atomName == "CA") {
                if (is_rotor_avail(iNo)) {# xxx
                    if (({(atomno=iNo) and (chain=gChain)
                        and thisModel}.group != "PRO") and (iNo > cargoNo)) { # phi
                        rotors += [{(atomno=@{get_cm_no(iNo-1)}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{iNo-1}) and (chain=gChain)
                                and thisModel}.atomIndex]
                        rotors += [{(atomno=@{iNo}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{iNo+1}) and (chain=gChain)
                                and thisModel}.atomIndex]
                    }
                    if (iNo != (anchorNo-1)) { # psi
                        rotors += [{(atomno=@{iNo-1}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{iNo}) and (chain=gChain)
                                and thisModel}.atomIndex]
                        rotors += [{(atomno=@{iNo+1}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{get_np_no(iNo+2)}) and (chain=gChain)
                                and thisModel}.atomIndex]
                    }
                }
            }
        }
    }
    else {

        for (var iNo = cargoNo; iNo >= anchorNo; iNo--) {
            if ({(atomno=iNo) and (chain=gChain)
                and thisModel}.atomName == "CA") {
                if (is_rotor_avail(iNo)) {
                    if ((iNo != (anchorNo-1)) and (iNo < cargoNo)) { # psi
                        rotors += [{(atomno=@{get_np_no(iNo+2)}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{iNo+1}) and (chain=gChain)
                                and thisModel}.atomIndex]
                        rotors += [{(atomno=@{iNo}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{iNo-1}) and (chain=gChain)
                                and thisModel}.atomIndex]
                    }
                    if ({(atomno=iNo) and (chain=gChain)
                        and thisModel}.group != "PRO") { # phi
                        rotors += [{(atomno=@{iNo+1}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{iNo}) and (chain=gChain)
                                and thisModel}.atomIndex]
                        rotors += [{(atomno=@{iNo-1}) and (chain=gChain)
                            and thisModel}.atomIndex,
                            {(atomno=@{get_cm_no(iNo-1)}) and (chain=gChain)
                                and thisModel}.atomIndex]
                    }
                }
            }
        }
    }

    if (nWard) {
        gNrotors = rotors
    }
    else {
        gCrotors = rotors
    }
}
function collect_bb_rotors(nWard) {
    if (nWard) {
        gNrotors = array()
        var nres = {atomIndex=gNcargoIdx}.resno
        var nname = {atomIndex=gNcargoIdx}.atomName
        var ares = get_resno_min(gChain)
        var aA = get_atom_rcn( ares, gChain, "N")
        if (gNanchorIdx >= 0) {
            aA = {atomIndex=gNanchorIdx}
        }
        var aname = aA.atomName
        for (var r = nres; r >= ares; r--) {
            var aCp = get_atom_rcn( r-1, gChain, "C")
            var aN = get_atom_rcn( r, gChain, "N")
            var aCa = get_atom_rcn( r, gChain, "CA")
            var aC = get_atom_rcn( r, gChain, "C")
            var aNn = get_atom_rcn( r+1, gChain, "N")
            if (aCp.size < 1) {
                aCp = aNn
            }
            # psi
            if (((r < nres) and (r > ares))
                or ((r == nres) and (nname == "C"))
                or ((r == ares) and (aname != "C"))) {
                if (is_rotor_avail(aCa.atomIndex, aC.atomIndex)) {
                    gNrotors += aNn.atomIndex
                    gNrotors += aC.atomIndex
                    gNrotors += aCa.atomIndex
                    gNrotors += aN.atomIndex
                }
            }
                        
            # phi
            if (aCa.group != "PRO") {
                if (((r <= nres) and (r > ares))
                    or ((r == ares) and (aname == "N"))) {
                    if (is_rotor_avail(aCa.atomIndex, aN.atomIndex)) {
                        gNrotors += aC.atomIndex
                        gNrotors += aCa.atomIndex
                        gNrotors += aN.atomIndex
                        gNrotors += aCp.atomIndex
                    }
                }
            }
        } # endfor
    }
    else {
        gCrotors = array()
        var cres = {atomIndex=gCcargoIdx}.resno
        var cname = {atomIndex=gCcargoIdx}.atomName
        var ares = get_resno_max(gChain)
        var aA = get_atom_rcn( ares, gChain, "C")
        if (gCanchorIdx >= 0) {
            aA = {atomIndex=gCanchorIdx}
        }
        var aname = aA.atomName
        for (var r = cres; r <= ares; r++) {
            var aCp = get_atom_rcn( r-1, gChain, "C")
            var aN = get_atom_rcn( r, gChain, "N")
            var aCa = get_atom_rcn( r, gChain, "CA")
            var aC = get_atom_rcn( r, gChain, "C")
            var aNn = get_atom_rcn( r+1, gChain, "N")
            if (aNn.size < 1) {
                aNn = aCp
            }
            
            # phi
            if (aCa.group != "PRO") {
                if (((r > cres) and (r < ares))
                    or ((r == cres) and (aname == "N"))
                    or ((r == ares) and (aname != "N"))) {
                    if (is_rotor_avail(aN.atomIndex, aCa.atomIndex)) {
                        gCrotors += aCp.atomIndex
                        gCrotors += aN.atomIndex
                        gCrotors += aCa.atomIndex
                        gCrotors += aC.atomIndex
                    }
                }
            }
            
            # psi
            if (((r >= cres) and (r < ares))
                or ((r == cres) and (aname != "C"))
                or ((r == ares) and (aname == "C"))) {
                if (is_rotor_avail(aCa.atomIndex, aC.atomIndex)) {
                    gCrotors += aN.atomIndex
                    gCrotors += aCa.atomIndex
                    gCrotors += aC.atomIndex
                    gCrotors += aNn.atomIndex
                }
            }
        } # endfor
    }
}

function collect_rotors() {
    collect_bb_rotors(false)
    collect_bb_rotors(true)
}

function tug_sc(pt) {

    # If destination atom defined
    if (gDestAtomIdx >= 0) {
        var v = {atomIndex=gDestAtomIdx}.xyz - {atomIndex=gSCidx}.xyz
        if (abs(angle({atomIndex=gDestAtomIdx}.xyz, {0 0 0}, pt)) < 90) {
            pt = -v/20.0
        }
        else {
            pt = v/20.0
        }
    }
    gSCpt += pt
    draw arrow {atomIndex=gSCidx} @gSCpt
}

function set_colors() {
    select (thisModel)
    color {selected} @gScheme
    color {atomIndex=g1pivotIdx} green
    color {atomIndex=g2pivotIdx} green
    color @gCargoSet @gAltScheme
    color {gCargoSet and oxygen} pink
    select {(atomIndex=gCcargoIdx) or (atomIndex=gNcargoIdx)
        or (atomIndex=gCanchorIdx) or (atomIndex=gNanchorIdx)}
    halo on
    select {atomIndex=gDestAtomIdx}
    star on
    select none
}

function clear_atom_idxs() {
    gCcargoIdx = -1
    gNcargoIdx = -1
    gCanchorIdx = -1
    gNanchorIdx = -1
    g1pivotIdx = -1
    g2pivotIdx = -1
    g1dynamicIdx = -1
    g2dynamicIdx = -1
    gDestAtomIdx = -1
    gSCidx = -1
}

function timed_out (s) {
    timeout ID"tug" OFF
    refresh
    if (prompt(format("%s - Undo?", s), "Yes|No", true) == "Yes") {
        gBusy = false
        restore state gState
        connect
        select gCargoSet
        set bondPicking true
        refresh
        for (var i = 1; i <= gFreeze.size; i+=2) {
            select {atomIndex=@{gFreeze[i]}} or {atomIndex=@{gFreeze[i+1]}}
            color bonds lightblue
        }
        background ECHO yellow
        echo @gEcho
        select all
        quit
    }
}

function record_drag() {
    var ls = format("select %s;", {selected})
    ls += format("gCanchorIdx = %d;", gCanchorIdx)
    ls += format("gCanchorNo = %d;", gCanchorNo)
    ls += format("gNanchorIdx = %d;", gNanchorIdx)
    ls += format("gNanchorNo = %d;", gNanchorNo)
    ls += format("gCcargoIdx = %d;", gCcargoIdx)
    ls += format("gNcargoIdx = %d;", gNcargoIdx)
    ls += format("gCcargoNo = %d;", gCcargoNo)
    ls += format("gNcargoNo = %d;", gNcargoNo)
    ls += format("gDestAtomIdx = %d;", gDestAtomIdx)
    ls += format("g1pivotIdx = %d;", g1pivotIdx)
    ls += format("g2pivotIdx = %d;", g2pivotIdx)
    ls += format("gOkCollide = %s;", gOkCollide)
    ls += format("gChain = \"%s\";", gChain)
    ls += format("gMinNo = %d;", gMinNo)
    ls += format("gMaxNo = %d;", gMaxNo)
    ls += format("gCargoSet = %s;", gCargoSet)
    ls += format("gSCidx = %d;", gSCidx)
    ls += format("gSCcircle = %d;", gSCcircle)
    ls += format("gSCpt = %s;", gSCpt)
    ls += "collect_rotors();"
    ls += "tug_drag_done_mb();"
    plico_record(ls)
}

# Pick call-back for freeze
function tug_pick_cb() {
    if (_pickInfo[3][6] == "bond") {
        var sel = {selected}
        var i = _pickInfo.find(":")
        var iChain = _pickInfo[i+1]
        i = _pickInfo.find("#")
        var a1no = 0 + _pickInfo[i+1][i+3]
        var j = _pickInfo[i+1][9999].find("#")
        var a2no = 0 + _pickInfo[i+j+1][i+j+3]
        var i1idx = {(atomno=a1no) and (chain=iChain)
            and thisModel}.atomIndex
        var i2idx = {(atomno=a2no) and (chain=iChain)
            and thisModel}.atomIndex
        if (({atomIndex=i1idx}.atomName == "CA")
            or ({atomIndex=i2idx}.atomName == "CA")) {
            if (({atomIndex=i1idx}.atomName != "CB")
                and ({atomIndex=i2idx}.atomName != "CB")) {
                if (i1idx > i2idx) {
                    var idx = 0 + i1idx
                    i1idx = 0 + i2idx
                    i2idx = 0 + idx
                }
                select {atomIndex=i1idx} or {atomIndex=i2idx}

                for (i = 1; i <= gFreeze.size; i += 2) {
                    if ((gFreeze[i] == i1idx) and (gFreeze[i+1] == i2idx)) {
                        if (i > 1) {
                            if (gFreeze.size = (i+1)) {
                                gFreeze = gFreeze[1][i-1]
                            }
                            else {
                                gFreeze = gFreeze[1][i-1] + gFreeze[i+2][0]
                            }
                        }
                        else {
                            gFreeze = gFreeze[i+2][0]
                        }
                        color bonds NONE
                        i = 0
                        break
                    }
                }
                if (i > gFreeze.size) {
                    gFreeze += i1idx
                    gFreeze += i2idx
                    color bonds lightblue
                }
            }
        }
        select {sel}
    }
}

# Bound to LEFT-UP by tug_enable_drag
function tug_drag_done_mb() {
    if (not gBusy) {
        if (gPlicoRecord != "") {
            record_drag()
        }

        # Move by rotation on rotor sets, smallest first
        gBusy = true
        background ECHO pink
        refresh

        # If side chain mode
        if (gSCidx >= 0) {
            drag_sc()
        }

        # Else
        else if (not gTow) {
            gOK = true
            timeout ID"tug" 20.0 "timed_out(\"Tug timed out\")"
            if ((gCrotors.size < gNrotors.size) or (gNanchorIdx < 0)) {
                if (gCrotors.size > 4) {
                    tug_track_c()
                }
                if (gOK and (gNrotors.size > 4)) {
                    tug_track_n()
                }
            }
            else {
                if (gNrotors.size > 4) {
                    tug_track_n()
                }
                if (gOK and (gCrotors.size > 4)) {
                    tug_track_c()
                }
            }
            timeout ID"tug" OFF

            # If anchor angles acute, fail
            if (gOK == true) {
                if (gCanchorIdx >= 0) {
                    var ic = get_cward_bb_idx(gCanchorIdx, gChain)
                    var in = get_nward_bb_idx(gCanchorIdx, gChain)
                    if ((ic >= 0) and
                        angle({atomIndex=ic}, {atomIndex=gCanchorIdx}, {atomIndex=in})
                        < 100.0) {
                        gOK = false
                    }
                }
                if (gNanchorIdx >= 0) {
                    var ic = get_cward_bb_idx(gNanchorIdx, gChain)
                    var in = get_nward_bb_idx(gNanchorIdx, gChain)
                    if ((in >= 0) and
                        angle({atomIndex=ic}, {atomIndex=gNanchorIdx}, {atomIndex=in})
                        < 100.0) {
                        gOK = false
                    }
                }
            }

            # If too far
            if (not gOK) {
                timed_out("TUG TOO FAR!")
            }

            # Else OK
            else {

                var idx = {
                    (atomno=@{{(chain=gChain) and thisModel}.atomno.min})
                    and (chain=gChain) and thisModel}.atomIndex


                var ihc = 0
                for (ihc = 0; ihc < 10; ihc++) {
                    select ((atomno >= gNanchorNo) and (atomno <= gCanchorNo)
                        and (chain = gChain) and thisModel)
                    handle_collisions( idx)
                    if (count_collisions(({})).size == 0) {
                        break
                    }
                }
                if (ihc == 10) {
                    timed_out("Unable to handle all collisions!")
                }
            }
        }
        select {gCargoSet}
        gBusy = false
        background ECHO yellow
        set bondPicking true
        refresh
    }
}

# Bound to ALT-SHIFT-LEFT-DRAG by tug_enable_drag
function tug_drag_2_mb() {
    tug_drag_mb(true)
}

# Bound to ALT-LEFT-DRAG by tug_enable_drag
function tug_drag_mb(alt) {
    if (not gBusy) {
        gBusy = true
        var dx = (40.0 * (_mouseX - gMouseX))/_width
        var dy = (40.0 * (_mouseY - gMouseY))/_height
        var q = quaternion()
        var ptd = {@dx @dy 0}
        var pt = (!q)%ptd
        var caxis = {0 0 0}
        if (distance(pt,  {0 0 0}) > 0.004) {
            # If sidechain mode
            if (gSCidx >= 0) {
                if ({atomIndex=gSCidx}.atomName == "O") {
                    if ({atomIndex=gSCidx}.group != "PRO") {
                        var dir = ((abs(dx) > abs(dy))
                            ? ((dx < 0) ? 10 : -10)
                            : ((dy < 0) ? 1 : -1))
                        counter_rotate(gSCidx, dir, not alt)
                    }
                }
                else {
                    gSCcheck = not alt
                    tug_sc(pt)
                }
            }

            # Else
            else {

                # If new drag
                if (gNewDrag) {
                    gNewDrag = false
                    save state gState
                }

                # If destination atom defined
                if (gDestAtomIdx >= 0) {
                    var v = {atomIndex=gDestAtomIdx}.xyz - {selected}.xyz
                    if (abs(angle({atomIndex=gDestAtomIdx}.xyz, {0 0 0}, pt)) < 90) {
                        pt = -v/20.0
                    }
                    else {
                        pt = v/20.0
                    }
                }

                # Move the cargo
                select {gCargoSet}

                # If pivots defined, rotate it
                if (g1pivotIdx >= 0) {

                    # If two pivots
                    if (g2pivotIdx >= 0) {
                        caxis = {atomIndex=g2pivotIdx}
                    }

                    # Else
                    else {
                        caxis = cross(pt, {0 0 0}) + {atomIndex=g1pivotIdx}.xyz
                    }

                    var dir = ((abs(dx) > abs(dy))
                        ? ((dx < 0) ? 2 : -2)
                        : ((dy < 0) ? 2 : -2))
                    rotate_selected_record(g1pivotIdx, caxis, dir)

                }

                # Else translate it
                else {
                    translate_selected_record(pt)
                }

                # If collisions
                var cNotSels = (within(kCtolerance, false, {selected})
                    and not {gMovingSet})
                if ((cNotSels) and (not alt)) {
                    gOk2 = true
                    for (var i = 1; i <= cNotSels.size;  i++) {

                        # If net collision vector same as move vector
                        var cSels = (within(kCtolerance, false, cNotSels[i]) and {selected})
                        for (var j = 1; j <= cSels.size;  j++) {
                            var v1 = cNotSels[i].xyz - cSels[j].xyz
                            if (abs(angle(v1, {0 0 0}, pt)) < 90) {

                                # If tow mode
                                if (gTow) {

                                    # Make a dynamic pivot
                                    if (g1pivotIdx < 0) {
                                        g1pivotIdx = cSels[j].atomIndex
                                        g1dynamicIdx = cNotSels[i].atomIndex
                                        color {atomIndex=g1pivotIdx} lightgreen
                                        set_distance_idx(cNotSels[i].atomIndex,
                                            cSels[j].atomIndex,
                                            kCtolerance + kDtolerance)
                                    }
                                    else if (g2pivotIdx < 0) {
                                        g2pivotIdx = cSels[j].atomIndex
                                        g2dynamicIdx = cNotSels[i].atomIndex
                                        color {atomIndex=g2pivotIdx} lightgreen
                                        set_distance_idx(cNotSels[i].atomIndex,
                                            cSels[j].atomIndex,
                                            kCtolerance + kDtolerance)
                                    }
                                    else {
                                        gOk2 = false
                                    }
                                }
                                else {

                                    # Try to resolve
                                    select @{cSels[j]}
                                    var idx = {(atomno=@{{(chain=gChain)
                                        and thisModel}.atomno.min})
                                        and (chain=gChain) and thisModel}.atomIndex
                                    handle_collisions( idx)
                                }
                            }
                        } # endfor
                        if (not gOk2) {
                            break
                        }
                    } # endfor

                    # If unable
                    if (not gOk2) {

                        # Back off
                        background ECHO pink
                        delay 1
                        if (g1pivotIdx >= 0) {
                            rotate_selected_record(g1pivotIdx, caxis, -a)
                        }
                        else {
                            translate_selected_record(-pt)
                        }
                        background ECHO yellow
                        set bondPicking true
                    }
                }
            }

            # If dynamic pivots
            if (g1dynamicIdx >= 0) {
                var v1 = {atomIndex=g1dynamicIdx}.xyz - {atomIndex=g1pivotIdx}.xyz
                if (abs(angle(v1, {0 0 0}, pt)) > 90) {
                    color {atomIndex=g1pivotIdx} @gAltScheme
                    g1pivotIdx = -1
                    g1dynamicIdx = -1

                }
            }
            if (g2dynamicIdx >= 0) {
                var v1 = {atomIndex=g2dynamicIdx}.xyz - {atomIndex=g2pivotIdx}.xyz
                if (abs(angle(v1, {0 0 0}, pt)) > 90) {
                    color {atomIndex=g2pivotIdx} @gAltScheme
                    g2pivotIdx = -1
                    g2dynamicIdx = -1
                }
            }

            gMouseX = _mouseX
            gMouseY = _mouseY
        }
        select {gCargoSet}
        gBusy = false
    }
}

# Bound to ALT-LEFT-DOWN by tug_enable_drag
function tug_mark_mb() {
    gMouseX = _mouseX
    gMouseY = _mouseY
    gNewDrag = true
}

# Called by tug_cargo_mb
function tug_enable_drag() {
    gEcho = "__________TUG__________|ALT-CLICK=mark block|SHIFT-CLICK=anchors" +
        "|ALT-CTRL-CLICK=pivots|ALT-SHIFT-CLICK=dest atom|ALT-DRAG=move" +
        "|ALT-SHIFT-DRAG=alt move|CLICK bond=freeze|ALT-DOUBLE-CLICK=undo" +
        "|SHIFT-DOUBLE-CLICK=exit"
    echo @gEcho

    # Allow atoms to be dragged
    bind "ALT-LEFT-DOWN" "tug_mark_mb";
    bind "ALT-LEFT-UP" "tug_drag_done_mb";
    bind "ALT-SHIFT-LEFT-DOWN" "tug_mark_mb";
    bind "ALT-LEFT-DRAG" "tug_drag_mb";
    bind "ALT-SHIFT-LEFT-DRAG" "tug_drag_2_mb";

    unbind "SHIFT-LEFT-CLICK"
    bind "SHIFT-LEFT-CLICK" "_pickAtom";
    bind "SHIFT-LEFT-CLICK" "+:tug_anchor_mb";

    bind "ALT-CTRL-LEFT-CLICK" "_pickAtom";
    bind "ALT-CTRL-LEFT-CLICK" "+:tug_pivot_mb";

    bind "ALT-SHIFT-LEFT-CLICK" "_pickAtom";
    bind "ALT-SHIFT-LEFT-CLICK" "+:tug_dest_atom_mb";
}

# Bound to SHIFT-LEFT-CLICK by tug_cargo_mb
function tug_anchor_mb() {
    if ({atomIndex=_atomPicked}.chain == gChain) {
        var aPidx = get_sc_bb_idx( _atomPicked, gChain)

        var pno = {atomIndex=aPidx}.atomno
        if (pno > {atomIndex=gCcargoIdx}.atomno) {
            select {atomIndex=gCanchorIdx}
            halo off
            if (gCanchorIdx == aPidx) {
                gCanchorIdx = -1
                gCanchorNo = gMaxNo + 1
            }
            else {
                gCanchorIdx = aPidx
                gCanchorNo = {atomIndex=gCanchorIdx}.atomno
                select {atomIndex=gCanchorIdx}
                halo on
            }
            collect_bb_rotors(false)
        }
        else if (pno < {atomIndex=gNcargoIdx}.atomno) {
            select {atomIndex=gNanchorIdx}
            halo off
            if (gNanchorIdx == aPidx) {
                gNanchorIdx = -1
                gNanchorNo = gMinNo - 1
            }
            else {
                gNanchorIdx = aPidx
                gNanchorNo = {atomIndex=gNanchorIdx}.atomno
                select {atomIndex=gNanchorIdx}
                halo on
            }
            collect_bb_rotors(true)
        }
        else {
            tow_cargo_mb()
        }

        # Get moving atoms set
        gMovingSet = {((atomno < gCanchorNo) and (atomno > gNanchorNo)
            and (chain=gChain) and thisModel)}
    }
    select {gCargoSet}
}

# Bound to ALT-SHIFT-LEFT-CLICK by tug_cargo_mb
function tug_dest_atom_mb() {
    var aOk = true
    if ({atomIndex=_atomPicked}.chain == gChain) {

        var pno = {atomIndex=_atomPicked}.atomno
        if ((pno <= {atomIndex=gCcargoIdx}.atomno)
            and (pno >= {atomIndex=gNcargoIdx}.atomno)) {
            aOk = false
        }
    }
    if (aOk) {
        select {atomIndex=gDestAtomIdx}
        star off
        if (gDestAtomIdx == _atomPicked) {
            gDestAtomIdx = -1
        }
        else {
            gDestAtomIdx = _atomPicked
            select {atomIndex=gDestAtomIdx}
            star on
        }
        select {gCargoSet}
    }
}

# Bound to CTRL-LEFT-CLICK by tug_cargo_mb
function tug_pivot_mb() {
    if (g1pivotIdx == _atomPicked) {
        color {atomIndex=g1pivotIdx} @gScheme
        if (g2pivotIdx >= 0) {
            g1pivotIdx = g2pivotIdx
            g2pivotIdx = -1
            g2dynamicIdx = -1
        }
        else {
            g1pivotIdx = -1
            g1dynamicIdx = -1
        }
    }
    else if (g2pivotIdx == _atomPicked) {
        color {atomIndex=g2pivotIdx} @gScheme
        g2pivotIdx = -1
        g2dynamicIdx = -1
    }
    else if (g1pivotIdx >= 0) {
        if (g2pivotIdx >= 0) {
            color {atomIndex=g2pivotIdx} @gScheme
        }

        g2pivotIdx = _atomPicked
        g2dynamicIdx = -1
        color {atomIndex=g2pivotIdx} green
    }
    else {
        g1pivotIdx = _atomPicked
        g1dynamicIdx = -1
        color {atomIndex=g1pivotIdx} green
    }
    select {gCargoSet}
}

# Bound to SHIFT-LEFT-CLICK by plico_tug
function tow_cargo_mb() {
    gTow = true
    gChain = {atomIndex=_atomPicked}.chain
    gMinNo = {(chain=gChain) and thisModel}.atomno.min
    gMaxNo = {(chain=gChain) and thisModel}.atomno.max
    gCcargoIdx = -1
    gNcargoIdx = -1
    gCanchorIdx = -1
    gCanchorNo = gMaxNo + 1
    gNanchorIdx = -1
    gNanchorNo = gMinNo - 1

    # Highlight cargo cluster
    select {(chain=gChain) and thisModel}
    gCargoSet = {selected}
    gMovingSet = {selected}
    set_colors()

    # Enable dragging
    tug_enable_drag()
    select {gCargoSet}
    halo off
    var es = gEcho.replace("anchors","mark chain")
    echo @es
    unbind "SHIFT-LEFT-CLICK"
    bind "SHIFT-LEFT-CLICK" "_pickAtom";
    bind "SHIFT-LEFT-CLICK" "+:tow_cargo_mb";
}

# Bound to ALT-LEFT-CLICK by plico_tug or called by plicotoab.toabCargoMB
function tug_cargo_mb() {

    # If O or movable side chain atom picked
    if ((({atomIndex=_atomPicked}.atomName = "O")
        and ({atomIndex=_atomPicked}.group != "PRO"))
        or (is_moveable_sc( _atomPicked))) {
        if (gSCidx >= 0) {
            draw gSCcircle DELETE
        }
        if (gSCidx == _atomPicked) {
            gSCidx = -1
        }
        else {
            gSCidx = _atomPicked
            gSCpt = {atomIndex=gSCidx}.xyz
            draw gSCcircle CIRCLE {atomIndex=gSCidx} MESH NOFILL
        }
    }
    else {
        if ({atomIndex=_atomPicked}.chain != gChain) {
            if (gTow) {
                select {(chain=gChain) and thisModel}
                color {selected} @gScheme
            }
            gChain = {atomIndex=_atomPicked}.chain
            select ({atomIndex=gCcargoIdx} or {atomIndex=gNcargoIdx}
                or {atomIndex=gCanchorIdx} or {atomIndex=gNanchorIdx})
            halo off
            gCcargoIdx = -1
            gNcargoIdx = -1
            gCanchorIdx = -1
            gNanchorIdx = -1
        }
        gTow = false
        gMinNo = {(chain=gChain) and thisModel}.atomno.min
        gMaxNo = {(chain=gChain) and thisModel}.atomno.max
        if (gNanchorIdx < 0) {
            gNanchorNo = gMinNo - 1
        }
        if (gCanchorIdx < 0) {
            gCanchorNo = gMaxNo + 1
        }
        var aPidx = get_sc_bb_idx( _atomPicked, gChain)

        gSCidx = -1
        draw gSCcircle DELETE

        # If existing cWard cargo picked
        if (gCcargoIdx == aPidx) {

            # Clear the highlight
            select {atomIndex=gCcargoIdx}
            halo off

            # If nWard cargo exists, mark it as the cWard cargo
            if (gNcargoIdx != gCcargoIdx) {
                gCcargoIdx = get_cp_idx(gNcargoIdx)
                gCcargoNo = {atomIndex=gCcargoIdx}.atomno
            }
            else {
                gCcargoIdx = -1
                gNcargoIdx = -1
            }
        }
        else if (gNcargoIdx == aPidx) {
            select {atomIndex=gNcargoIdx}
            halo off
            gNcargoIdx = get_nm_idx(gCcargoIdx)
            gNcargoNo = {atomIndex=gNcargoIdx}.atomno
        }
        else if (gCcargoIdx >= 0) {

            var no = {atomIndex=aPidx}.atomno

            # If pick is nWard of it
            if (no < {atomIndex=gCcargoIdx}.atomno) {

                # If exists, clear its highlight
                if (gNcargoIdx != gCcargoIdx) {
                    select {atomIndex=gNcargoIdx}
                    halo off
                }

                # Set new nWard cargo and highlight it
                gNcargoIdx = get_nm_idx(aPidx)
                gNcargoNo = {atomIndex=gNcargoIdx}.atomno
            }

            # Else cWard
            else {

                # Clear its old highlight
                select {atomIndex=gCcargoIdx}
                if (gNcargoIdx != gCcargoIdx) {
                    halo off
                }

                # Set new cWard cargo and highlight
                gCcargoIdx = get_cp_idx(aPidx)
                gCcargoNo = {atomIndex=gCcargoIdx}.atomno
            }
        }

        # Else no cWard cargo
        else {

            # Set new cWard cargo and highlight
            gCcargoIdx = get_cp_idx(aPidx)
            gCcargoNo = {atomIndex=gCcargoIdx}.atomno
            gNcargoIdx = get_nm_idx(gCcargoIdx)
            gNcargoNo = {atomIndex=gNcargoIdx}.atomno
        }

        # If any anchor now inside cargo cluster, kill it
        if ({atomIndex=gCanchorIdx}.atomno <= {atomIndex=gCcargoIdx}.atomno) {
            gCanchorIdx = -1
            gCanchorNo = gMaxNo + 1
        }
        if ({atomIndex=gNanchorIdx}.atomno >= {atomIndex=gNcargoIdx}.atomno) {
            gNanchorIdx = -1
            gNanchorNo = gMinNo - 1
        }

        # Highlight cargo cluster
        select_nward_idx(gCcargoIdx, gNcargoIdx)
        gCargoSet = {selected}
        set_colors()

        # Collect the rotor sets
        collect_rotors()

        # Get moving atoms set
        gMovingSet = {((atomno < gCanchorNo) and (atomno > gNanchorNo)
            and (chain=gChain) and thisModel)}
    }

    # Enable dragging
    if (gToab) {
        to_ab_enable_drag()
    }
    else {
        tug_enable_drag()
    }

    select {gCargoSet}
}

function tug_undo_mb() {
    if (prompt("Undo", "Yes|No", true) == "Yes") {
        restore state gState
    }
}

# Top level of Tug
function plico_tug() {

    # Load common functions if not already
    if (kCommon < 7) {
        script $SCRIPT_PATH$plicoCommon.spt
        if (kCommon < 7) {
            prompt ("A newer version of plicoCommon.SPT is required")
            quit
        }
    }

    gPlico = "TUG"
    plico_prelim(true, true)
    
    gBondPicking = bondPicking
    set bondPicking true
    set PickCallback "jmolscript:tug_pick_cb"

    gEcho = ("_________TUG_________|ALT-CLICK=mark block|SHIFT-CLICK=mark chain" +
        "|CLICK bond=freeze|ALT-DOUBLE-CLICK=undo|SHIFT-DOUBLE-CLICK=exit")
    echo @gEcho
    gCrotors = array()
    gNrotors = array()
    clear_atom_idxs()
    gToab = false

    bind "ALT-LEFT-CLICK" "_pickAtom";
    bind "ALT-LEFT-CLICK" "+:tug_cargo_mb";
    bind "SHIFT-LEFT-CLICK" "_pickAtom";
    bind "SHIFT-LEFT-CLICK" "+:tow_cargo_mb";
    bind "ALT-LEFT-DOUBLE" "tug_undo_mb";
    bind "SHIFT-DOUBLE" "tug_exit(true)";
    bind "LEFT-CLICK" "+:plico_menu_toggle";
}

# Bound to DOUBLE by plico_tug
function tug_exit() {
    if (plico_exit()) {
        set bondPicking gBondPicking
        set PickCallback NONE
        select all
        color bonds none
        
        reset kTug
        reset gCanchorIdx  
        reset gCanchorNo   
        reset gPlico       
        reset gNanchorIdx  
        reset gNanchorNo   
        reset gCcargoIdx   
        reset gNcargoIdx   
        reset gCcargoNo    
        reset gNcargoNo    
        reset gDestAtomIdx 
        reset g1pivotIdx   
        reset g2pivotIdx   
        reset gSelSaves    
        reset gCrotors     
        reset gNrotors     
        reset gOkCollide   
        reset gChain       
        reset gMinNo       
        reset gMaxNo       
        reset gCargoSet    
        reset gMovingSet   
        reset gSCidx       
        reset gSCcircle    
        reset gSCpt        
        reset gTargetPt    
        reset gNewDrag     
        reset gTow         
        reset g1dynamicIdx 
        reset g2dynamicIdx 
        reset gSCcheck     
        reset gBondPicking 
        reset gFreeze      
        reset gToab        
        reset function "get_cp_idx"
        reset function "get_cm_no"
        reset function "get_nm_idx"
        reset function "get_np_no"
        reset function "get_cb_idx"
        reset function "get_o_idx"
        reset function "get_nward_bb_idx"
        reset function "get_cward_bb_idx"
        reset function "get_sc_set"
        reset function "get_sc_bb_idx"
        reset function "is_bb_idx"
        reset function "is_sc_idx"
        reset function "select_add_sc"
        reset function "handle_collisions"
        reset function "tug_track_idx"
        reset function "do_counter_rotate"
        reset function "counter_rotate"
        reset function "counter_rotate_2"
        reset function "repair_proline"
        reset function "repair_sc"
        reset function "tug_track_c"
        reset function "tug_track_n"
        reset function "translate_selected_record"
        reset function "rotate_selected_record"
        reset function "collect_sc_rotors"
        reset function "drag_sc"
        reset function "fix_sc_collision_2"
        reset function "is_moveable_sc"
        reset function "is_rotor_avail"
        reset function "xcollect_bb_rotors"
        reset function "collect_bb_rotors"
        reset function "collect_rotors"
        reset function "tug_sc"
        reset function "set_colors"
        reset function "clear_atom_idxs"
        reset function "timed_out"
        reset function "record_drag"
        reset function "tug_pick_cb"
        reset function "tug_drag_done_mb"
        reset function "tug_drag_2_mb"
        reset function "tug_drag_mb"
        reset function "tug_mark_mb"
        reset function "tug_anchor_mb"
        reset function "tug_enable_drag"
        reset function "tug_dest_atom_mb"
        reset function "tug_pivot_mb"
        reset function "tow_cargo_mb"
        reset function "tug_cargo_mb"
        reset function "tug_undo_mb"
        reset function "plico_tug"


    }
}

# End of TUG.SPT

Contributors

Remig