示例#1
0
    def testRepsExist(self):
        cmd.viewport(200, 150)
        cmd.load(self.datafile('1oky-frag.pdb'), 'm1')

        # make some nonbonded
        cmd.unbond('resi 115-', 'resi 115-')

        # labels
        cmd.label('all', 'name')

        # measurements
        cmd.distance('measure1', 'index 1', 'index 10')
        cmd.angle('measure1', 'index 1', 'index 10', 'index 20')
        cmd.dihedral('measure1', 'index 1', 'index 10', 'index 20', 'index 30')

        # color test setup
        cmd.color('white', '*')
        cmd.set('ambient', 1)
        cmd.set('depth_cue', 0)
        cmd.set('antialias', 0)
        cmd.set('line_smooth', 0)
        cmd.orient()

        # test most reps
        for rep in REPS:
            cmd.show_as(rep)
            self.assertImageHasColor('white', msg='rep missing: ' + rep)

        # test cartoon
        cmd.show_as('cartoon')
        for cart in CARTOONS:
            cmd.cartoon(cart)
            self.assertImageHasColor('white', msg='cartoon missing: ' + cart)
示例#2
0
    def testRepsExist(self):
        cmd.viewport(200, 150)
        cmd.load(self.datafile('1oky-frag.pdb'), 'm1')

        # make some nonbonded
        cmd.unbond('resi 115-', 'resi 115-')

        # labels
        cmd.label('all', 'name')

        # measurements
        cmd.distance('measure1', 'index 1', 'index 10')
        cmd.angle('measure1', 'index 1', 'index 10', 'index 20')
        cmd.dihedral('measure1', 'index 1', 'index 10', 'index 20', 'index 30')

        # color test setup
        cmd.color('white', '*')
        cmd.set('ambient', 1)
        cmd.set('depth_cue', 0)
        cmd.set('antialias', 0)
        cmd.set('line_smooth', 0)
        cmd.orient()

        # test most reps
        for rep in REPS:
            cmd.show_as(rep)
            self.assertImageHasColor('white', msg='rep missing: ' + rep)

        # test cartoon
        cmd.show_as('cartoon')
        for cart in CARTOONS:
            cmd.cartoon(cart)
            self.assertImageHasColor('white', msg='cartoon missing: ' + cart)
def draw_axis(chA, chB, scale_factor=20, w=0.6, r1=1, g1=1, b1=1, r2=1, g2=0, b2=0):
    T = transf_matrix(chA, chB)
    angle=angle_axis(chA, chB)
    angle_degrees=(angle*180)/math.pi
    axis1=[direction_cosines(chA, chB)[0], direction_cosines(chA, chB)[1], direction_cosines(chA, chB)[2]]
    p = nearest_point_to_axis(chA, chB)
    x1, y1, z1 = p[0] + (3*scale_factor*axis1[0]), p[1] + (3*scale_factor*axis1[1]), p[2] + (3*scale_factor*axis1[2])
    x2, y2, z2 = p[0] - (3*scale_factor*axis1[0]), p[1] - (3*scale_factor*axis1[1]), p[2] - (3*scale_factor*axis1[2])
    obj = [cgo.CYLINDER, x1, y1, z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2, 0.0]
    cmd.load_cgo(obj, angle_degrees)

    cmA=center_of_Mass(chA)
    cmB=cmW
    cmAver=(cmB+cmA)/2
    vector=numpy.array([(cmB[0]-cmA[0]), (cmB[1]-cmA[1]), (cmB[2]-cmA[2])])
    moduli_vector=numpy.linalg.norm(vector)
    vector_director=numpy.array([(cmB[0]-cmA[0])/moduli_vector, (cmB[1]-cmA[1])/moduli_vector, (cmB[2]-cmA[2])/moduli_vector])
    pC_A = proyeccion_centroide(chA, chA, chB)
    pC_B = proyeccion_centroide_working(chA, chB)


    trans_vector = numpy.array([(pC_B[0]-pC_A[0]), (pC_B[1]-pC_A[1]), (pC_B[2]-pC_A[2])])
    modu_tr = numpy.linalg.norm(trans_vector)
    rota_centroid_rad=numpy.dot(vector_director, axis1)
    rota_centroid = (rota_centroid_rad*180)/math.pi
    rota_centroid_absol_0= numpy.absolute(rota_centroid)
    rota_centroid_absol=round(rota_centroid_absol_0,2)


    if rota_centroid_absol == 0.00:
        p1 = '_1'
        p2 = '_2'
        p3 = '_3'
        cmd.pseudoatom (pos=[cmA[0], cmA[1], cmA[2]], object=p1)
        cmd.pseudoatom (pos=[pC_A[0], pC_A[1], pC_A[2]], object=p2)
        cmd.pseudoatom (pos=[cmB[0], cmB[1], cmB[2]], object=p3)
        cmd.angle(None, p1, p2, p3)
        print_information(T, axis1, angle_degrees,  moduli_vector, obj, x1, y1, z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2)

    if rota_centroid_absol != 0:
        p1 = '_1'
        p2 = '_2'
        p3 = '_3'
        p4 = '_4'
        cmd.pseudoatom (pos=[cmA[0], cmA[1], cmA[2]], object=p1)
        cmd.pseudoatom (pos=[pC_A[0], pC_A[1], pC_A[2]], object=p2)
        cmd.pseudoatom (pos=[pC_B[0], pC_B[1], pC_B[2]], object=p3)
        cmd.pseudoatom (pos=[cmB[0], cmB[1], cmB[2]], object=p4)
        cmd.dihedral(None, p1, p2, p3, p4)
        cmd.distance(None, p2, p3)
        print_information(T, axis1, angle_degrees,  moduli_vector, obj, x1, y1, z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2, modu_tr)

    cmd.create('working', chA)
    cmd.super('working', chB)
示例#4
0
 def testAngleColor(self):
     cmd.fragment('ala')
     cmd.color('blue')
     cmd.angle('ang01', 'index 8', 'index 5', 'index 2')
     cmd.hide('label')
     cmd.set('fog', '0')
     cmd.set('ambient', '1')
     cmd.set('angle_color', 'red')
     cmd.set('dash_gap', '0')
     cmd.zoom()
     #need to check to make sure screen image has red in it
     img_array = self.get_imagearray(width=100, height=100, ray=0)
     self.assertImageHasColor('red', img_array, delta=[10,0,0])
