{% extends "layout.html" %} {% block title %}Experiments{% endblock %} {% block lead %}Procedures we followed.{% endblock %} {% block page_content %}
Procedures were referenced from the official documents provided by Thermofisher or Qiagen for each kit.
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.
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.
As a side note, our Speed-Vac machine was likely broken and couldn’t pull a vacuum or heat up to 60 C.
As a side note, our Speed-Vac machine was likely broken and couldn’t pull a vacuum or heat up to 60 C.
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.
You should now have all 3 inserts assembled again and purified along with almost no extra surplus.
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.
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).
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.
No bands were seen under UV light, so we decided to redo the entire procedure and fix some of the mistakes that were made.
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).
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.
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.
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.
Note: All numerical values of insert amount, plasmid amount, and buffer amount are based on our calculations
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
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"
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
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.
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.
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.
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.
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.
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 = 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.
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.
simulation.minimizeEnergy()
The energy of the system is minimized to relax the initial structure.
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.
simulation.step(10000)
A molecular dynamics simulation in the NVT ensemble is run for 10,000 steps.
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.
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.
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.
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.
The best way to replicate our experiments with VCell is to find our models (names listed in Engineering) and play around with them!
{% endblock %}