Experiments

Procedures we followed.

Wet Lab

Reagents and Consumables:

Procedures were referenced from the official documents provided by Thermofisher or Qiagen for each kit.

Instruments:

3 part assembly procedure (first iteration)

This procedure is an adapted form of iGEM’s 3A assembly method. Instead of assembling two gene parts together, this procedure aims to assemble 3 parts into a plasmid backbone. Reference Design section for a visual diagram of the ligation procedure.

Digesting 3 inserts separately

Cleaning Up Each Sample with Qiagen PCR Purification Kit

Due to the heat resistant nature of SpeI, we could not heat inactivate the enzyme and had to use a PCR cleanup kit to remove the enzyme to ensure it did not interfere with downstream processes. Every cleanup step is performed with a Qiagen PCR Purification Kit. The procedure listed here is repeated for each tube. As a side note, our Speed-Vac machine was likely broken and couldn’t pull a vacuum or heat up to 60 C.

Ligating A and B Together

Digesting Part AB

Cleaning Up Part AB

As a side note, our Speed-Vac machine was likely broken and couldn’t pull a vacuum or heat up to 60 C.

Ligating AB and C

Digesting ABC with EcoRI and PstI

Cleaning Up Part ABC (botched)

As a side note, our Speed-Vac machine was likely broken and couldn’t pull a vacuum or heat up to 60 C.

3 part assembly procedure (second iteration)

Digesting 3 inserts separately

Ligating Insert A and B

Digesting AB mix

Ligating inserts AB and C

Digesting ABC

You should now have all 3 inserts assembled and purified along with some extra samples in each step of the way, in case you want to run a Bio analyzer, Nanodrop, etc.

Redoing the process starting at Ligation of AB and C

Ligating inserts AB and C again

Digesting ABC

You should now have all 3 inserts assembled again and purified along with almost no extra surplus.

Storage Vectors - Plasmid Digestion Try #1

Creation of Competent Cells

Transforming Competent Cells with Plasmids

Our agar plates had to much growth. We realized that our ration of 1:1 was too high, so we decided that we would dilute it the next time we made agar plates.

Miniprep of Colonies

Note: All centrifuges were done at 14000 rpm and 27° C

After nanodropping the plasmids from the miniprep, we decided to only use C11, E11, and G11 since they had the highest concentration and purity (high 260/280 ratio).

Digestion of Plasmids + Inserts

BioAnalyzer

The results from the BioAnalyzer were inconclusive for the plasmids, so we decided to move on to the gel electrophoresis and purification. The BioAnalyzer is essentially a smaller gel electrophoresis, which means that running a gel can confirm the results and allow us to move with our experiment.

The results from the BioAnalyzer for the inserts showed that parts A and B had digested correctly. However, part C wasn’t digested correctly from the size that the band correlated with. We redigested part C using the same digestion procedure shown above.

Gel Electrophoresis

No bands were seen under UV light, so we decided to redo the entire procedure and fix some of the mistakes that were made.

Storage Vectors - Plasmid Digestion Try #2

Miniprep of Colonies

Note: All centrifuges were done at 14000 rpm and 27° C

After nanodropping the plasmids from the miniprep, we decided to only use A11, C11, and E11 since, although G11 had high concentration, they had the highest purity (high 260/280 ratio).

PCR Purification Column

Note: All centrifuges were done at 13000 rpm and 27° C

The plasmids were run through a BioAnalyzer again (Check above for the protocol) and sufficient concentrations and sizes were seen for all of the plasmids that were digested.

Gel Electrophoresis

Minimal bands were seen in the gel for A11, C11, and E11, so it was determined that the digestion was unsuccessful once again. However, the results were confusing because the BioAnalyzer showed sufficient amounts of all three of the digests. We decided to run the undigested G11 on the gel and its band showed up. For this reason, we decided to quickly digest G11 and use it for the experiment.

Storage Vectors - G11

PCR Purification Column

Note: All centrifuges were done at 13000 rpm and 27° C

The resulting flow-through was nanodropped, but the results showed low concentrations of plasmid. The G11 was eluted 2 more times in order to maximize the amount of plasmid taken from the column.

Gel Extraction

Ligation of Inserts

Note: All numerical values of insert amount, plasmid amount, and buffer amount are based on our calculations

