View All Pages

Myosin Simulation Race

What this described

This describes a simplified model of a motor protein such as myosin V walking on an actin filament. This has been the subject of a lot of recent experimental and theoretical investigation. The model that is described below strips down a lot of the less important features so as to make clear just how simple a motor needs to be.

To Install

You'll need to have the gnu C compiler installed, which you probably do if you've managed to run the simulations up to now. You have to determine if you have a 32 or 64 bit version of python installed. Try typing "python --version" in a terminal to determine this.

If you're on windows 10 using the windows linux subsystem,  and python 2, you need to  additionally install:

sudo apt-get install g++-multilib

Unzip the hw8/2heads/2heads.zip. Then if you have 32 bit python, type:

make

If you're on 64 bit, type instead:

make BITS=""

(Most people these days will have 64 bit software and hardware).

 



If all goes well (you might see some warnings though), you should now be able to run my.py in python or ipython. If this fails and you have a relatively recent mac operating system, you might try to untar this
    

Links to an external site. file with the executable and everything installed. This can be temperamental!


The Model


The model is similar to those you've studied previously but with some extra bells and whistles. It's still a Langevin simulation of a chain with fixed link lengths and stiffness, but now interacts with a periodic 1D array of sites. The ends of the molecule are its "heads".


    

  • 1. The heads bind to these sites at an angle (that you can adjust). This is crucial in getting the molecule to walk in one direction.
    • 

  • 2. If all the molecule did was to bind, it wouldn't do much, but this is where ATP comes in. ATP "energizes" a bound head that now gets loose and flops about. Note ATP can bind to either head, so the motion isn't necessarily always forwards.
    • 

  • 3. Now that a head is loose and the ATP has got split to become ADP. The head now becomes attracted to binding sites again.
    • 

  • 4. Eventually the free head will fluctuate until it docks with another binding site. And the system has moved forward and is now in stage 1, above. Now an ATP molecule binds to a head as in stage 2 and the whole cycle repeats itself.
    • 



You can simplify the way you think about this further and say that there are two parameters controlling ATP binding. Essentially what's happening is that either the head is sticky or it isn't. The rate at which a head comes off binding sites, is the rate it changes from sticky to not being sticky. If that rate of is very low, heads are stuck on binding sites for a long time. But once they come off, they'll be a rate at which new ATP molecules come on. You'd want that to be pretty fast or you miss out on the chances to rebind to a head to some binding site again. So the two parameters to play with here are ComingOffRate and ComingOnRate.


You can also vary the number of monomers to make it larger, (ChainLength), and you can vary the stiffness. The stiffness for every monomer is adjustable through the SpringConstantArray. Note that to get a stiff chain you've got to make these values negative. This is because this is implemented by adding repulsive interactions between monomers separated by two links.


Various bad things can happen.


    

  • The molecule can unbind on both sides, causing it to float off into never-never-land. The program catches that when it happens. If you set the coming off rate too high, that's what will happen.
    • 

  • The molecule can decide not too move for a very long time. That's what'll happen if the coming
    off rate is too small
    • 

  • The molecule is too straight and can't bind at two sites. That'll happen if the |stiffness| is too large
    • 

  • The molecule moves backwards way too much That's what'll happen if the |stiffness| is too small
    • 



If it doesn't drop off on its way to the finish line, the program will tell you how ,much time it takes to run the race, going 30 units. Your job is to adjust all the parameters to make the time as small as possible.


These are the things you might try varying:


    

  • ComingOnRate
    • 

  • ComingOffRate
    • 

  • VActinDepth (Strength of binding to the actin)
    • 

  • Binding Angle (in radians)
    • 

  • SpringConstant and SpringConstantArray
    • 

  • StepLength (length of a link)
    • 

  • ChainLength (= 1 + number of links.)
    • 



These are things that you probably shouldn't touch (though saying this will probably make you curious, but this won't cause smoke to come out.)


    

  • Don't fool with RK_StepSize (unless it seems to be blowing up because you've made
    some parameter too big.)
    • 

  • Don't fool with ActinSpacing.
    • 

  • Don't fool with Damping (speeds up code), SoftCore, HardCore, NNConstant, or ExtForce (that's for another project, not this quarter.)
    • 



Biology


    

      

    • Suppose you want to design a motor protein that rarely falls off. That is, it can take many steps before accidentally detaching. According to the above model, how will this affect its speed?
      • 

    



Suppose now you want to design a motor protein that has a large stall force. How will this affect its speed?


Note: The stall force is a measure of how strong the motor protein is. If you apply a force, say with optical tweezers, to the the motor, in the opposite direction of motion, then this is the force that will cause the motor to stop moving forward.


    

  • Discuss the above questions for myosin-V.
    •