示例#5
0
 def doFinish(self):
     r_aA = cmd.get_distance(atom1="pw2", atom2="pw3", state=0)
     cmd.distance(self.params_str[0], "pw2", "pw3")
     th_a = cmd.get_angle(atom1="pw1", atom2="pw2", atom3="pw3", state=0)
     cmd.angle(self.params_str[1], "pw1", "pw2", "pw3")
     th_A = cmd.get_angle(atom1="pw2", atom2="pw3", atom3="pw4", state=0)
     cmd.angle(self.params_str[2], "pw2", "pw3", "pw4")
     if not (r_aA and th_a and th_A):
         showerror(self.parent, "Error!",
                   "Maybe you made a mistake when choosing atoms!")
         self.reset()
     phi_ba = cmd.get_dihedral(atom1="pw0",
                               atom2="pw1",
                               atom3="pw2",
                               atom4="pw3",
                               state=0)
     cmd.dihedral(self.params_str[3], "pw0", "pw1", "pw2", "pw3")
     phi_aA = cmd.get_dihedral(atom1="pw1",
                               atom2="pw2",
                               atom3="pw3",
                               atom4="pw4",
                               state=0)
     cmd.dihedral(self.params_str[4], "pw1", "pw2", "pw3", "pw4")
     phi_AB = cmd.get_dihedral(atom1="pw2",
                               atom2="pw3",
                               atom3="pw4",
                               atom4="pw5",
                               state=0)
     cmd.dihedral(self.params_str[5], "pw2", "pw3", "pw4", "pw5")
     index_c = cmd.id_atom("pw0")
     index_c_name = getAtomString('pw0')
     index_b = cmd.id_atom("pw1")
     index_b_name = getAtomString('pw1')
     index_a = cmd.id_atom("pw2")
     index_a_name = getAtomString('pw2')
     index_A = cmd.id_atom("pw3")
     index_A_name = getAtomString('pw3')
     index_B = cmd.id_atom("pw4")
     index_B_name = getAtomString('pw4')
     index_C = cmd.id_atom("pw5")
     index_C_name = getAtomString('pw5')
     self.setBondForceParam(r_aA, th_a, th_A, phi_ba, phi_aA, phi_AB,
                            index_c, index_b, index_a, index_A, index_B,
                            index_C)
     self.setAtomsDef(index_c_name, index_b_name, index_a_name,
                      index_A_name, index_B_name, index_C_name)
     top = Toplevel(
         self.parent)  # <- freeze when open gro file in pymol 1.X
     Output(top, self.bondForceParams, self.atoms_def)
     cmd.set_wizard()
示例#6
0
    def testMeasureBetweenStates(self):
        cmd.load(self.datafile('1v5a-3models.cif'), 'm1')

        # distance
        d = cmd.distance('d1', '24/CZ', 'same', state1=2, state2=3)
        self.assertAlmostEqual(d, 3.0, delta=1e-1)

        # angle
        a = cmd.angle('a1',
                      '24/CZ',
                      'same',
                      'same',
                      state1=2,
                      state2=3,
                      state3=1)
        self.assertAlmostEqual(a, 73.5, delta=1e-1)

        # visual test
        cmd.viewport(100, 100)
        cmd.set('dash_radius', 1.0)
        self.ambientOnly()
        for name in ['d1', 'a1']:
            cmd.disable('*')
            cmd.enable(name)
            cmd.zoom(name)
            self.assertImageHasColor('yellow')
示例#7
0
def angle_between_helices(selection1, selection2, method='helix',
        state1=STATE, state2=STATE, visualize=1, quiet=1):
    '''
DESCRIPTION

    Calculates the angle between two helices

USAGE

    angle_between_helices selection1, selection2 [, method [, visualize]]

ARGUMENTS

    selection1 = string: atom selection of first helix

    selection2 = string: atom selection of second helix

    method = string: function to calculate orientation {default: helix_orientation}

    visualize = 0 or 1: show fitted vector as arrow {default: 1}

EXAMPLE

    fetch 2x19, async=0
    select hel1, /2x19//B/23-36/
    select hel2, /2x19//B/40-54/
    angle_between_helices hel1, hel2
    angle_between_helices hel1, hel2, cafit

SEE ALSO

    helix_orientation, loop_orientation, cafit_orientation, angle_between_domains
    '''
    import math

    state1, state2 = int(state1), int(state2)
    visualize, quiet = int(visualize), int(quiet)

    try:
        orientation = globals()[methods_sc[str(method)]]
    except KeyError:
        print 'no such method:', method
        raise CmdException

    if not int(quiet):
        print ' Using method:', orientation.__name__

    cen1, dir1 = orientation(selection1, state1, visualize, quiet=1)
    cen2, dir2 = orientation(selection2, state2, visualize, quiet=1)

    angle = cpv.get_angle(dir1, dir2)
    angle = math.degrees(angle)

    if not quiet:
        print ' Angle: %.2f deg' % (angle)

    if visualize:
        # measurement object for angle
        center = cpv.scale(cpv.add(cen1, cen2), 0.5)
        tmp = get_unused_name('_')
        for pos in [center,
                cpv.add(center, cpv.scale(dir1, 5.0)),
                cpv.add(center, cpv.scale(dir2, 5.0))]:
            cmd.pseudoatom(tmp, pos=list(pos), state=1)
        name = get_unused_name('angle')
        cmd.angle(name, *[(tmp, i) for i in [2,1,3]])
        cmd.delete(tmp)

        cmd.zoom('(%s) or (%s)' % (selection1, selection2), 2,
                state1 if state1 == state2 else 0)

    return angle