transformation Vector

Dry Lab

OpenMM

Setting Up OpenMM

To start with OpenMM, set up procedures on the official website need to be followed. A simplified version for MacBooks will be presented here. Anaconda and a new environment to install OpenMM will be needed. To install run this snippet of code

    conda install -c conda-forge openmm

this should install openmm, but you might have to use pip to install other necessary libraries for your script. Also to use any of the same files that we have used visit this link.

https://gitlab.igem.org/2023/software-tools/manual-ky

Docking

A file that contains your ligand and protein is needed, and, ideally, it should already be situated in a binding pocket to reduce the amount of time needed to observe. We used ROSIE a ligand docking software to dock the ligand to the protein. 200 different iterations were used and when the 2 get docked, conformational change is also recorded and saved, meaning the structure is in the correct shape.

https://rosie.graylab.jhu.edu/ligand_docking

The needed files can be generated; Using the pdb created by Uniprot for LuxR, this smile string for PFOA "C(=O)(C(C(C(C(C(C(C(F)(F)F)(F)F)(F)F)(F)F)(F)F)(F)F)(F)F)O", and this smile string for AHL "CCCC(=O)CC(=O)NC1CCOC1=O"

Forcefields

Now, to govern how the ligand and protein interact, you will need forcefields, which are essentially just files of data, containing everything about the molecule from elements to charges. Now for the protein, LuxR we can use the general amber forcefield, amber 14 all, and the general forceifeld for water is, amber 14 - tip3pfb, for the ligand and protein system we will use the amber 14 general forcefield, GAFF, and finally we will need one specific to the ligand, or in this case one for pfoa and one for ahl. To generate these files you will need the sdf file for the ligand, the same one used in the ROSIE docking. You will need to install homebrew before proceding. Once homebrew is installed, open terminal and run this

    brew install gcc

This will install all the dependencies for ambertools.

Now we can use the antechamber tool that comes with ambertools, this is a very useful quantum computing tool. Run this command into terminal to determine the charges for your ligand. Run this in your terminal (same environment that all libraries were installed in anaconda), and you can use The OpenBabel to convert your sdf to mol2 so that you can store charges

    antechamber -i /path/to/PFOA.mol2 -fi mol2 -o /new/path/pfoa-ligand-charged.mol2 -fo mol2 -c bcc -nc -1

Now that you have a mol2 with your charges, you can run it through this converter to get a pdb file. Then using this cloud server, you can obtain a forcefield file (.xml) for your ligand, you will need to do this twice, to get one for ahl, and one for PFOA.

https://www.cheminfo.org/Chemistry/Cheminformatics/FormatConverter/index.html and https://datascience.unm.edu/tomcat/biocomp/convert

Developing the script

Now it is time to create the script, we can run this through snippets so each part of the code is understandable, this is the final code after many many iterations. The provided code appears to be using the OpenMM library to perform molecular dynamics simulations.

Importing Modules

    from openmm.app import *
  from openmm import *
  from openmm.unit import *
  from sys import stdout
  from mdtraj.reporters import *

This section imports the necessary modules and classes from OpenMM and other libraries. OpenMM is used for molecular dynamics simulations, and `mdtraj` is used for reporting and analyzing simulation data.

Loading Molecular Structures

    pdb = PDBFile("pfoa_luxr/pfoa_dock_luxr_1.pdb")

In this section, a PDB file representing a molecular structure is loaded using the `PDBFile` class. This file contains the initial coordinates and topology information for the system.

Creating a Force Field

    forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml', 'pfoa_luxr/gaff.xml', 'pfoa_luxr/PFOA-specific.xml')

A force field is created by specifying XML files that define the parameters for the molecules in the system. This includes information about atoms, bonds, angles, dihedrals, and nonbonded interactions.

Modifying the Molecular Structure

    modeller = Modeller(pdb.topology, pdb.positions)
    modeller.deleteWater()
    residues = modeller.addHydrogens(forcefield)
    modeller.addSolvent(forcefield, padding=1.0*nanometer)

This section imports the necessary modules and classes from OpenMM and other libraries. OpenMM is used for molecular dynamics simulations, and `mdtraj` is used for reporting and analyzing simulation data.

