aakankschit · aakankschit · Jan 17, 2022 · Jan 19, 2022 · Jan 19, 2022 · Jan 19, 2022
diff --git a/oelicense/.gitignore b/oelicense/.gitignore
diff --git a/other-materials/README.md b/other-materials/README.md
@@ -6,7 +6,7 @@ It may be crosslinked from course content, etc.
 
 ## Manifest
 - `python-intro`: Directory containing introductory material on Python; see [`python-intro/README.md`](python-intro/README.md). See also the Beckstein material linked below.
-- `solvation-free-energies`: Directory containing example materials for hydration free energy calculations with Yank; see [`solvation-free-energies/README.md`][solvation-free-energies/README.md]i
+- `solvation-free-energies`: Directory containing example materials for hydration free energy calculations with Yank; see [`solvation-free-energies/README.md`][solvation-free-energies/README.md]; Yank would need to be installed first, and support for it is not currently very good, so hopefully we can improve on this soon.
 
 ## Other useful materials:
 - For very helpful material on Linux and Python relevant to our area, refer to [Oliver Beckstein's Computational Methods in Physics course](https://asu-compmethodsphysics-phy494.github.io/ASU-PHY494/overview/), which has sectionns on Linux/Unix, Python, git, etc.

diff --git a/other-materials/solvation-free-energies/README.md b/other-materials/solvation-free-energies/README.md
@@ -1,6 +1,6 @@
 # Solvation free energy calculations with Yank
 
-This provides example materials for solvation free energy calculations with implicit and explicit solvent in Yank.
+This provides example materials for solvation free energy calculations with implicit and explicit solvent in Yank. You would need to install Yank first.
 Demonstrations are set up for hydration free energy calculations on FreeSolv and/or FreeSolvMini.
 
 I validated this, in the implicit solvent case, for phenol from IUPAC name, SMILES, and FreeSolv (mobley_20524.mol2) and get consistent values -- basically -10.08+/-0.01 kT in all cases. 

diff --git a/other-materials/solvation-free-energies/run_hydration.py b/other-materials/solvation-free-energies/run_hydration.py
@@ -7,7 +7,7 @@
 from simtk.openmm import app
 import netCDF4 as netcdf
 from tempfile import TemporaryDirectory
-import yank
+import yank #Note before using this you should install yank
 import mdtraj
 from yank.experiment import *
 import textwrap

diff --git a/uci-pharmsci/Getting_Started.ipynb b/uci-pharmsci/Getting_Started.ipynb
diff --git a/uci-pharmsci/Getting_Started_condacolab.ipynb b/uci-pharmsci/Getting_Started_condacolab.ipynb
diff --git a/uci-pharmsci/README.md b/uci-pharmsci/README.md
@@ -25,7 +25,7 @@ Please begin by reading the beginning portion of [`getting-started.md`](getting-
 
 
 #### Cheatsheets and dotfiles
-Under the **uci-pharmasci/docs/** directory, we have included some useful command cheat sheets for [BASH](https://github.com/nathanmlim/blues-apps/tree/master/docs/bash_cheatsheet.jpg) and [vi](https://github.com/nathanmlim/blues-apps/tree/master/docs/vi_cheatsheet.pdf) (on OS X, zsh is becoming default instead, but in general it is similar.).
+Under the **uci-pharmasci/docs/** directory, we have included some useful command cheat sheets for [BASH](https://github.com/MobleyLab/drug-computing/blob/master/uci-pharmsci/docs/bash_cheatsheet.jpg) and [vi](https://github.com/MobleyLab/drug-computing/blob/master/uci-pharmsci/docs/vi_cheatsheet.pdf) (on OS X, zsh is becoming default instead, but in general it is similar.).
 
 You may also want to check out the [CodeAcademy Github](https://www.codecademy.com/learn/learn-git) tutorial.
 

diff --git a/uci-pharmsci/assigned_materials.md b/uci-pharmsci/assigned_materials.md
@@ -42,8 +42,11 @@ To prepare for Lecture 1, on Python, Linux, text editors, and GitHub, please:
 - Skim through the PDF of the MD (part II)/MC slides in the `MC` directory, noting any questions for discussion in class
 - Review the MC sandbox Jupyter notebook in the same directory
 
-## Before Lecture 7 ([Solvation](lectures/solvation)):
-- Read the Jupyter notebook in the `solvation` directory under lectures.
+## Before Lecture 7 ([ChEMBL database work](https://github.com/volkamerlab/teachopencadd/tree/master/teachopencadd/talktorials/T001_query_chembl)
+- For this lecture we draw on the [TeachOpenCADD](https://github.com/volkamerlab/teachopencadd) repo
+- Clone or download the GitHub repo, or at least the content of the `T001_query_chembl` directory from the `talktorials` directory 
+- Skim the content in the `talktorial.ipynb` notebook
+- Install chembl_webresource_client, which is conda-installable
 
 ## Before Lecture 8 ([Docking, scoring and pose prediction](lectures/docking_scoring_pose)):
 - Read the `docking.ipynb` Jupyter notebook in the relevant directory and `old_slides.pdf` there, from the slide numbered 11 (bottom left corner) onwards.

diff --git a/uci-pharmsci/assignments/3D_structure_shape/3D_structure_shape_assignment.ipynb b/uci-pharmsci/assignments/3D_structure_shape/3D_structure_shape_assignment.ipynb
diff --git a/uci-pharmsci/assignments/MD/MD.ipynb b/uci-pharmsci/assignments/MD/MD.ipynb
@@ -93,7 +93,7 @@
     "\n",
     "The left-hand term is the kinetic energy, and here can be simplified by noting all of the masses in the system are defined to be 1. The right hand term involves the Boltzmann constant, the number of particles in the system, and the instantaneous temperature.\n",
     "\n",
-    "So, you can compute the effective temperature of your system, and translate this into a scaling factor which you can use to multiply (scale) all velocities in the system to ensure you get the correct average temperature (see http://www.pages.drexel.edu/~cfa22/msim/node33.html). **Specifically, following the Drexel page (eq. 177), compute a (scalar) constant by which you will multiply all of the velocities to ensure that the effective temperature is at the correct target value after rescaling.** To do this calculation you will need to compute the kinetic energy, which involves the sum above. \n",
+    "So, you can compute the effective temperature of your system, and translate this into a scaling factor which you can use to multiply (scale) all velocities in the system to ensure you get the correct average temperature (see https://www.compchems.com/thermostats-in-molecular-dynamics/#velocity-rescaling). **Specifically, following the page above, compute a (scalar) constant $\\lambda$ by which you will multiply all of the velocities to ensure that the effective temperature is at the correct target value after rescaling.** To do this calculation you will need to compute the kinetic energy, which involves the sum above. \n",
     "    \n",
     "Remove translational motion, rescale the velocities, and have your function return the  updated velocity array.\n",
     "Once the above two functions are written, finishing write a simple MD code using the available functions to:\n",
@@ -105,7 +105,7 @@
     "\n",
     "Use the settings given above for $N$, $\\rho$, $T$, the timestep, and the cutoff distance. \n",
     "\n",
-    "Perform simulations for $M = 2, 4, 6, 8, 12,$ and $16$ and store the total energies versus time out to 2,000 timesteps. (Remember, $M$ controls the number of particles per polymer; you are keeping the same total number of particles in the system and changing the size of the polymers). On a single graph, plot the potential energy versus time for each of these cases (each in a different color). Turn in this graph.  \n",
+    "Perform simulations for $M = 2, 4, 6, 8, 12,$ and $16$ and store the total energies (kinetic plus potential) versus time out to 2,000 timesteps. (Remember, $M$ controls the number of particles per polymer; you are keeping the same total number of particles in the system and changing the size of the polymers). On a single graph, plot the potential energy versus time for each of these cases (each in a different color). Turn in this graph.  \n",
     "\n",
     "Note also you can visualize, if desired, using the Python module for writing to PDB files which you saw in the Energy Minimization exercise. \n",
     "\n",
@@ -114,12 +114,12 @@
     "\n",
     "Modify your MD code from above to perform a series of steps that will allow you to compute the self-diffusion coefficient as a function of chain length and determine how diffusion of polymers depends on the size of the polymer. To compute the self-diffusion coefficient, you will simply need to monitor the motion of each polymer in time. \n",
     "\n",
-    "Here, you will first perform two equilibrations at constant temperature using velocity rescaling . The first will allow the system to reach the desired temperature and forget about its initial configuration (remember, it was started on a lattice). The second will allow you to compute the average total energy of the system. Then, you will fix the total energy at this value and perform a production simulation. \n",
+    "Here, you will first perform two equilibrations at constant temperature using velocity rescaling . The first will allow the system to reach the desired temperature and forget about its initial configuration (remember, it was started on a lattice). The second will allow you to compute the average total energy (kinetic plus potential) of the system. Then, you will fix the total energy at this value and perform a production simulation. \n",
     "\n",
     "Here’s what you should do:\n",
     "* Following initial preparation (like above), first perform equilibration for NStepsEquil1 using velocity rescaling to target temperature T every RescaleFreq steps, using whatever value of RescaleFreq you used previously (NOT every step!)\n",
-    "* Perform a second equilibration for `NStepsEquil2` timesteps using velocity rescaling at the same frequency, storing energies while you do this. \n",
-    "* Compute the average total energy over this second equilibration and rescale the velocities to start the final phase with the correct total energy. In other words, the total energy at the end of equilibration will be slightly above or below the average; you should find the kinetic energy you need to have to get the correct total energy, and rescale the velocities to get this kinetic energy. After this you will be doing no more velocity rescaling. (Hint: You can do this final rescaling easily by computing a scaling factor, and you will probably not be using the rescaling code you use to maintain the temperature during equilibration.)\n",
+    "* Perform a second equilibration for `NStepsEquil2` timesteps using velocity rescaling at the same frequency, storing energies (kinetic and potential, separately) while you do this. \n",
+    "* Compute the average total energy (kinetic plus potential) over this second equilibration and rescale the velocities to start the final phase with the correct total energy. In other words, the total energy at the end of equilibration will be slightly above or below the average; you should find the kinetic energy you need to have to get the correct total energy, and rescale the velocities to get this kinetic energy. After this you will be doing no more velocity rescaling. (Hint: You can do this final rescaling easily by computing a scaling factor, and you will probably not be using the rescaling code you use to maintain the temperature during equilibration.)\n",
     "* Copy the initial positions of the particles into a reference array for computing the mean squared displacement, for example using `Pos0 = Pos.copy()`\n",
     "* Perform a production run for `NStepsProd` integration steps with constant energy (NVE) rather than velocity rescaling. Periodically record the time and mean squared displacement of the atoms from their initial positions. (You will need to write a small bit of code to compute mean squared displacements, but it shouldn’t take more than a couple of lines; you may send it to me to check if you are concerned about it). The mean squared displacement is given by \n",
     "\\begin{equation}\n",
@@ -157,7 +157,7 @@
     "You can send your comments/discussion as an e-mail, and the rest of the items as attachments.\n",
     "\n",
     "### What’s provided for you: \n",
-    "In this case, most of what you need is provided in the importable module `MD_functions.py` (which you can view with your favorite text editor, like `vi` or Atom), except for the functions for initial velocities and velocity rescaling -- in those cases, the shells are present below and you need to write the core (which will be very brief!).  **However, you will also need to insert the code for the `ConjugateGradient` function in `MD_functions.py`** from your work you did in the Energy Minimization assignment. If you did not do this, or did not get it correct (or if you are not certain if you did), you will need to e-mail David Mobley for solutions.\n",
+    "In this case, most of what you need is provided in the importable module `MD_functions.py` (which you can view with your favorite text editor, like `vi` or Atom), except for the functions for initial velocities and velocity rescaling -- in those cases, the shells are present below and you need to write the core (which will be very brief!).  **However, you will also need to insert the code for the `ConjugateGradient` function in `MD_functions.py`**. This is similar to (but not identical to) the ConjugateGradient code from the energy minimization assignment -- specifically, now our particles are joined into polymers, meaning that the function needs slightly different arguments to pass to energy and force evaluation routines. \n",
     "\n",
     "From the Fortran library `mdlib` (which you will compile as usual via `f2py3 -c -m mdlib mdlib.f90` or similar), the only new function you need is Velocity Verlet. In `MD_functions.py`, the following tools are available (this shows their documentation, not the details of the code, but you should only need to read the documentation in order to be able to use them. NOTE: No modification of these functions is needed; you only need to use them. You will only need to write `InitVelocities` and `RescaleVelocities` as described above, plus provide your previous code for `ConjugateGradient`: \n"
    ]
@@ -358,9 +358,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {
-    "collapsed": true,
     "id": "uezEQuk55C2F"
    },
    "outputs": [],
@@ -374,7 +373,7 @@
     "#Set up as in A\n",
     "#Equilibrate for NStepsEquil1 with velocity rescaling every RescaleFreq steps, discarding energies\n",
     "#Equilibrate for NStepsEquil2 with velocity rescaling, storing energies\n",
-    "#Stop and average the energy. Rescale the velocities so the current (end-of-equilibration) energy matches the average\n",
+    "#Stop and average the toal energy. Rescale the velocities so the current (end-of-equilibration) total energy matches the average total energy.\n",
     "#Store the particle positions so you can later compute the mean squared displacement\n",
     "#Run for NStepsProd at constant energy (NVE) recording time and mean squared displacement periodically\n",
     "\n",
@@ -416,7 +415,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.12"
+   "version": "3.12.8"
   },
   "toc": {
    "nav_menu": {},

diff --git a/uci-pharmsci/assignments/energy_minimization/energy_minimization_assignment.ipynb b/uci-pharmsci/assignments/energy_minimization/energy_minimization_assignment.ipynb
@@ -65,16 +65,11 @@
     "iPython notebooks such as this one often contain a variety of cells containing code. These are normally intended to be run, which you can when you have an individual cell selected, by hitting the button at the top with a 'play' symbol, or by typing shift-enter. If you do NOT do so on each of the cells defining variables/functions which will be used here, then you will encounter an error about undefined variables when you run the later cells. \n",
     " \n",
     "## Your step 1 for the assignment: Start by doing some file bookkeeping:\n",
-    " * Find `emlib.f90` and optional utility `pos_to_pdb.py` in this directory.\n",
-    " * In the command prompt navigate to that folder and type 'f2py3 -c -m emlib emlib.f90' which should compile the fortran library for use within python (For more on F2Py, refer to the [f2py documentation](https://numpy.org/doc/stable/f2py)). In OS X, this may require you to install the (free) XCode developer tools (available from the Mac App store) and the command-line developer tools first (the latter via `xcode-select --install`). In Linux it should just work. Windows would be a hurdle.\n",
+    " * Find `emlib.f90` and optional utility `pos_to_pdb.py` in this directory. **If you are on Google Colab**, you will need to have uploaded this library and/or the directory enclosing it to Google Drive, mount Google Drive, and navigate to the directory containing this library.** See notes below on \"Installing Packages\" as well as background in `Getting_Started.ipynb`.\n",
+    " * In the command prompt navigate to that folder and type 'f2py -c -m emlib emlib.f90' which should compile the fortran library for use within python (For more on F2Py, refer to the [f2py documentation](https://numpy.org/doc/stable/f2py)). In OS X, this may require you to install the (free) XCode developer tools (available from the Mac App store) and the command-line developer tools first (the latter via `xcode-select --install`). In Linux it should just work. Windows would be a hurdle.\n",
     " * In your command prompt, start theis Jupyter notebook (in OSX this would be something like 'Jupyter notebook energy_minimization_assignment'), which should open it in your web browser; you're running it already unless you are looking at the HTML version of this file.\n",
     " \n",
-    "Template Python code for the assignment is provided below. I suggest making a new notebook which is a copy of this one (perhaps containing your name in the filename) and working from there. \n",
-    " \n",
-    " \n",
-    " ## Next, we prep Python for the work:\n",
-    " \n",
-    " First we import the numpy numerical library we're going to need, as well as the compiled Fortran library emlib"
+    "Template Python code for the assignment is provided below. I suggest making a new notebook which is a copy of this one (perhaps containing your name in the filename) and working from there. \n"
    ]
   },
   {
@@ -85,22 +80,32 @@
    "source": [
     "## Installing Packages\n",
     "\n",
-    "***If you are running this on Google Colab, please add the installation blocks from the [getting started notebook](https://github.com/MobleyLab/drug-computing/blob/master/uci-pharmsci/Getting_Started.ipynb) or [condacolab](https://github.com/aakankschit/drug-computing/blob/master/uci-pharmsci/Getting_Started_condacolab.ipynb) here and then execute the code below***"
+    "If you are running this notebook locally, you should have installed everything already. If you are running **on Google Colab** you will likely need to install prerequisites. (On occasion, Google Colab has had a fortran compiler installed already, meaning it might not be necessary to install anything, but this is typically not the case.)\n",
+    "\n",
+    "If you are running this on Google Colab, you will typically need to add the installation blocks from the [getting started notebook](https://github.com/MobleyLab/drug-computing/blob/master/uci-pharmsci/Getting_Started.ipynb) here **in a new code block** and then execute the code below. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Next, we prep Python for the work:\n",
+    " \n",
+    " First we import the numpy numerical library we're going to need, as well as the compiled Fortran library emlib"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {
-    "collapsed": true,
     "id": "DiyM0EjL5cdN"
    },
    "outputs": [],
    "source": [
     "import numpy as np\n",
     "import emlib\n",
-    "from pos_to_pdb import * \n",
-    "#This would allow you to export coordinates if you want, later"
+    "#from pos_to_pdb import *  #This would allow you to export coordinates if you want, later"
    ]
   },
   {
@@ -134,7 +139,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {
     "id": "Cz_zeUNd5cdP"
    },
@@ -283,7 +288,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {
     "id": "FoKqhioL5cdQ",
     "outputId": "132969c7-2e96-439f-fe88-9ca13c98281d"
@@ -294,10 +299,10 @@
      "output_type": "stream",
      "text": [
       "a=\n",
-      " [ 0.27969529  0.37836589  0.96785443]\n",
+      " [0.89598508 0.71295953 0.01997318]\n",
       "b=\n",
-      " [[ 0.37068791  0.64081204  0.21422213]\n",
-      " [ 0.471194    0.28575791  0.54468387]]\n"
+      " [[0.09347335 0.12438994 0.73166013]\n",
+      " [0.19155384 0.72085277 0.76497705]]\n"
      ]
     }
    ],
@@ -618,9 +623,9 @@
    "provenance": []
   },
   "kernelspec": {
-   "display_name": "drugcomp",
+   "display_name": "drugcomp23",
    "language": "python",
-   "name": "drugcomp"
+   "name": "drugcomp23"
   },
   "language_info": {
    "codemirror_mode": {
@@ -632,7 +637,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.12"
+   "version": "3.9.16"
   },
   "toc": {
    "nav_menu": {},