# ActinFriction

## README

`ActinFriction`

— Module**Actin rings dynamics simulation package**

A Julia package for simulating the dynamics of passively crosslinked actin rings.

This package allows the SDEs described in Ref. 1 to be solved, and provides methods for directly calculating the friction coefficients described in the same paper.

**Installation**

The package can be installed by starting the Julia REPL, typing `]`

to enter package mode, and running

`add ActinFriction`

to install from the General registry, or by running

`add https://github.com/cumberworth/ActinFriction.jl`

to install directly from the development repository.

A related python package, actinfrictionpy, includes code for analyzing and plotting the output from these ...

**References**

[1] A. Cumberworth and P. R. ten Wolde, Constriction of actin rings by passive crosslinkers, arXiv:2203.04260 [physics.bio-ph].

**Links**

`R_to_lambda`

`RingParams`

`bending_force`

`condensation_force`

`entropic_force`

`equilibrium_occupancy`

`equilibrium_ring_radius`

`force_L_to_R`

`free_energy_barrier_Nd_exact`

`free_energy_barrier_Nd_exp`

`free_energy_barrier_cX`

`friction_coefficient_Nd_exact`

`friction_coefficient_Nd_exp`

`friction_coefficient_cX`

`kramers_r0`

`l_to_lambda`

`lambda_to_R`

`lambda_to_l`

`savename`

`solve_and_write_ring_Nd_contin_exp`

`solve_and_write_ring_Nd_contin_exp_noise`

`solve_and_write_ring_Nd_discrete_exact`

`solve_and_write_ring_Nd_discrete_exact_noise`

`solve_and_write_ring_Nd_discrete_exp`

`solve_and_write_ring_Nd_discrete_exp_noise`

`solve_and_write_ring_cX`

`solve_and_write_ring_cX_noise`

## API

`ActinFriction.RingParams`

— Type`k01::Float64`

: Per site rate constant of initial crosslinker binding (s^-1)`r01::Float64`

: Per site rate of initial crosslinker binding (M^-1 s^-1)`r10::Float64`

: Per site rate (constant) of singly bound crosslinker unbinding (s^-1)`r12::Float64`

: Per site rate (constant) of singly bound crosslinker doubly binding (s^-1)`r21::Float64`

: Per site rate (constant) of doubly bound crosslinker unbinding one head (s^-1)`deltas::Float64`

: Spacing between binding sites on a filament (m)`deltad::Float64`

: Spacing for doubly bound crosslinkers (m)`k::Float64`

: Spring constant of crosslinker (N m^-1)`T::Float64`

: Temperature (K)`Nf::Int64`

: Number of filaments`Nsca::Int64`

: Number of scaffold filaments`EI::Float64`

: Bending rigidity (N m^2)`Lf::Float64`

: Filament length (m)`r0::Float64`

: Jump rate prefactor`Df::Float64`

: Actin filament diameter (m)`eta::Float64`

: Viscosity of fluid (kg m^-1 s^-1)`Ds::Float64`

: Diffusion coefficient of singly bound crosslinkers on filament (m^2 s^-1)`KsD::Float64`

: Dissociation constant for single crosslinker binding from solution (M)`KdD::Float64`

: Dissociation constant for double crosslinker binding from solution (M)`cX::Float64`

: Crosslinker concentration (M)`n::Float64`

: Number of overlaps moving collectively during constriction`tend::Float64`

: Duration of dynamics (s)`lambda0::Float64`

: Initial lambda`Ndtot0::Float64`

: Initial total doubly-bound crosslinkers`interval::Float64`

: Write inteval for mean and variance of stochastic simulations`zeta::Float64`

: Friction coefficient

Parameters for actin-anillin ring system.

`ActinFriction.R_to_lambda`

— Method```
R_to_lambda(R, p::RingParams) -> Any
```

Convert from ring radius to lambda.

`ActinFriction.bending_force`

— Method```
bending_force(lambda, p::RingParams) -> Any
```

Calculate current bending force on L in a ring.

`ActinFriction.condensation_force`

— Method```
condensation_force(p::RingParams) -> Float64
```

Calculate condenstation force on L in a ring.

Since the condenstation force only depends on the total number of overlaps, it is constant as the ring constricts.

`ActinFriction.entropic_force`

— Method```
entropic_force(lambda, Ndtot, p::RingParams) -> Any
```

Calculate current entropic force on L for a ring.

`ActinFriction.equilibrium_occupancy`

— Method```
equilibrium_occupancy(p::RingParams) -> Float64
```

Calculate the equilibrium occupancy.

`ActinFriction.equilibrium_ring_radius`

— Method```
equilibrium_ring_radius(p::RingParams) -> Float64
```

Calculate the equilibrium radius of a ring.