示例#8
0
def draw_axis(chA,
              chB,
              scale_factor=20,
              w=0.6,
              r1=1,
              g1=1,
              b1=1,
              r2=1,
              g2=0,
              b2=0):
    T = transf_matrix(chA, chB)
    angle = angle_axis(chA, chB)
    angle_degrees = (angle * 180) / math.pi
    axis1 = [
        direction_cosines(chA, chB)[0],
        direction_cosines(chA, chB)[1],
        direction_cosines(chA, chB)[2]
    ]
    p = nearest_point_to_axis(chA, chB)
    x1, y1, z1 = p[0] + (3 * scale_factor * axis1[0]), p[1] + (
        3 * scale_factor * axis1[1]), p[2] + (3 * scale_factor * axis1[2])
    x2, y2, z2 = p[0] - (3 * scale_factor * axis1[0]), p[1] - (
        3 * scale_factor * axis1[1]), p[2] - (3 * scale_factor * axis1[2])
    obj = [
        cgo.CYLINDER, x1, y1, z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2, 0.0
    ]
    cmd.load_cgo(obj, angle_degrees)

    cmA = center_of_Mass(chA)
    cmB = cmW
    cmAver = (cmB + cmA) / 2
    vector = numpy.array([(cmB[0] - cmA[0]), (cmB[1] - cmA[1]),
                          (cmB[2] - cmA[2])])
    moduli_vector = numpy.linalg.norm(vector)
    vector_director = numpy.array([(cmB[0] - cmA[0]) / moduli_vector,
                                   (cmB[1] - cmA[1]) / moduli_vector,
                                   (cmB[2] - cmA[2]) / moduli_vector])
    pC_A = proyeccion_centroide(chA, chA, chB)
    pC_B = proyeccion_centroide_working(chA, chB)

    trans_vector = numpy.array([(pC_B[0] - pC_A[0]), (pC_B[1] - pC_A[1]),
                                (pC_B[2] - pC_A[2])])
    modu_tr = numpy.linalg.norm(trans_vector)
    rota_centroid_rad = numpy.dot(vector_director, axis1)
    rota_centroid = (rota_centroid_rad * 180) / math.pi
    rota_centroid_absol_0 = numpy.absolute(rota_centroid)
    rota_centroid_absol = round(rota_centroid_absol_0, 2)

    if rota_centroid_absol == 0.00:
        p1 = '_1'
        p2 = '_2'
        p3 = '_3'
        cmd.pseudoatom(pos=[cmA[0], cmA[1], cmA[2]], object=p1)
        cmd.pseudoatom(pos=[pC_A[0], pC_A[1], pC_A[2]], object=p2)
        cmd.pseudoatom(pos=[cmB[0], cmB[1], cmB[2]], object=p3)
        cmd.angle(None, p1, p2, p3)
        print_information(T, axis1, angle_degrees, moduli_vector, obj, x1, y1,
                          z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2)

    if rota_centroid_absol != 0:
        p1 = '_1'
        p2 = '_2'
        p3 = '_3'
        p4 = '_4'
        cmd.pseudoatom(pos=[cmA[0], cmA[1], cmA[2]], object=p1)
        cmd.pseudoatom(pos=[pC_A[0], pC_A[1], pC_A[2]], object=p2)
        cmd.pseudoatom(pos=[pC_B[0], pC_B[1], pC_B[2]], object=p3)
        cmd.pseudoatom(pos=[cmB[0], cmB[1], cmB[2]], object=p4)
        cmd.dihedral(None, p1, p2, p3, p4)
        cmd.distance(None, p2, p3)
        print_information(T, axis1, angle_degrees, moduli_vector, obj, x1, y1,
                          z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2, modu_tr)

    cmd.create('working', chA)
    cmd.super('working', chB)
示例#9
0
def angle_between_domains(selection1,
                          selection2,
                          method='align',
                          state1=STATE,
                          state2=STATE,
                          visualize=1,
                          quiet=1):
    '''
DESCRIPTION

    Angle by which a molecular selection would be rotated when superposing
    on a selection2.

    Do not use for measuring angle between helices, since the alignment of
    the helices might involve a rotation around the helix axis, which will
    result in a larger angle compared to the angle between helix axes.

USAGE

    angle_between_domains selection1, selection2 [, method ]

ARGUMENTS

    selection1 = string: atom selection of first helix

    selection2 = string: atom selection of second helix

    method = string: alignment command like "align" or "super" {default: align}

EXAMPLE

    fetch 3iplA 3iplB, bsync=0
    select domain1, resi 1-391
    select domain2, resi 392-475
    align 3iplA and domain1, 3iplB and domain1
    angle_between_domains 3iplA and domain2, 3iplB and domain2

SEE ALSO

    align, super, angle_between_helices
    '''
    import math

    try:
        import numpy
    except ImportError:
        print(' Error: numpy not available')
        raise CmdException

    state1, state2 = int(state1), int(state2)
    visualize, quiet = int(visualize), int(quiet)

    if cmd.is_string(method):
        try:
            method = cmd.keyword[method][0]
        except KeyError:
            print('no such method:', method)
            raise CmdException

    mobile_tmp = get_unused_name('_')
    cmd.create(mobile_tmp, selection1, state1, 1, zoom=0)
    try:
        method(mobile=mobile_tmp,
               target=selection2,
               mobile_state=1,
               target_state=state2,
               quiet=quiet)
        mat = cmd.get_object_matrix(mobile_tmp)
    except:
        print(' Error: superposition with method "%s" failed' %
              (method.__name__))
        raise CmdException
    finally:
        cmd.delete(mobile_tmp)

    try:
        # Based on transformations.rotation_from_matrix
        # Copyright (c) 2006-2012, Christoph Gohlke

        R33 = [mat[i:i + 3] for i in [0, 4, 8]]
        R33 = numpy.array(R33, float)

        # direction: unit eigenvector of R33 corresponding to eigenvalue of 1
        w, W = numpy.linalg.eig(R33.T)
        i = w.real.argmax()
        direction = W[:, i].real

        # rotation angle depending on direction
        m = direction.argmax()
        i, j, k, l = [[2, 1, 1, 2], [0, 2, 0, 2], [1, 0, 0, 1]][m]
        cosa = (R33.trace() - 1.0) / 2.0
        sina = (R33[i, j] +
                (cosa - 1.0) * direction[k] * direction[l]) / direction[m]

        angle = math.atan2(sina, cosa)
        angle = abs(math.degrees(angle))
    except:
        print(' Error: rotation from matrix failed')
        raise CmdException

    if not quiet:
        try:
            # make this import optional to support running this script standalone
            from .querying import centerofmass, gyradius
        except (ValueError, ImportError):
            gyradius = None
            try:
                # PyMOL 1.7.1.6+
                centerofmass = cmd.centerofmass
            except AttributeError:
                centerofmass = lambda s: cpv.scale(cpv.add(*cmd.get_extent(s)),
                                                   0.5)

        center1 = centerofmass(selection1)
        center2 = centerofmass(selection2)
        print(' Angle: %.2f deg, Displacement: %.2f angstrom' %
              (angle, cpv.distance(center1, center2)))

        if visualize:
            center1 = numpy.array(center1, float)
            center2 = numpy.array(center2, float)
            center = (center1 + center2) / 2.0

            if gyradius is not None:
                rg = numpy.array(gyradius(selection1), float)
            else:
                rg = 10.0

            h1 = numpy.cross(center2 - center1, direction)
            h2 = numpy.dot(R33, h1)
            h1 *= rg / cpv.length(h1)
            h2 *= rg / cpv.length(h2)

            for pos in [center1, center2, center1 + h1, center1 + h2]:
                cmd.pseudoatom(mobile_tmp, pos=list(pos), state=1)

            # measurement object for angle and displacement
            name = get_unused_name('measurement')
            cmd.distance(name, *['%s`%d' % (mobile_tmp, i) for i in [1, 2]])
            cmd.angle(name, *['%s`%d' % (mobile_tmp, i) for i in [3, 1, 4]])

            # CGO arrow for axis of rotation
            visualize_orientation(direction, center1, rg, color='blue')

            cmd.delete(mobile_tmp)

    return angle