Creating the Molecular System

    system = forcefield.createSystem(modeller.topology, nonbondedMethod=PME, nonbondedCutoff=1.0*nanometer, constraints=HBonds)

Here, the molecular system is created based on the modified topology. The force field parameters are used to define the system's potential energy functions. The `nonbondedMethod` is set to PME, and the `nonbondedCutoff` is set to 1.0 nanometers. Constraints on hydrogen bonds are also specified.

Integrator Configuration

    integrator = LangevinMiddleIntegrator(300*kelvin, 1/picosecond, 0.002*picoseconds)

An integrator is configured for the simulation. In this case, a Langevin integrator is used with a temperature of 300 K, a collision rate of 1/picosecond, and a time step of 0.002 picoseconds.

Setting up a Simulation

    simulation = Simulation(modeller.topology, system, integrator)
    simulation.context.setPositions(modeller.positions)

An integrator is configured for the simulation. In this case, a Langevin integrator is used with a temperature of 300 K, a collision rate of 1/picosecond, and a time step of 0.002 picoseconds.

Energy Minimization

    simulation.minimizeEnergy()

The energy of the system is minimized to relax the initial structure.

Simulation Reporters

    simulation.reporters.append(PDBReporter('output.pdb', 20000))
    simulation.reporters.append(StateDataReporter(stdout, 100, step=True,
    potentialEnergy=True, temperature=True, volume=True, kineticEnergy=True, totalEnergy=True))
    simulation.reporters.append(StateDataReporter("md_log.txt", 100, step=True,
    potentialEnergy=True, temperature=True, volume=True, kineticEnergy=True, totalEnergy=True))
    simulation.reporters.append(DCDReporter('trajectory.dcd', 100))

In this section, several reporters are added to report simulation data at regular intervals. These reporters include PDBReporter for trajectory snapshots, StateDataReporter for energy and temperature data, and DCDReporter for trajectory storage.

Running NVT Simulation

    simulation.step(10000)

A molecular dynamics simulation in the NVT ensemble is run for 10,000 steps.

Adding Barostat and Running NPT Simulation

    system.addForce(MonteCarloBarostat(1*bar, 300*kelvin))
    simulation.context.reinitialize(preserveState=True)
    simulation.step(10000)
    simulation.reporters[-1].close()

A Monte Carlo barostat is added to the system to maintain constant pressure (NPT ensemble), and another NPT simulation is run for 10,000 steps. The last reporter is closed to finish data collection.

Data Analysis and Plotting

    import numpy as np
    import matplotlib.pyplot as plt
    data = np.loadtxt("md_log.txt", delimiter=',')

Data collected from the simulation is loaded from the "md_log.txt" file into a NumPy array for analysis and plotting.

Data Analysis and Plotting

    step = data[:,0]
    potential_energy = data[:,1]
    temperature = data[:,2]
    volume = data[:,3]
    kinetic_energy = data[:,4]
    total_energy = data[:,5]

    plt.plot(step, potential_energy, label="Potential Energy")
    plt.plot(step, kinetic_energy, label="Kinetic Energy")
    plt.plot(step, total_energy, label="Total Energy")
    plt.xlabel("Step")
    plt.ylabel("Energy (kJ/mol)")
    plt.legend()
    plt.show()

    plt.plot(step, temperature)
    plt.xlabel("Step")
    plt.ylabel("Temperature (K)")
    plt.show()
    plt.plot(step, volume)
    plt.xlabel("Step")
    plt.ylabel("Volume (nm^3)")
    plt.show()

This section uses Matplotlib to create and display plots of potential energy, kinetic energy, total energy, temperature, and volume as a function of simulation step. The data for these properties is obtained from the loaded "md_log.txt" file. The code is primarily concerned with setting up and running a molecular dynamics simulation and visualizing the results through plots.

Final Script

The final script can be downloaded with the gitlab link from earlier.

Virtual Cell Modeling

Our models are freely available to anyone that has a VCell account. All constants, simulation setups, reaction diagrams, and results can all be accessed for free by opening our models in VCell. Annotations for each reaction include the sources used to find the reaction constants. The models are hosted on VCell servers and are shared publicly in the “Uncurated” folder.

vcell

The best way to replicate our experiments with VCell is to find our models (names listed in Engineering) and play around with them!