Molecular_Dynamics_Simulation_with_Trifluoroethanol.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GuerrSim96/Molecular_Dynamics_Simulation_with_Trifluoroethanol/blob/main/Molecular_Dynamics_Simulation_with_Trifluoroethanol.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iY5gkK-q-4VQ"
      },
      "outputs": [],
      "source": [
        "#@title ##### Mount the Drive\n",
        "#@markdown ### Before going ahead check out the short tutorial on GitHub on how to use this notebook by [clicking here](https://github.com/GuerrSim96/MDS-pVT/tree/main#molecular_dynamics_simulation_with_trifluoroethanolipynb).\n",
        "#@markdown # Click the last output URL!\n",
        "!sudo add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null\n",
        "!sudo apt-get update -qq 2>&1 > /dev/null\n",
        "!sudo apt -y install -qq google-drive-ocamlfuse 2>&1 > /dev/null\n",
        "!google-drive-ocamlfuse"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RP3FzUJotb7O"
      },
      "outputs": [],
      "source": [
        "!sudo apt-get install -qq w3m # to act as web browser\n",
        "!xdg-settings set default-web-browser w3m.desktop # to set default browser\n",
        "%cd /content\n",
        "!mkdir drive\n",
        "%cd drive\n",
        "!mkdir MyDrive\n",
        "%cd ..\n",
        "!google-drive-ocamlfuse /content/drive/MyDrive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fNfTEl2---t9"
      },
      "outputs": [],
      "source": [
        "#@title ##### Installing and Import\n",
        "# Install of py3Dmol and biopython\n",
        "!pip --quiet install biopython  # --quiet flag prevents printing of the output\n",
        "!pip --quiet install py3Dmol\n",
        "print('Istallazione di biopython, py3Dmol completata!!!')\n",
        "# Time when the program begins\n",
        "import time\n",
        "from datetime import datetime\n",
        "time_start = time.time()  # Get the time in seconds\n",
        "date_time_start = datetime.fromtimestamp(time_start)  # To convert the time by seconds to date and time\n",
        "with open('timer', 'x') as clk:\n",
        "  clk.write(f'Start:\\t\\t{date_time_start}\\n')\n",
        "# Import parameters files\n",
        "import os\n",
        "import sys\n",
        "import shutil as sh\n",
        "path_mdp='/content/drive/MyDrive/MDS-pVT/md_files/mdp/'\n",
        "par= os.listdir(path_mdp)\n",
        "mdp=['ions.mdp','minim.mdp','nvt.mdp','npt.mdp','md.mdp']\n",
        "fc=os.listdir('/content')\n",
        "for p in mdp:\n",
        "  if p not in par:\n",
        "    print(f'{p} there is not in {path_mdp}')\n",
        "    sys.exit  # Block the execution of the code\n",
        "  else:\n",
        "    print(p+' is already there')\n",
        "  if p not in fc:\n",
        "    sh.copy(path_mdp+p, '/content')  # Copy a file in the working directory\n",
        "    print(f'-The file \\\"{p}\\\" has been moved successfully')\n",
        "  else:\n",
        "    print(f'-The file \\\"{p}\\\" is already in /content')\n",
        "path_solvs='/content/drive/MyDrive/MDS-pVT/md_files/input/'\n",
        "solvs=['trifluoroethanol.pdb', 'tip3p_added.pdb']\n",
        "for solv in solvs:\n",
        "  if solv not in fc:\n",
        "    sh.copy(path_solvs+solv, '/content')  # Copy a file in the working directory\n",
        "    print(f'-The file \\\"{solv}\\\" has been moved successfully')\n",
        "  else:\n",
        "    print(f'-The file \\\"{solv}\\\" is already in /content')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YnNn2HeBHTLL"
      },
      "outputs": [],
      "source": [
        "#@title ##### Set Comunication\n",
        "#to run GROMACS bin files\n",
        "import subprocess\n",
        "path_bin='/content/drive/MyDrive/MDS-pVT/gromacs-2023/bin/'\n",
        "os.environ['PATH'] += f':{path_bin}'\n",
        "# To understand\n",
        "for root, directories, files in os.walk(path_bin):\n",
        "    for dir in directories:\n",
        "        os.chmod(os.path.join(root, dir), 0o777)\n",
        "    for f in files:\n",
        "        os.chmod(os.path.join(root, f), 0o777)\n",
        "subprocess.Popen('source \"$PATH\"/GMXRC.bash', shell=True, executable='/bin/bash', stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n",
        "# to allow communication between bash and python\n",
        "def gmx(cmd):\n",
        "  '''To launch gmx process'''\n",
        "  process = subprocess.Popen(cmd, shell=True, executable='/bin/bash', stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n",
        "  output, error = process.communicate()\n",
        "  print(f'Output: \\n{output.decode(\"utf-8\")} \\n\\n{error.decode(\"utf-8\")}\\n\\n')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gmtTmljPkZy-"
      },
      "outputs": [],
      "source": [
        "#@title # Get the Structure\n",
        "from Bio.PDB import *\n",
        "#@markdown Enter the identification code of the pdb structure in the line below:\n",
        "pdb_id = \"1jrj\"  #@param {type:\"string\"}\n",
        "pdbl= PDBList()\n",
        "parser= PDBParser(PERMISSIVE=True, QUIET=True)\n",
        "pdbl.retrieve_pdb_file(pdb_id, pdir='.', file_format ='pdb', overwrite=True)\n",
        "os.rename(f'pdb{pdb_id.lower()}.ent', f'{pdb_id}.pdb')  # Convert the str id in lowercase\n",
        "structure = parser.get_structure(pdb_id, f'{pdb_id}.pdb')\n",
        "model = structure.get_models()\n",
        "models= list(model)\n",
        "input_f=models[0]\n",
        "io= PDBIO()\n",
        "io.set_structure(input_f)  # Get only one model from a NMR file\n",
        "io.save(\"file.pdb\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "el7vP4DcmXA7"
      },
      "outputs": [],
      "source": [
        "#@title # Generating Topology\n",
        "# Removing water\n",
        "!grep -v HOH file.pdb > file_clean.pdb\n",
        "# Counting the sulfur bond\n",
        "ss, line= 0, 'y \\n'\n",
        "with open(f'{pdb_id}.pdb', 'r') as pdb:\n",
        "  for line in pdb:\n",
        "    if 'SSBOND' in line:\n",
        "      ss+=1\n",
        "with open('options', 'x') as file:\n",
        "  for x in range(ss):\n",
        "    file.write(line)\n",
        "# Prepare the topology with oplsaa ff and tip3p water model -ingh is a flag that we can use with a file.pdb generated from an NMR technique\n",
        "pdb2gmx= 'gmx pdb2gmx -f file_clean.pdb -o file_processed.pdb -water tip3p -ff oplsaa -ignh -ss yes < options'\n",
        "gmx(pdb2gmx)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qdHvqFAJcX8p"
      },
      "outputs": [],
      "source": [
        "#@title # Calculation of Box Dimensions\n",
        "with open('options', 'w') as file:\n",
        "   file.write('Backbone \\n')\n",
        "# Orient the structure with the major axis coincident with the x-axis\n",
        "orient='gmx editconf -f file_processed.pdb -o file_oriented.pdb -princ < options'\n",
        "gmx(orient)\n",
        "x,y,z = [],[],[]\n",
        "with open('file_oriented.pdb', 'r') as protein:\n",
        "  for line in protein:\n",
        "    if line.startswith(\"ATOM\"): # extract x, y, z coordinates for carbon alpha atoms\n",
        "      x_c = float(line[30:38].strip())\n",
        "      y_c = float(line[38:46].strip())\n",
        "      z_c = float(line[46:54].strip())\n",
        "      if line[12:16].strip() == \"CA\":\n",
        "        x.append(x_c)\n",
        "        y.append(y_c)\n",
        "        z.append(z_c)\n",
        "x_max, x_min= x.index(max(x)), x.index(min(x))\n",
        "y_max, y_min= y.index(max(y)), y.index(min(y))\n",
        "z_max, z_min= z.index(max(z)), z.index(min(z))\n",
        "dist_x=((x[x_min]-x[x_max])**2 + (y[x_min]-y[x_max])**2 + (z[x_min]-z[x_max])**2)**0.5 /10\n",
        "dist_y=((x[y_min]-x[y_max])**2 + (y[y_min]-y[y_max])**2 + (z[y_min]-z[y_max])**2)**0.5 /10\n",
        "dist_z=((x[z_min]-x[z_max])**2 + (y[z_min]-y[z_max])**2 + (z[z_min]-z[z_max])**2)**0.5 /10\n",
        "x_l, y_l, z_l= int(dist_x*1.75)+1, int(dist_y*1.75)+1, int(dist_z*1.75)+1\n",
        "os.environ['MAIN_AXIS_BOX']= str(x_l) #to trasfer a variable from python to bash\n",
        "if y_l > z_l:\n",
        "  os.environ['SEC_AXIS_BOX']= str(y_l)\n",
        "else:\n",
        "  os.environ['SEC_AXIS_BOX']= str(z_l)\n",
        "# Define the box cell as triclinic and using the spc216 equilibrated 3-point solvent model\n",
        "editconf='gmx editconf -f file_oriented.pdb -o file_newbox.pdb -bt triclinic -c -box \"$MAIN_AXIS_BOX\" \"$SEC_AXIS_BOX\" \"$SEC_AXIS_BOX\"'\n",
        "gmx(editconf)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nvv2icYm4izg"
      },
      "outputs": [],
      "source": [
        "#@title # Solvation\n",
        "#@markdown If you want trifluoroethanol in the system, flag the box below:\n",
        "include_tfe= True #@param {type:'boolean'}\n",
        "# if statement\n",
        "if include_tfe: # True\n",
        "  with open('options', 'w') as file:\n",
        "    file.write('TFE \\n')\n",
        "  # Produces an #include file for a topology\n",
        "  restr_tfe= 'gmx genrestr -f trifluoroethanol.pdb -o porse_tfe.itp < options'\n",
        "  gmx(restr_tfe)\n",
        "  # Find where insert the string #include file\n",
        "  with open('topol.top', 'r') as top:\n",
        "    info= top.readlines()\n",
        "  with open('topol.top', 'r') as top:\n",
        "    for num, line in enumerate(top, 1):\n",
        "      if '#include \"oplsaa.ff/ions.itp\"' in line: # Modificare\n",
        "        t_line= num\n",
        "  add_info='\\n;Include TFE topology \\n#include \"oplsaa.ff/trifluoroethanol.itp\" \\n \\n;Include Position restraint file \\n#ifdef POSRES_TFE \\n#include \"posre_tfe.itp\" \\n#endif \\n'\n",
        "  info.insert(t_line, add_info) # Write in topol.top\n",
        "  with open('topol.top', 'w') as top:\n",
        "    info= ''.join(info)\n",
        "    top.write(info)\n",
        "  # obtain the number of water molecules that fit in the box\n",
        "  w4box='gmx solvate -cp file_newbox.pdb -cs spc216.gro -o w4box.pdb &> w4box'\n",
        "  gmx(w4box)\n",
        "  # To calculate the molecules number of tfe to add in the simulation box\n",
        "  with open('w4box', 'r') as file:  # Search into the file\n",
        "    for line in file:\n",
        "      if 'Number of solvent molecules' in line:  # To get the number of the water molecules\n",
        "        field = line.split()  # Divide the row in elements\n",
        "        for element in field:\n",
        "          if element.isdigit():  # Verify if the element is a number\n",
        "            w_n= int(element)  # Convert from str into int\n",
        "  from scipy.constants import Avogadro\n",
        "  #@markdown Trifluoroethanol percentage (%v/v):\n",
        "  tfe_percent= 30 #@param {type:\"slider\", min:10, max:100, step:10}\n",
        "  w_percent= 100- tfe_percent # Water percentage\n",
        "  w_vol_mol, tfe_vol_mol, w_mol= 0.01807, 0.07232, w_n/Avogadro  # Convert in moles\n",
        "  w_vol= w_mol * w_vol_mol # Convert in volume\n",
        "  tfe_vol, w_vol_new= w_vol * tfe_percent/100, w_vol * w_percent/100 # Calculate the volume\n",
        "  tfe_mol, w_mol_new= tfe_vol / tfe_vol_mol, w_vol_new / w_vol_mol # Final moles\n",
        "  tfe_n, w_n_new= int(tfe_mol * Avogadro), int(w_mol_new * Avogadro) # Number of trifluorethanol molecules and water molecules\n",
        "  os.environ['MOLS_TFE'] = str(tfe_n)  # Trasfer variable from python to bash\n",
        "  # Add trifluoroethanol in the system\n",
        "  insert_tfe= 'gmx insert-molecules -f file_newbox.pdb -ci trifluoroethanol.pdb -nmol \"$MOLS_TFE\" -o file_tfe.pdb'\n",
        "  gmx(insert_tfe)\n",
        "  # Modify topology file\n",
        "  with open('topol.top', 'a') as top:  # Add at the end of the file\n",
        "    top.write(f'TFE {tfe_n} \\n')  # Write the number of trifluoroethanol molecules\n",
        "  os.environ['MOL_WATER'] = str(w_n_new)  # Trasfer variable from python to bash\n",
        "  # Add water molecules to obrtain the correct proportion between trifluoroethanol and water\n",
        "  solvate= 'gmx insert-molecules -f file_tfe.pdb -ci tip3p_added.pdb -nmol \"$MOL_WATER\" -try 20 -o file_tfe_solv.pdb &> added_water'\n",
        "  gmx(solvate)\n",
        "  # Verify if water molecules were added\n",
        "  verific=[]\n",
        "  with open('added_water', 'r') as file:  # Search into the file\n",
        "    for line in file:\n",
        "      if 'Added' in line:\n",
        "        field = line.split()  # Divide the row in elements\n",
        "        for element in field:\n",
        "          if element.isdigit():  # Verify if the element is a number\n",
        "            verific.append(int(element))  # Convert from str into int\n",
        "  if verific[0] == verific[1]:\n",
        "    print('All water molecules have been added in the simulation box!')\n",
        "  else:  # Block the execution of the code\n",
        "    sys.exit('the condition \"w_added == diff\" must be true to allow the execution of the code.')\n",
        "  # Modify topol.top after added water molecules\n",
        "  with open('topol.top', 'a') as top:  # Add at the end of the file\n",
        "    top.write(f'SOL {w_n_new} \\n')  # Write the number of water molecules\n",
        "  # Set the variables for the cell below\n",
        "  to_neutralize= 'file_tfe_solv.pdb'\n",
        "  os.environ['TO_NEUTRALIZE']= to_neutralize\n",
        "else: # False\n",
        "  solvate='gmx solvate -cp file_newbox.pdb -cs spc216.gro -o file_solv.pdb -p topol.top'\n",
        "  gmx(solvate)\n",
        "  to_neutralize= 'file_solv.pdb'\n",
        "  os.environ['TO_NEUTRALIZE']= to_neutralize"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zR3EWKrLfRhx"
      },
      "outputs": [],
      "source": [
        "#@title #Neutralizing the System\n",
        "!grep 'qtot' topol.top\n",
        "# Generate the run input for genion\n",
        "grompp_ions= 'gmx grompp -f ions.mdp -c \"$TO_NEUTRALIZE\" -p topol.top -o ions.tpr -maxwarn 1'\n",
        "gmx(grompp_ions)\n",
        "# Overwrite \"options\" file, it will be used ad imput insed of the std input\n",
        "with open('options', 'w') as file:\n",
        "  file.write('SOL \\n')\n",
        "# Replace some water molecules (SOL) with ions to remove net charge\n",
        "genion= 'gmx genion -s ions.tpr -o file_solv_ions.pdb -p topol.top -rmin 0.32 -pname NA -nname CL -conc 0.15 -neutral < options'\n",
        "gmx(genion)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ##### Box System Visualization\n",
        "import py3Dmol\n",
        "view= py3Dmol.view()\n",
        "view.addModel(open('file_solv_ions.pdb', 'r').read(),'pdb')  # File to screen\n",
        "view.setBackgroundColor('Black')  # Background color\n",
        "view.addStyle({'atom':'OW'},{'sphere':{'radius':'0.1'}})  # Style water molecules\n",
        "view.zoomTo()\n",
        "view.show()"
      ],
      "metadata": {
        "id": "lu6IfQ67q9lj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6aCJejf_ibQY"
      },
      "outputs": [],
      "source": [
        "#@title # Minimization\n",
        "# Relax the system\n",
        "grompp_minim, mdrun_minim= 'gmx grompp -f minim.mdp -c file_solv_ions.pdb -o em.tpr -maxwarn 1', 'gmx mdrun -deffnm em'\n",
        "gmx(grompp_minim)\n",
        "gmx(mdrun_minim)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fjdiRfYW_-I2"
      },
      "outputs": [],
      "source": [
        "#@title # Equilibration\n",
        "# Equilibration phase I (under nVT/isothermal-isochoric/canonical) - stabilizes T\n",
        "grompp_nvt, mdrun_nvt= 'gmx grompp -v -f nvt.mdp -c em.gro -r em.gro -p topol.top -o nvt.tpr -maxwarn 1', 'gmx mdrun -deffnm nvt'\n",
        "gmx(grompp_nvt)\n",
        "gmx(mdrun_nvt)\n",
        "# Equilibration phase II (under npT/isothermal-isobaric) - stabilizes p\n",
        "grompp_npt, mdrun_npt= 'gmx grompp -f npt.mdp -c nvt.gro -r nvt.gro -t nvt.cpt -p topol.top -o npt.tpr -maxwarn 2', 'gmx mdrun -deffnm npt'\n",
        "gmx(grompp_npt)\n",
        "gmx(mdrun_npt)\n",
        "def pa_di(list_path):\n",
        "  '''Function to create new directory into the drive, starting from a list of names.'''\n",
        "  print(pa_di.__doc__)\n",
        "  for dir in list_path:\n",
        "    if os.path.isdir(dir) is True:\n",
        "      print('-The directory \\\"'+ dir +'\\\" is already there')\n",
        "    else:\n",
        "      os.mkdir(dir)\n",
        "      print('-The directory \\\"'+ dir +'\\\" has been created successfully')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V6NrvZhKCl7I"
      },
      "outputs": [],
      "source": [
        "#@title ##### Export to Drive\n",
        "# Generating the output directory\n",
        "lst_dir, path_simul= [], f'/content/drive/MyDrive/MDS-pVT/md_files/{pdb_id}'\n",
        "lst_dir.append(path_simul)\n",
        "path_par = path_simul + '/parameters/' # Subdirectory to separate the outputs\n",
        "lst_dir.append(path_par)\n",
        "pa_di(lst_dir)\n",
        "here= os.getcwd() # Working directory\n",
        "os.environ['DIRECTORY'] = '/content/'\n",
        "if here != path_simul:\n",
        "  os.chdir(path_simul) # Changing working directory\n",
        "  print(f'\\n-Now the working directory is \\\"{path_simul}\\\"')\n",
        "else:\n",
        "  print(f'\\n-The working directory was already \\\"{path_simul}\\\"')\n",
        "# Assemble the structure for a 10-ns MD simulation using md.mdp as a parameter file\n",
        "gromp_md= 'gmx grompp -f \"$DIRECTORY\"md.mdp -c \"$DIRECTORY\"npt.gro -t \"$DIRECTORY\"npt.cpt -p \"$DIRECTORY\"topol.top -o md_1.tpr -maxwarn 2'\n",
        "gmx(gromp_md)\n",
        "# Move all the file to the working directory\n",
        "fc_1, files_par, files_simul, trasfer= os.listdir('/content'), os.listdir(path_par), os.listdir(path_simul), ['timer']\n",
        "for file in fc_1:\n",
        "  if file.endswith('.top'):\n",
        "    if file not in files_simul:\n",
        "      trasfer.append(file)\n",
        "    else:\n",
        "      print('-The file \\\"'.upper() + file + '\\\" is already there!'.upper()) # It will be printed in UPPERCASE\n",
        "  elif file.endswith('.mdp'):\n",
        "    if file not in files_par:\n",
        "      sh.copy(f'/content/{file}', path_par)\n",
        "      print(f'-The file \\\"{file}\\\" has been moved successfully')\n",
        "    else:\n",
        "      print(f'-The file \\\"{file}\\\" is already there')\n",
        "for file in trasfer:\n",
        "  sh.copy(f'/content/{file}', path_simul)\n",
        "  print(f'-The file \\\"{file}\\\" has been moved successfully')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DkFJ1I78GA92"
      },
      "outputs": [],
      "source": [
        "#@title # MD Simulation\n",
        "# Time when molecular dynamics begins\n",
        "time_md_s= time.time()\n",
        "date_time_md_s= datetime.fromtimestamp(time_md_s) # To convert the time by seconds to date and time\n",
        "with open('timer', 'a') as clk:\n",
        "  clk.write(f'MD start:\\t{date_time_md_s}\\n')\n",
        "# Run the 10ns MD simulation\n",
        "mdrun_md= 'gmx mdrun -deffnm md_1'\n",
        "gmx(mdrun_md)\n",
        "# Time when the first simulation ends\n",
        "time_md_e= time.time()\n",
        "date_time_md_e= datetime.fromtimestamp(time_md_e) # To convert the time by seconds to date and time\n",
        "with open('timer', 'a') as clk:\n",
        "  clk.write(f'MD 10ns:\\t\\t{date_time_md_e}\\n')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ##### Extended Simulation\n",
        "#@markdown ## If you want add other 10 ns to the sumlation, flag the box below:\n",
        "extend_simulation= False #@param {type:'boolean'}\n",
        "#@markdown ###### (this is strongly discouraged if you do not have colab pro)\n",
        "with open('options', 'w') as file:\n",
        "    file.write('Protein \\n System \\n')\n",
        "  # Puts the center of mass of molecules in the box\n",
        "trjconv= 'gmx trjconv -s md_1.tpr -f md_1.xtc -o md_10ns_1_protPBC.xtc -pbc mol -center -skip 100 < options'\n",
        "gmx(trjconv)\n",
        "# if statement\n",
        "if extend_simulation: # True\n",
        "  # Extend the simulation for 10ns\n",
        "  extend, mdrun_extend= 'gmx convert-tpr -s md_1.tpr -extend 10000 -o md_2.tpr', 'gmx mdrun -deffnm md_2 -cpi md_1.cpt -noappend'\n",
        "  gmx(extend)\n",
        "  gmx(mdrun_extend)\n",
        "  # Puts the center of mass of molecules in the box\n",
        "  trjconv_ex= 'gmx trjconv -s md_2.tpr -f md_2.xtc -o md_10ns_2_protPBC.xtc -pbc mol -center -skip 100 < options'\n",
        "  gmx(trjconv_ex)\n",
        "  # Merge the trajectories\n",
        "  merge= 'gmx trjcat -f md_10ns_*.xtc -o md_20ns_protPBC.xtc'\n",
        "  gmx(merge)\n",
        "  # Time when the second simulation ends\n",
        "  time_end= time.time()\n",
        "  date_time_end= datetime.fromtimestamp(time_end) # To convert the time by seconds to date and time\n",
        "  with open('timer', 'a') as clk:\n",
        "    clk.write(f'MD 20ns:\\t\\t\\t{date_time_end}\\n')\n",
        "# Time when the program ends\n",
        "time_end= time.time()\n",
        "date_time_end= datetime.fromtimestamp(time_end) # To convert the time by seconds to date and time\n",
        "with open('timer', 'a') as clk:\n",
        "  clk.write(f'End:\\t\\t\\t{date_time_end}\\n')"
      ],
      "metadata": {
        "id": "kwiSlH74kOsx"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "private_outputs": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}