示例#10
0
def angle_between_helices(selection1,
                          selection2,
                          method='helix',
                          state1=STATE,
                          state2=STATE,
                          visualize=1,
                          quiet=1):
    '''
DESCRIPTION

    Calculates the angle between two helices

USAGE

    angle_between_helices selection1, selection2 [, method [, visualize]]

ARGUMENTS

    selection1 = string: atom selection of first helix

    selection2 = string: atom selection of second helix

    method = string: function to calculate orientation {default: helix_orientation}

    visualize = 0 or 1: show fitted vector as arrow {default: 1}

EXAMPLE

    fetch 2x19, bsync=0
    select hel1, /2x19//B/23-36/
    select hel2, /2x19//B/40-54/
    angle_between_helices hel1, hel2
    angle_between_helices hel1, hel2, cafit

SEE ALSO

    helix_orientation, loop_orientation, cafit_orientation, angle_between_domains
    '''
    import math

    state1, state2 = int(state1), int(state2)
    visualize, quiet = int(visualize), int(quiet)

    try:
        orientation = globals()[methods_sc[str(method)]]
    except KeyError:
        print('no such method:', method)
        raise CmdException

    if not int(quiet):
        print(' Using method:', orientation.__name__)

    cen1, dir1 = orientation(selection1, state1, visualize, quiet=1)
    cen2, dir2 = orientation(selection2, state2, visualize, quiet=1)

    angle = cpv.get_angle(dir1, dir2)
    angle = math.degrees(angle)

    if not quiet:
        print(' Angle: %.2f deg' % (angle))

    if visualize:
        # measurement object for angle
        center = cpv.scale(cpv.add(cen1, cen2), 0.5)
        tmp = get_unused_name('_')
        for pos in [
                center,
                cpv.add(center, cpv.scale(dir1, 5.0)),
                cpv.add(center, cpv.scale(dir2, 5.0))
        ]:
            cmd.pseudoatom(tmp, pos=list(pos), state=1)
        name = get_unused_name('angle')
        cmd.angle(name, *[(tmp, i) for i in [2, 1, 3]])
        cmd.delete(tmp)

        cmd.zoom('(%s) or (%s)' % (selection1, selection2), 2,
                 state1 if state1 == state2 else 0)

    return angle
示例#11
0
        cmd.select("current_surroundings",
                   "current_surroundings and bindingsite")
        cmd.select("current_polar", "current_surroundings and polar_atoms")
        polar_distance = cmd.dist("polar_contacts",
                                  "ligand",
                                  "polar_atoms",
                                  mode=2)
        print("Polar contact: ")
        print polar_distance, halo.name, halo.resn, halo.resi
        model_polar = cmd.get_model("current_polar")
        for pol in model_polar.atom:
            cmd.select("current_polar", "id %s" % (pol.id))
            # check for halogen bonds, distances 5.0, angles: > 140
            current_distance = cmd.distance("current_distance",
                                            "current_halogen", "current_polar")
            current_angle = cmd.angle("current_angle", "current_neighbor",
                                      "current_halogen", "current_polar")

            if (current_angle >= 140) and (current_distance <= 5.0):
                print("Halogen bond: ")
                print current_distance, current_angle, pol.name, pol.resn, pol.resi

            cmd.delete("current_angle")
            cmd.delete("current_distance")

    # visualizations
    cmd.hide("lines")
    cmd.hide(
        "nonbonded")  # hide all nonbonded atoms, i.e. oxygen of water or ions
    cmd.show("sticks", "ligand")
    cmd.show("lines", "bindingsite")
    cmd.show("nb_spheres", "water_bs")  # nb_spheres = non bonded spheres