`ActinFriction.force_L_to_R`

— Method```
force_L_to_R(force, p::RingParams) -> Any
```

Convert from force on L to force on R.

`ActinFriction.free_energy_barrier_Nd_exact`

— Method```
free_energy_barrier_Nd_exact(Nd, p::RingParams) -> Any
```

Calculate free-energy barrier for the explicit-binding regime with exact friction.

`ActinFriction.free_energy_barrier_Nd_exp`

— Method```
free_energy_barrier_Nd_exp(Nd, p::RingParams) -> Any
```

Calculate free-energy barrier for the explicit-binding regime with approximate friction.

The barrier to sliding a distance of deltas, in units of kbT.

`ActinFriction.free_energy_barrier_cX`

— Method```
free_energy_barrier_cX(l, p::RingParams) -> Any
```

Calculate free-energy barrier for the fast-binding regime.

The barrier to sliding a distance of deltas, in units of kbT.

`ActinFriction.friction_coefficient_Nd_exact`

— Method```
friction_coefficient_Nd_exact(
Nd,
p::RingParams
) -> Vector{Any}
```

Calculate friction coefficient in the explicit-binding regime with exact friction.

`ActinFriction.friction_coefficient_Nd_exp`

— Method```
friction_coefficient_Nd_exp(Nd, p::RingParams) -> Any
```

Calculate friction coefficient in the explicit-binding regime with approximate friction.

`ActinFriction.friction_coefficient_cX`

— Method```
friction_coefficient_cX(lambda, p::RingParams) -> Any
```

Calculate friction coefficient in the fast-binding regime.

`ActinFriction.kramers_r0`

— Method```
kramers_r0(Nd, p::RingParams) -> Any
```

Calculate jump rate prefactor from Kramers' theory.

`ActinFriction.l_to_lambda`

— Method```
l_to_lambda(l, p::RingParams) -> Any
```

Convert from continuous number of sites in an overlap to lambda.

`ActinFriction.lambda_to_R`

— Method```
lambda_to_R(lambda, p::RingParams) -> Any
```

Convert from lambda to ring radius.

`ActinFriction.lambda_to_l`

— Method```
lambda_to_l(lambda, p::RingParams) -> Any
```

Convert from lambda to continuous number of sites in an overlap.

`ActinFriction.savename`

— Method```
savename(
prefix,
params;
digits,
suffix,
ignored_fields
) -> String
```

Generate file name from a set of parameters.

This is a replacement for the DrWatson function that has better handling of rounding and trailing zeros.

`ActinFriction.solve_and_write_ring_Nd_contin_exp`

— Method```
solve_and_write_ring_Nd_contin_exp(
u0,
tspan,
p,
ifields,
filebase
)
```

Solve ring dynamics in the continuous explicit-binding regime with approximate friction.

`ActinFriction.solve_and_write_ring_Nd_contin_exp_noise`

— Method```
solve_and_write_ring_Nd_contin_exp_noise(
u0,
tspan,
trajs,
p,
ifields,
filebase
)
```

Solve ring dynamics in the continuous explicit-binding regime with approximate friction and noise.

`ActinFriction.solve_and_write_ring_Nd_discrete_exact`

— Method```
solve_and_write_ring_Nd_discrete_exact(
u0,
tspan,
trajs,
p,
ifields,
filebase
)
```

Solve ring dynamics in the discrete explicit-binding regime with exact friction.

`ActinFriction.solve_and_write_ring_Nd_discrete_exact_noise`

— Method```
solve_and_write_ring_Nd_discrete_exact_noise(
u0,
tspan,
trajs,
p,
ifields,
filebase
)
```

Solve ring dynamics in the discrete explicit-binding regime with exact friction and noise.

`ActinFriction.solve_and_write_ring_Nd_discrete_exp`

— Method```
solve_and_write_ring_Nd_discrete_exp(
u0,
tspan,
trajs,
p,
ifields,
filebase
)
```

Solve ring dynamics in the discrete explicit-binding regime with approximate friction.

`ActinFriction.solve_and_write_ring_Nd_discrete_exp_noise`

— Method```
solve_and_write_ring_Nd_discrete_exp_noise(
u0,
tspan,
trajs,
p,
ifields,
filebase
)
```

Solve ring dynamics in the discrete explicit-binding regime with approximate friction and noise.

`ActinFriction.solve_and_write_ring_cX`

— Method```
solve_and_write_ring_cX(u0, tspan, p, ifields, filebase)
```

Solve ring dynamics in the fast-binding regime.

`ActinFriction.solve_and_write_ring_cX_noise`

— Method```
solve_and_write_ring_cX_noise(
u0,
tspan,
trajs,
p,
ifields,
filebase
)
```

Solve ring dynamics in the fast-binding regime with noise.