Winter School on the Physics of the Cell

Trento, Thursday 30 January 2020

Part 1. Compute the mean-square end-to-end distance of a worm-like chain.

Goal: Verify the linear relationship between mean-square end-to-end distance of a worm-like chain, <Ree^2(N)>, and the polymer mass, N.

a) Download the Monte Carlo code here, the Makefile to compile it here and the input file here.

b) Execute the code as: ./WLC-MC.exe < WLC-MC.in &

c) You will get a file called R2ee-VS-N.dat with 4 columns: column 1 is N, column 2 is <Ree^2(N)>, column 3 is <Energy(N)>, column 4 is the corresponding acceptance ratio.

Part 2. Comparing structural properties of ideal linear polymers vs. real linear polymers in good solvent dilute conditions.

Goal: Quantifying swelling of non-ideal linear chains, comparison to the Flory theory.

a) The purpose of this exercise is to verify, by Monte Carlo computer simulations, the swelling of single chains when moving from ideal to non-ideal conditions. The code can be downloaded here, the Makefile for compilation here (execute: make -f myMake) and the input file here. After compilation, the run can be executed in the command line as: ./RWs-VS-SAWs.exe < RWs-VS-SAWs-SingleChain.in &

b) The run produces a file, which provides an overview of the MC relaxation of the chain in terms of ensemble averages of some typical observables like the polymer aspect ratios and mean-square gyration radius.

c) The code may be used with two different initial conditions for the polymer: random-walk-like conformations (mimicking ideal conditions) and rigid rods. The user will verify that, at equilibrium, any signature of the initial conformation is lost (as it must be!!!) and the polymer chains fall into the same "universality class".

Part 3. Comparing structural properties of ideal linear polymers vs. real linear polymers in melt.

Goal: Verifying the Flory theorem for concentrated solutions.

a) Now, by using the same code, we will verify the screening of excluded volume in melts of linear polymers as predicted by Flory theorem. To do so, download here the input file which produces an initial melt of M linear chains made of NK flexible segments inside the simulation box of volume V with periodic boundary conditions on the cubic lattice. The density of Kuhn segments takes the finite value rhoK = (M*NK )/V=5. The chains are constructed as standard random walks.

b) As for the melts of linear chains, repeat the exercise by starting from a melt of rigid rods. You should observe that - after equilibration - the memory of the initial state is lost and polymers statistics is well described by random-walk statistics as predicted by the Flory theorem.

Part 4. Generating melts of double-folded, randomly-branching ring polymers.

Goal: Proper coarse-graining of ring polymers in melt.

For more details on the background, algorithm and codes presented here, see Rosa and Everaers, Phys. Rev. Lett. 112, 118302 (2014) and the references therein.

The algorithm consists of the following steps:

Step 1: Generation of a melt of randomly-branching lattice polymers (or, trees). Our Monte Carlo strategy employs a variation of the "amoeba", reptation-like algorithm by Seitz and Klein (J. Chem. Phys. 75, 5190 (1981)):

1.1) M linear polymer chains made of NK flexible segments are initially arranged inside the simulation box with periodic boundary conditions on the cubic lattice. As for the melt of linear chains, the volume of the box, V, is chosen in such a way that the density of Kuhn segments rhoK = (M*NK )/V=5.

1.2) The algorithm consists in cutting a randomly chosen leaf on a randomly chosen tree, the cut leaf is then attached at a new, randomly chosen node on the tree. The proposed move is accepted/rejected according to the Metropolis criterion, the energy function consisting of one term promoting branching and a term penalizing the overlap between chain monomers.

1.3) At equilibrium, the system should be homogeneously filled with average elementary cell occupancy ~5 Kuhn segments.

The algorithm can be downloaded here, the Makefile to compile it (command: make -f myMake) here and the input file here.

1.4) After compilation, the program has to be executed in the command line as: ./AmoebaAlgo-BranchedPolymers.exe < AmoebaAlgo-BranchedPolymers.in > amoeba.out &. The file amoeba.out monitors the road to equilibration, by reporting the ensemble averages of several observables (Kuhn segment density per cell, single-polymer aspect ratios, mean-square gyration radius, ...) measured in the course of the MC run.

1.5) At the end, several files are produced: in particular, the file rbp.lmp contain the fine-grained version of the branched polymers which will be used in step 2.

Step 2: From on- to off-lattice branched polymers. By this step we move the melt of branched trees generated at step 1 from on- to off-lattice. This is accomplished by using the MD simulator LAMMPS. This goes by 2 short consecutive runs with input files which can be downloaded here and here. The corresponding command lines are (execute 2.1 first, wait for it to finish and then execute 2.2):

2.1) mpirun -np #ncpus LAMMPSexecutable < bead_spring_rbp_1.lam -log log.lammps.1 > lammps.out.1 &

2.2) mpirun -np #ncpus LAMMPSexecutable < bead_spring_rbp_2.lam -log log.lammps.2 > lammps.out.2 &

#ncpus is the number of cpu's asked by the user for the runs, while the two files log.lammps.* and lammps.out.* contain useful information on what was going on during the two MD runs.

In practice, the two runs perform gentle push-off of the on-lattice conformations of branched polymers by using (2.1) a capped repulsive interaction between monomers to avoid LAMMPS "explosion", followed by (2.2) the full standard Lennard-Jones interaction. This was shown to properly generate a uniformly dense melt of off-lattice branched polymers, which can then be used as the "backbones" for double-folded randomly branched rings in melt (step 3).

Step 3: Constructing double-folded rings around randomly branched structures. Double-folding of ring polymers around corresponding trees follow the most natural implementation: For each tree, one starts from a randomly chosen tip and move inward by placing Lennard-Jones monomers along the backbone. At each branching point, one random direction is taken and the process continued until a new tip is reached. Then, the process moves backwards by placing monomers oppositely to the monomers which have been already placed. At a new branching point, the process moves through one of the directions not yet explored, otherwise moves back to the original tip. It is easy to see that this procedures creates double-folded ring structures (see Rosa and Everaers, Eur. Phys. J E 42, 7 (2019) for a quantitative analysis of randomly-branched, double-folded ring structures).

To perform this task, download the corresponding code here, compile it and then run it similarly to the amoeba algorithm by using the input file here. By this procedure you will obtain two files: RBPribbon.lmp (a configuration file for starting a LAMMPS run) and (VERY important!) the file chains.Lengths containing the exact contour lengths of the different rings (the procedure in fact does not allow maintaining the ring melt strictly monodisperse, i.e. with chains of exactly equal contour lengths; however, this is not a real problem because - as one can easily check - the differences amongst the different contour lengths are truly minimal).

Step 4: Local relaxation of double-folded structures. The final steps require that the structures are locally relaxed up to the entanglement time taue as this does homogeneize locally the solution. To do so, we strongly recommend to move first the files RBPribbon.lmp and chains.Lengths to a separate sub-directory (so to avoid messing these and next files with the ones generated previously). Then, it is sufficient to launch consecutively (i.e., wait the first run to finish before the second may start) the following LAMMPS runs (similarly as for step 2 above) with the input files which can be downloaded here and here:

2.1) mpirun -np #ncpus LAMMPSexecutable < bead_spring.pushoff_1.lam -log log.lammps.1 > lammps.out.1 &

2.2) mpirun -np #ncpus LAMMPSexecutable < bead_spring.pushoff_2.lam -log log.lammps.2 > lammps.out.2 &

At the end, you should get a short LAMMPS trajectory up to the time scale corresponding the entanglement time of the solution. The final configuration can then be used to run a much longer LAMMPS simulation and, so, explore the dynamical behavior of ring polymers.