示例#12
0
def create_selections(options):

    # Hide everything
    cmd.hide("lines")
    cmd.hide("nonbonded")

    # Protein structure
    cmd.select("protein_structure", "all")

    if options.has_key('no_ligand_selected'):
        # Super basic option, call ligand and chain from organic
        print("Attempting to automatically find ligand")
        ligand_candidates_number = cmd.select("ligand_candidate", "organic")
        candidate_resn = ""
        candidate_chain = ""
        if ligand_candidates_number:
            ligand_candidates_model = cmd.get_model("ligand_candidate")
            for cand_atom in ligand_candidates_model.atom:
                candidate_resn, candidate_chain = cand_atom.resn, cand_atom.chain
                break
        if candidate_resn and candidate_chain:
            print("Automatically detected ligand is '%s' in chain '%s'" %
                  (candidate_resn, candidate_chain))
            options['ligand_name'] = candidate_resn
            options['chain_name'] = candidate_chain
        else:
            raise argparse.ArgumentError(
                "Could not automatically detect ligand. Please make sure a ligand is contained in the provided pdb-file or use the 'Basic Mode'."
            )

    # Ligand
    cmd.select(
        "sele_all_ligands", "organic and chain %s and resn %s" %
        (options['chain_name'], options["ligand_name"]))
    number_of_ligands_selected = cmd.select(
        "sele_ligand", 'organic and chain %s and resn %s and alt a+""' %
        (options['chain_name'], options["ligand_name"]))
    # remove all duplicate conformations
    cmd.remove("sele_all_ligands and not sele_ligand")
    cmd.delete("sele_all_ligands")

    #Feature: If we did not get a correct chain name from the user, we will try to guess through the whole alphabet to find it
    # otherwise the ligand will not appear in the visualization
    if not number_of_ligands_selected:
        #list holding all ascii-letters
        for letter in ascii_uppercase:
            number_of_ligands_selected = cmd.select(
                "sele_ligand",
                'organic and chain %s and resn %s and alt a+""' %
                (letter, options["ligand_name"]))
            if number_of_ligands_selected:
                options['chain_name'] = letter
                break

    cmd.create("ligand", "sele_ligand")
    cmd.delete("sele_ligand")
    cmd.show("sticks", "ligand")
    cmd.color(options["colors"]['color_carbon'], "ligand and e. C")
    cmd.color(options["colors"]['oxygen'], "ligand and e. O")
    cmd.color(options["colors"]['nitrogen'], "ligand and e. N")

    # Cofactor
    if options["cofactor_in_binding_site"]:
        cmd.select(
            "sele_cofactor", "resn %s and chain %s" %
            (options['cofactor_name'], options['chain_name']))
        cmd.create("cofactor", "sele_cofactor")
        cmd.show("sticks", "cofactor")
        cmd.color(options['colors']['color_cofactor'], "cofactor and e. C")
        cmd.delete("sele_cofactor")

    # Surface
    cmd.create("protein_surface", "all")
    cmd.hide("lines", "protein_surface")
    cmd.hide("sticks", "protein_surface")
    cmd.hide("nonbonded", "protein_surface")
    cmd.show("surface", "protein_surface")
    cmd.color(options["colors"]['protein_surface'], "protein_surface")

    # Cartoon
    cmd.copy("protein_cartoon", "protein_surface")
    cmd.hide("surface", "protein_cartoon")
    cmd.show("cartoon", "protein_cartoon")
    cmd.color(options["colors"]['protein_cartoon'], "protein_cartoon")

    # Transparent Cartoon
    cmd.copy("protein_cartoon_transparent", "protein_cartoon")
    cmd.set("cartoon_transparency", options['cartoon_transparency'],
            "protein_cartoon_transparent")

    # 2nd Transparent Cartoon
    cmd.copy("protein_cartoon_transparent_more", "protein_cartoon")
    cmd.set("cartoon_transparency", 0.9, "protein_cartoon_transparent_more")

    # Binding Site
    cmd.select("sele_binding_site",
               "ligand expand %s" % (options['binding_site_radius']))
    cmd.select("sele_binding_site", "br. sele_binding_site")
    cmd.select("sele_binding_site", "sele_binding_site and protein_structure")
    cmd.select("sele_binding_site", "sele_binding_site and not ligand")
    cmd.create("binding_site", "sele_binding_site")
    cmd.delete("sele_binding_site")
    cmd.delete("protein_structure")
    cmd.hide("surface", "binding_site")
    cmd.hide("nonbonded")
    cmd.show("sticks", "binding_site")
    cmd.show("nb_spheres", "binding_site and not resn HOH")
    cmd.color(options["colors"]['binding_site'], "binding_site and e. C")
    cmd.color(options["colors"]['nitrogen'], "binding_site and e. N")
    cmd.color(options["colors"]['oxygen'], "binding_site and e. O")

    # get polar interacting residues in binding site without water
    cmd.select("sele_no_water_binding_site", "binding_site and not resn hoh")
    cmd.select(
        "sele_no_water_binding_site",
        "sele_no_water_binding_site and not resn %s" % options['ligand_name'])
    pairs = polarpairs("sele_no_water_binding_site",
                       "ligand",
                       cutoff=options['binding_site_radius'],
                       name="polar_int_d")
    if pairs:
        cmd.hide("labels", "polar_int_d")
        cmd.color(options['colors']["interaction_polar"], "polar_int_d")
    else:
        print("No polar interaction pairs found")
        options["no_polar_interactions_found"] = True
    cmd.delete("sele_no_water_binding_site")

    interacting_tuples = polartuples(pairs, selection_name="polar_interaction")

    #create a list with selection names of polar_interacting residues
    polar_selection_names = [
        "resi %s and resn %s and chain %s" % tup for tup in interacting_tuples
    ]

    # write the residues into a custom text file,
    with open("%s" % (POLAR_INTERACTIONS_FILENAME, ), "w") as f:
        f.write("#POLAR INTERACTION PARTNERS WITH %s\n" %
                (options['ligand_name'], ))
        f.write("RESI\tRESN\tCHAIN\n")
        for tup in interacting_tuples:
            f.write("%s\t%s\t%s\n" % tup)

    #select all polar interacting residues at once for an overview
    # cmd.select("polar_interacting_residues", "")
    for i, selection_name in enumerate(polar_selection_names):
        if i:  # if i>0 and we already have sele_polar_interacting_residues
            cmd.select(
                "sele_polar_interacting_residues",
                "sele_polar_interacting_residues or %s" % selection_name)
            print(
                "select sele_polar_interacting_residues, sele_polar_interacting_residues or %s"
                % selection_name)
        else:
            cmd.select("sele_polar_interacting_residues", selection_name)
            print("select sele_polar_interacting_residues, %s" %
                  selection_name)

    if not options.has_key("no_polar_interactions_found"):
        cmd.create("polar_interacting_residues",
                   "sele_polar_interacting_residues")
        cmd.delete("sele_polar_interacting_residues")

        cmd.show("sticks", "polar_interacting_residues")
        cmd.color("grey50", "polar_interacting_residues and e. C")
        cmd.color(options["colors"]['nitrogen'],
                  "polar_interacting_residues and e. N")
        cmd.color(options["colors"]['oxygen'],
                  "polar_interacting_residues and e. O")

    # create selection for HOH molecules in binding pocket and make nb_spheres
    if options['water_in_binding_site']:
        cmd.select("sele_water_binding_site", "binding_site and resn hoh")
        water_pairs = polarpairs("sele_water_binding_site",
                                 "ligand",
                                 cutoff=options['binding_site_radius'])

        # further filter polar interactions, discard water molecules that don't interact with binding site and ligand
        # water molecules in interacting tuples are already forming a hbond to ligand
        water_list = []
        water_distance_list = []
        water_polar_tuples_list = []

        if water_pairs:
            # print("water_bridge_candidates ", water_bridge_candidates)
            print("water_bridge_candidates ", water_pairs)
            # water_bridge_selection_names = ["resi %s and resn %s and chain %s and polar_interacting_residues" % tup for
            water_bridge_selection_names = [
                "(%s`%s)" % tup[0] for tup in water_pairs
            ]
            for i, water_selection_name in enumerate(
                    water_bridge_selection_names):
                print("Water bridge prediction \n")
                print("select sele_water%s, %s" % (i, water_selection_name))
                water_selection = cmd.select("sele_water%s" % i,
                                             water_selection_name)
                print("water selection has %s atoms" % water_selection)
                cmd.select(
                    "sele_water_partner%s" % i, "sele_water%s expand %s" %
                    (i, options['binding_site_radius']))
                cmd.select("sele_water_partner%s" % i,
                           "sele_water_partner%s and binding_site" % i)
                cmd.select("sele_water_partner%s" % i,
                           "sele_water_partner%s and not ligand" % i)
                possible_binding_site_partners = cmd.select(
                    "sele_water_partner%s" % i,
                    "sele_water_partner%s and (e. S or e. O or e. N)" % i)

                print("Predicted %s possible_binding_site_partners for %s" %
                      (possible_binding_site_partners, water_selection_name))

                if possible_binding_site_partners:
                    # check if angles allow hbond
                    possible_pairs = polarpairs(
                        "sele_water_partner%s" % i,
                        "sele_water%s" % i,
                        name="d_water_%s" % i,
                        cutoff=options['binding_site_radius'])
                    water_list.append("sele_water%s" %
                                      i)  # contains water molecule
                    water_distance_list.append(
                        "d_water_%s" %
                        i)  # contains distance between water and binding site

                    # creates representation for residues interacting with water in binding site
                    water_polar_tuples_list.append(
                        polartuples(possible_pairs,
                                    selection_name="h20_inter_%s" % i))
                    print("water_polar_tuples_list", water_polar_tuples_list)
                    cmd.delete("sele_water_partner%s" % i)

                else:
                    cmd.delete("sele_water%s" % i)

            # print("water_list", water_list)
            # print("water_distance_list", water_distance_list)
            # print("water_polar_tuples_list", water_polar_tuples_list)
            # now only show water from water list
            water_to_output_list = []

            # list of water selections to enable in the movie
            water_to_enable_list = []
            for water_index, (water_name, water_distance_name) in enumerate(
                    zip(water_list, water_distance_list)):
                # number_of_water = cmd.select("sele_water_binding_site", "binding_site and resn hoh")
                number_of_water = cmd.select("sele_water_binding_site",
                                             water_name)
                if number_of_water:
                    cmd.create("water_%s" % water_index,
                               "sele_water_binding_site")
                    cmd.show("nb_spheres", "water_%s" % water_index)

                    #get identifier of water for polar_interactions written to file
                    w_model = cmd.get_model("water_%s" % water_index)
                    for water_mol in w_model.atom:
                        water_to_output_list.append(
                            (water_mol.resi, water_mol.resn, water_mol.chain))
                    water_to_enable_list.append("water_%s" % water_index)
                    water_to_enable_list.append(water_distance_name)

                cmd.color(options['colors']["interaction_polar"],
                          water_distance_name)
                cmd.hide("label", water_distance_name)
                cmd.delete(water_name)
            cmd.delete("sele_water_binding_site")

            #append water molecules to polar interactions file
            with open("%s" % (POLAR_INTERACTIONS_FILENAME, ), "a+") as f:
                for tup in water_to_output_list:
                    # f.write("RESI\tRESN\tCHAIN\n")
                    f.write("%s\t%s\t%s\n" % tup)

            # residues interacting with water and
            options["water_to_enable_list"] = water_to_enable_list

    # Halogen Bond
    if options['check_halogen_interaction']:
        halogen_bond_selections = []
        halogen_interaction_partners = []
        for halogen in ["Cl", "Br", "I"]:
            number_of_halogen = cmd.select("sele_%s_interaction" % halogen,
                                           "ligand and e. %s" % halogen)
            print("We have %s %s atoms in our ligand" %
                  (number_of_halogen, halogen))
            if number_of_halogen:

                cmd.select("sele_candidates",
                           "sele_%s_interaction expand 4.5" % halogen)
                cmd.select("sele_candidates",
                           "sele_candidates and (e. O or e. S)")
                number_of_candidates = cmd.select(
                    "sele_candidates",
                    "sele_candidates and binding_site and not ligand")

                print("We have %s potential candidates for %s bonds" %
                      (number_of_candidates, halogen))
                if number_of_candidates:
                    # if angle ~160 and distance up to 4.5 A
                    # if angle 150-160 and distance up to 4.0 A
                    candidate_model = cmd.get_model("sele_candidates")
                    for atom in candidate_model.atom:
                        print("Candidate from model = %s %s" %
                              (atom.resn, atom.index))

                    cmd.select("sele_halo", "ligand and e. %s" % halogen)
                    model_br = cmd.get_model("sele_halo")
                    candidate_model = cmd.get_model("sele_candidates")
                    for i, atom in enumerate(model_br.atom):
                        # print("i= %s" % i)
                        sele_halo = cmd.select("sele_halo%s" % i,
                                               "id %s and ligand" % atom.id)
                        # model_sele_halo = cmd.get_model("sele_halo%s" % i)
                        sele_halo_c = cmd.select("sele_halo%s_c" % i,
                                                 "neighbor sele_halo%s" % i)
                        # print("sele_halo %s" % sele_halo, "sele_halo_c %s" % sele_halo_c)
                        for j, oxygen_or_sulfur in enumerate(
                                candidate_model.atom):
                            cmd.select(
                                "ox_or_sulf_%s" % j,
                                "id %s and binding_site" % oxygen_or_sulfur.id)
                            distance = cmd.distance(
                                "halogen_bond_%s_%s_%s" % (halogen, i, j),
                                "sele_halo%s" % i, "ox_or_sulf_%s" % j)
                            angle = cmd.angle(
                                "halogen_bond_angle_%s_%s_%s" %
                                (halogen, i, j), "sele_halo%s_c" % i,
                                "sele_halo%s" % i, "ox_or_sulf_%s" % j)
                            print("Distance = %s, angle = %s" %
                                  (distance, angle))
                            if (distance <= 4.5 and angle >= 160.0) or (
                                    distance <= 4.0 and angle >= 150.0):
                                print(
                                    "We have a halogen bond: halogen_bond_angle_%s_%s_%s"
                                    % (halogen, i, j))
                                cmd.hide(
                                    "label",
                                    "halogen_bond_%s_%s_%s" % (halogen, i, j))
                                cmd.hide(
                                    "label", "halogen_bond_angle_%s_%s_%s" %
                                    (halogen, i, j))
                                cmd.color(
                                    "cb_yellow",
                                    "halogen_bond_%s_%s_%s" % (halogen, i, j))
                                cmd.color(
                                    "cb_yellow",
                                    "halogen_bond_angle_%s_%s_%s" %
                                    (halogen, i, j))
                                #halogen_bond_selections.append("halogen_bond_%s_%s_%s" % (halogen, i, j))
                                halogen_bond_selections.append(
                                    "halogen_bond_angle_%s_%s_%s" %
                                    (halogen, i, j))
                                cmd.create("halogen_interaction_partner%s" % i,
                                           "br. ox_or_sulf_%s" % j)
                                halogen_interaction_partners.append(
                                    "halogen_interaction_partner%s" % i)
                            else:
                                print("No halogen bond, deleting selection!\n")
                                cmd.delete("halogen_bond_angle_%s_%s_%s" %
                                           (halogen, i, j))
                            # always delete bond, angle is enough
                            cmd.delete("halogen_bond_%s_%s_%s" %
                                       (halogen, i, j))
                            cmd.delete("ox_or_sulf_%s" % j)
                        #cleanup selections
                        cmd.delete("sele_halo%s" % i)
                        cmd.delete("sele_halo%s_c" % i)
                        cmd.delete("sele_halo%s_c" % i)
                        cmd.delete("sele_candidates")
                    cmd.delete("sele_halo")
            cmd.delete("sele_%s_interaction" % halogen)

        # check whether we found any halogen bond interactions
        # if halogen_bond_selections has more than one element, it will
        #   evaluate as true, if empty it will be false
        if halogen_bond_selections:
            options['halogen_bond_selections'] = halogen_bond_selections
            options[
                'halogen_interaction_partners'] = halogen_interaction_partners
