P-P docking with suitable constraint type

Member Site › Forums › Rosetta 3 › Rosetta 3 – Applications › P-P docking with suitable constraint type

Viewing 1 reply thread
  • Author
    Posts
    • November 14, 2012 at 2:03 am #1462
      Anonymous

        Hi, I’ve a question about protein docking with constraits.
        Biochemical assay proves that a specific residue pair between two monomers is for sure to be close enough, for which FlatHarmonic constraint type can be used.
        However, another 17 inter residue pairs were identified by chemical cross-linking. 1. not all these 17 pairs are reliable, some might be experimental artificial, but we don`t konw which ones. 2. Based on konwn monomer structures, we can find some of these 17 pairs can not be satisfied at the same time, indicating a plausibility of multiple binding modes.
        So I hope to find several poses which can fulfil these 17 pairs as many as possible. But I am not sure which constraint type should be applied for these 17 pairs.
        I checked the constraint types and function types in manual. BOUNDED type might be a choice, but for x > ub+rswitch*sd, in my case the calculated constraint had better to be a constant, rather than a linear increase.
        Is there some existing constraint type suitable for my case ? Or I can only add a modified BOUNDED type by myself ?
        Thanks very much !

      • November 14, 2012 at 2:30 am #8088
        Anonymous

          If you include all 17 pairs at with similar SD, then Rosetta will treat all of them isoenergetically and naturally favor conformations that satisfy as many constraints as possible.

          The most straightforward way to alter BOUNDED in the way you want is to combine it with the CONSTANT func inside an AmbiguousConstraint:

          AmbiguousConstraint
          AtomPairConstraint Atom1 Res1 Atom2 Res2 BOUNDED lb ub sd rswitch tag
          AtomPairConstraint Atom1 Res1 Atom2 Res2 CONSTANTFUNC value
          END_AMBIGUOUS

          Where “value” is set at the capped value you want for your BOUNDED constraint. With CONSTANTFUNC in the ambiguous constraint, the two together will never return value greater than the constant, letting you get the flat value instead of a linear increase that you want.

          You can also feel free to just modify the internals of BOUNDED in the code, or make a copy of it and modify your copy.

          It is possible to choose groups of your 17 constraints within AmbiguousConstraints (separately from the CONSTANTFUNC pairing, so you’d have multiple layers of AmbiguousConstraint) if you think some constraints are either-or, so that only one needs to be satisfied at a time.

        • November 14, 2012 at 4:12 am #8089
          Anonymous

            Thanks very much for your kind reply. I will try AmbiguousConstraint to combine BOUNDED and CONSTANT.
            Could you please give an introduction of “multiple layers of AmbiguousConstraint”? Does it means that a pose will be accepted if at least one of the 17 constraints is satisfied and no penalty will be given for unsatisfying of the other 16 constraints ?

          • November 14, 2012 at 4:30 am #8090
            Anonymous

              In general, AmbiguousConstraint takes a bunch of constraints, evaluates all of them, and returns only the lowest-valued (most-satisfied) one. Let’s say, of your 17 constraints, you know that two in particular cannot be satisfied simultaneously. You could then put them in an AmbiguousConstraint:

              AmbiguousConstraint
              Experimental_constraint_1
              Experimental_constraint_2
              END_AMBIGUOUS

              But, as you said, you want the individual constraints to cap off at a flat value instead of increasing linearly indefinitely. So, each of the Experimental_constraint_# above is a whole BOUNDED+CONSTANT pair as in my earlier post:

              #this constraint ensures that either experimental data point 1 or 2 is satisfied, but not necessarily both
              AmbiguousConstraint

              #This subconstraint is for Experimental_constraint_1
              AmbiguousConstraint
              AtomPairConstraint Atom1 Res1 Atom2 Res2 BOUNDED lb ub sd rswitch Experimental_constraint_1
              AtomPairConstraint Atom1 Res1 Atom2 Res2 CONSTANTFUNC value
              END_AMBIGUOUS

              #This subconstraint is for Experimental_constraint_2
              AmbiguousConstraint
              AtomPairConstraint Atom1 Res1 Atom2 Res2 BOUNDED lb ub sd rswitch Experimental_constraint_2
              AtomPairConstraint Atom1 Res1 Atom2 Res2 CONSTANTFUNC value
              END_AMBIGUOUS

              END_AMBIGUOUS

              You can go on making similar constructs with AmbiguousConstraint and MultiConstraint (which works the same, except it returns the sum of ALL subconstraints instead of just the lowest value) to encode whatever logic you need for your 17 not-all-compatible data points.

              For your direct question, “Does it means that a pose will be accepted if at least one of the 17 constraints is satisfied and no penalty will be given for unsatisfying of the other 16 constraints ?” – if you put all 17 within one wrapping AmbiguousConstraint, yes, that is what it would do.

            • November 16, 2012 at 9:03 am #8100
              Anonymous

                Thanks smlewis !
                Whether the calculated “atom_pair_constraint” is direct added into “total_score” with a weight of 1 ?
                If “total_score” is around -60 ~ -90, which level of “atom_pair_constraint” is suitable for a reasonable and effective bias sampling ?
                I have tested AmbiguousConstraint to combine BOUNDED and CONSTANTFUNC type with 1 distance pair. Here is part of the output score file
                “””
                SEQUENCE:
                SCORE: total_score rms atom_pair_constraint cen_rms interchain_contact interchain_env interchain_pair interchain_vdw st_rmsd description
                SCORE: -84.431 34.880 0.025 34.880 -5.000 -77.426 -2.030 0.000 32.556 inp_0125
                SCORE: -83.578 40.096 0.134 40.096 -12.000 -72.405 0.045 0.648 37.506 inp_0186
                SCORE: -78.531 38.944 0.178 38.944 -2.000 -78.131 1.423 0.000 37.331 inp_0195
                …
                “””
                I don`t know whether my calculated “atom_pair_constraint” (less than 0.25) is too small for “total_score” around -80 ? Whether my constraint parameters are suitable for a reasonable and effective biasd sampling ?
                Here is my constraint input file:
                “””AmbiguousConstraint
                AtomPair CA 6A CA 240B BOUNDED 0 24 10 0.5 xlink
                AtomPair CA 6A CA 240B CONSTANTFUNC 0.25
                END_AMBIGUOUS
                “””
                Actually, “CONSTANTFUNC 0.25” resulted in sampling of many poses with large distance of CA-6A CA-240B. However when rswitch = 0.5, as suggested to ensure continuity in the derivation, the boundary constraint value at x = ub + rswitch*sd is 0.25.
                ~~~~~~
                Besides, my proteins are not very small. So I chose to use low resolution docking mode with alpha-carbon distance constraint. I don`t know whether centroid sidechain will cause problems for CA distance constraint.
                Thanks very much !!

              • November 16, 2012 at 7:20 pm #8104
                Anonymous

                  Centroid mode has all the backbone heavy atoms, so CA-CA atom pair constraints should be fine. (In fact, that’s exactly the type of constraints used in homology modeling, so you can be sure it’s been tested heavily for both centroid and full atom protocols.) You will, however, need to make sure that the constraints are loaded for that mode. If you’re using -constraints:cst_fa_file, it won’t work so well, as the “fa” stands for full atom. The -constraints:cst_file flag is the one used for centroid mode constraints. (That is, assuming the particular protocol you’re using is set up to load the centroid constraints.)

                  Regarding the size of the constraint, it doesn’t really depend on the absolute magnitude of the total score, but rather the difference in energies between the “good” and “bad” structures. Having a hard limit of 0.25 on your constraint (with a constraint weight of 1) effectively means that you’re okay with a “good” structure being up to 0.25 REU worse than the “bad” structure, when scored with a no-constraints energy function. To put it another way, you’re willing to take an 0.25 REU hit in Rosetta energy, as long as the Calphas are in the appropriate location.

                  So if the difference between the “good” and “bad” structures is 0.2 REU, a constraint size of 0.25 should be fine. But if the difference is 0.5 REU, you’re still going to end up with bad structures, unless you upweight your constraints. – Note this is only if you have the single constraint. If you have multiple simultaneous constraints, the size of the discrimination will be correspondingly enlarged.

              • Author
                Posts
              Viewing 1 reply thread
              • You must be logged in to reply to this topic.