示例#13
0
def ens_measure(pk1 = None,
                pk2 = None,
                pk3 = None,
                pk4 = None,
                name = None,
                log = None,
                verbose = True):
    '''
DESCRIPTION

    Statistics from ensemble structure measurements.  If:
      2 selections give = distance
      3 selections give = angle
      4 selections give = dihedral angle

USAGE

    ens_measure pk1, pk2, pk3, pk4, name, log, verbose

ARGUMENTS

    log = name of log file
    verbose = prints individual measurements

 EXAMPLE

    ens_measure atom1, atom2, name = 'measure', log 'ens.log'
  '''
    print >> log, '\nEnsemble measurement'

    if [pk1, pk2, pk3, pk4].count(None) > 2:
        print '\nERROR: Please supply at least 2 seletions'
        return
    number_models = cmd.count_states(pk1)
    measurements = []

    # distance
    if [pk1, pk2, pk3, pk4].count(None) == 2:
        print >> log, 'Distance'
        if name == None: name = 'ens_distance'
        # display as object
        cmd.distance(name = name,
                     selection1 = pk1,
                     selection2 = pk2)

        # get individual values
        for n in xrange(number_models):
            measurements.append( cmd.get_distance(pk1, pk2, n+1) )
        assert len(measurements) == number_models

    # angle
    if [pk1, pk2, pk3, pk4].count(None) == 1:
        print >> log, 'Angle'
        # display as object
        if name == None: name = 'ens_angle'
        cmd.angle(name = name,
                  selection1 = pk1,
                  selection2 = pk2,
                  selection3 = pk3)

        # get individual values
        for n in xrange(number_models):
            measurements.append( cmd.get_angle(atom1 = pk1,
                                               atom2 = pk2,
                                               atom3 = pk3,
                                               state = n+1) )
        assert len(measurements) == number_models

    # Dihedral angle
    if [pk1, pk2, pk3, pk4].count(None) == 0:
        print >> log, 'Dihedral angle'
        # display as object
        if name == None: name = 'ens_dihedral'
        cmd.dihedral(name = name,
                  selection1 = pk1,
                  selection2 = pk2,
                  selection3 = pk3,
                  selection4 = pk4)

        # get individual values
        for n in xrange(number_models):
            measurements.append( cmd.get_dihedral(atom1 = pk1,
                                                  atom2 = pk2,
                                                  atom3 = pk3,
                                                  atom4 = pk4,
                                                  state = n+1) )
        assert len(measurements) == number_models

    # print stats
    if verbose:
        print >> log, ' State  Value'
        for n, measurement in enumerate(measurements):
            print >> log, '  %4d  %3.3f '%(n+1, measurement)

    print >> log, '\nMeasurement statistics'
    print_array_stats(array                 = measurements,
                      log                   = log)
示例#14
0
def find_halogen_bonds():
    halogen_bonds = []
    cmd.select("bindingsite1", "ligand_a expand 5.0"
               )  # expand selection by 5 angstrom, extend = extend along bonds
    cmd.select(
        "bindingsite1",
        "br. bindingsite")  # br extends the selection to the full residue
    cmd.select("bindingsite1", "bindingsite and not ligand"
               )  # br extends the selection to the full residue
    cmd.select(
        "water",
        "resn hoh")  # resn = residues name, hoh = name of water molecules
    cmd.select("water_bs", "water and bindingsite")

    #select all relevant halogen atoms
    number_of_halogens = cmd.select("hal", "hal and ligand_a")
    cmd.select("polar_atoms", "e. O or e. N or e. S")

    model_halogen = cmd.get_model("hal")  # create model for halogen selection
    for halo in model_halogen.atom:
        print("A")
        cmd.select("current_halogen",
                   "(e. I or e. Cl or e. Br) and id %s" % (halo.id))
        cmd.select("current_neighbor", "current_halogen extend 1")
        cmd.select("current_neighbor",
                   "current_neighbor and not current_halogen")
        cmd.select("current_neighbor", "neighbor current_halogen")

        cmd.select("current_surroundings", "current_halogen expand 5.0")
        cmd.select("current_surroundings",
                   "current_surroundings and bindingsite1")
        cmd.select("current_polar", "current_surroundings and polar_atoms")

        model_polar = cmd.get_model("current_polar")
        for pol in model_polar.atom:
            cmd.select("current_polar",
                       "not water and polar_atoms and id %s" % (pol.id))
            # check for halogen bonds, distances 5.0, angles: > 140
            current_distance = cmd.distance("current_distance",
                                            "current_halogen", "current_polar")
            current_angle = cmd.angle("current_angle", "current_neighbor",
                                      "current_halogen", "current_polar")
            print(current_distance, current_angle)
            if (current_angle >= 140) and (current_distance <= 5.0):
                halogen_bonds.append((pol.resn, pol.resi, pol.id,
                                      current_distance, current_angle))
                #Append fitting halogen bonds to list

            cmd.delete("current_angle")
            cmd.delete("current_distance")

    #Clear up selections
    cmd.delete("current_halogen")
    cmd.delete("current_neighbor")
    cmd.delete("water")
    cmd.delete("water_bs")
    cmd.delete("current_polar")
    cmd.delete("current_surroundings")
    cmd.delete("bindingsite1")

    #Sort the list by distance
    halogen_bonds = sorted(halogen_bonds, key=lambda x: x[3])

    return halogen_bonds
示例#15
0
def angle_between_domains(selection1, selection2, method='align',
        state1=STATE, state2=STATE, visualize=1, quiet=1):
    '''
DESCRIPTION

    Angle by which a molecular selection would be rotated when superposing
    on a selection2.

    Do not use for measuring angle between helices, since the alignment of
    the helices might involve a rotation around the helix axis, which will
    result in a larger angle compared to the angle between helix axes.

USAGE

    angle_between_domains selection1, selection2 [, method ]

ARGUMENTS

    selection1 = string: atom selection of first helix

    selection2 = string: atom selection of second helix

    method = string: alignment command like "align" or "super" {default: align}

EXAMPLE

    fetch 3iplA 3iplB, async=0
    select domain1, resi 1-391
    select domain2, resi 392-475
    align 3iplA and domain1, 3iplB and domain1
    angle_between_domains 3iplA and domain2, 3iplB and domain2

SEE ALSO

    align, super, angle_between_helices
    '''
    import math

    try:
        import numpy
    except ImportError:
        print ' Error: numpy not available'
        raise CmdException

    state1, state2 = int(state1), int(state2)
    visualize, quiet = int(visualize), int(quiet)

    if cmd.is_string(method):
        try:
            method = cmd.keyword[method][0]
        except KeyError:
            print 'no such method:', method
            raise CmdException

    mobile_tmp = get_unused_name('_')
    cmd.create(mobile_tmp, selection1, state1, 1,  zoom=0)
    try:
        method(mobile=mobile_tmp, target=selection2, mobile_state=1,
                target_state=state2, quiet=quiet)
        mat = cmd.get_object_matrix(mobile_tmp)
    except:
        print ' Error: superposition with method "%s" failed' % (method.__name__)
        raise CmdException
    finally:
        cmd.delete(mobile_tmp)

    try:
        # Based on transformations.rotation_from_matrix
        # Copyright (c) 2006-2012, Christoph Gohlke

        R33 = [mat[i:i+3] for i in [0,4,8]]
        R33 = numpy.array(R33, float)

        # direction: unit eigenvector of R33 corresponding to eigenvalue of 1
        w, W = numpy.linalg.eig(R33.T)
        i = w.real.argmax()
        direction = W[:, i].real

        # rotation angle depending on direction
        m = direction.argmax()
        i,j,k,l = [
            [2,1,1,2],
            [0,2,0,2],
            [1,0,0,1]][m]
        cosa = (R33.trace() - 1.0) / 2.0
        sina = (R33[i, j] + (cosa - 1.0) * direction[k] * direction[l]) / direction[m]

        angle = math.atan2(sina, cosa)
        angle = abs(math.degrees(angle))
    except:
        print ' Error: rotation from matrix failed'
        raise CmdException

    if not quiet:
        try:
            # make this import optional to support running this script standalone
            from .querying import centerofmass, gyradius
        except (ValueError, ImportError):
            gyradius = None
            try:
                # PyMOL 1.7.1.6+
                centerofmass = cmd.centerofmass
            except AttributeError:
                centerofmass = lambda s: cpv.scale(cpv.add(*cmd.get_extent(s)), 0.5)

        center1 = centerofmass(selection1)
        center2 = centerofmass(selection2)
        print ' Angle: %.2f deg, Displacement: %.2f angstrom' % (angle, cpv.distance(center1, center2))

        if visualize:
            center1 = numpy.array(center1, float)
            center2 = numpy.array(center2, float)
            center = (center1 + center2) / 2.0

            if gyradius is not None:
                rg = numpy.array(gyradius(selection1), float)
            else:
                rg = 10.0

            h1 = numpy.cross(center2 - center1, direction)
            h2 = numpy.dot(R33, h1)
            h1 *= rg / cpv.length(h1)
            h2 *= rg / cpv.length(h2)

            for pos in [center1, center2, center1 + h1, center1 + h2]:
                cmd.pseudoatom(mobile_tmp, pos=list(pos), state=1)

            # measurement object for angle and displacement
            name = get_unused_name('measurement')
            cmd.distance(name, *['%s`%d' % (mobile_tmp, i) for i in [1,2]])
            cmd.angle(name, *['%s`%d' % (mobile_tmp, i) for i in [3,1,4]])

            # CGO arrow for axis of rotation
            visualize_orientation(direction, center1, rg, color='blue')

            cmd.delete(mobile_tmp)

    return angle
示例#16
0
文件: ens_tools.py 项目: dials/cctbx
def ens_measure(pk1=None,
                pk2=None,
                pk3=None,
                pk4=None,
                name=None,
                log=None,
                verbose=True):
    '''
DESCRIPTION

    Statistics from ensemble structure measurements.  If:
      2 selections give = distance
      3 selections give = angle
      4 selections give = dihedral angle

USAGE

    ens_measure pk1, pk2, pk3, pk4, name, log, verbose

ARGUMENTS

    log = name of log file
    verbose = prints individual measurements

 EXAMPLE

    ens_measure atom1, atom2, name = 'measure', log 'ens.log'
  '''
    print('\nEnsemble measurement', file=log)

    if [pk1, pk2, pk3, pk4].count(None) > 2:
        print('\nERROR: Please supply at least 2 seletions')
        return
    number_models = cmd.count_states(pk1)
    measurements = []

    # distance
    if [pk1, pk2, pk3, pk4].count(None) == 2:
        print('Distance', file=log)
        if name == None: name = 'ens_distance'
        # display as object
        cmd.distance(name=name, selection1=pk1, selection2=pk2)

        # get individual values
        for n in range(number_models):
            measurements.append(cmd.get_distance(pk1, pk2, n + 1))
        assert len(measurements) == number_models

    # angle
    if [pk1, pk2, pk3, pk4].count(None) == 1:
        print('Angle', file=log)
        # display as object
        if name == None: name = 'ens_angle'
        cmd.angle(name=name, selection1=pk1, selection2=pk2, selection3=pk3)

        # get individual values
        for n in range(number_models):
            measurements.append(
                cmd.get_angle(atom1=pk1, atom2=pk2, atom3=pk3, state=n + 1))
        assert len(measurements) == number_models

    # Dihedral angle
    if [pk1, pk2, pk3, pk4].count(None) == 0:
        print('Dihedral angle', file=log)
        # display as object
        if name == None: name = 'ens_dihedral'
        cmd.dihedral(name=name,
                     selection1=pk1,
                     selection2=pk2,
                     selection3=pk3,
                     selection4=pk4)

        # get individual values
        for n in range(number_models):
            measurements.append(
                cmd.get_dihedral(atom1=pk1,
                                 atom2=pk2,
                                 atom3=pk3,
                                 atom4=pk4,
                                 state=n + 1))
        assert len(measurements) == number_models

    # print stats
    if verbose:
        print(' State  Value', file=log)
        for n, measurement in enumerate(measurements):
            print('  %4d  %3.3f ' % (n + 1, measurement), file=log)

    print('\nMeasurement statistics', file=log)
    print_array_stats(array=measurements, log=log)
示例#17
0
ang_pairs = []
restraints = []

for filename in filenames:
    with open(filename, 'r') as f:
        lines = f.readlines()
        lines = list(filter(filter_func, lines))
        ang_pairs.extend(list(map(map_func, lines)))
        restraints.extend(list(map(map_func2, lines)))

out_lines = []
for ang_pair, restraint in zip(ang_pairs, restraints):
    group1 = "(id %d)" % ang_pair[0]
    group2 = "(id %d)" % ang_pair[1]
    group3 = "(id %d)" % ang_pair[2]
    cmd.angle("%d-%d-%d" % ang_pair, group1, group2, group3)
    resns = []
    resis = []
    atoms = []
    cmd.iterate("id %d+%d+%d" % ang_pair, "resns.append(resn)")
    cmd.iterate("id %d+%d+%d" % ang_pair, "resis.append(resi)")
    cmd.iterate("id %d+%d+%d" % ang_pair, "atoms.append(name)")
    angle = cmd.get_angle(group1, group2, group3)
    out_lines.append(
        "[ %s%s(%s)-%s%s(%s)-%s%s(%s) ~ %.2f degree (%s, %s, %s) ]\n" %
        ((resns[0], resis[0], atoms[0], resns[1], resis[1], atoms[1], resns[2],
          resis[2], atoms[2], angle) + restraint))
    out_lines.append("%d %d %d\n" % ang_pair)

# write dis_pairs to distance_pairs.ndx for analysis
with open("angle_out.ndx", 'w') as f: