DipoleVectorOrientationCalculation_v2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dye Separation = 14.708829491159385 Angstroms\n",
      "\n",
      "~~~~~ Corrections are being used for the initial coordinate axes guesses! ~~~~~\n",
      "\n",
      "Magnitude of ground state dipole vector for molecule m = 72.17643509498097\n",
      "Magnitude of ground state dipole vector for molecule n = 72.17643509498096\n",
      "\n",
      "Magnitude of excited state dipole vector for molecule m = 72.17992747114671\n",
      "Magnitude of excited state dipole vector for molecule n = 72.1799274711467\n",
      "\n",
      "Magnitude of transition dipole vector for molecule m = 37.360426907544834\n",
      "Magnitude of transition dipole vector for molecule n = 37.36042690754484\n",
      "\n",
      "Magnitude of static dipole difference vector for molecule m = 0.06590614538872898\n",
      "Magnitude of static dipole difference vector for molecule n = 0.06590614538873413 \n",
      "\n",
      "\n",
      "Dipole vector magnitudes are equal, the coordinate systems are OK.\n",
      "\n",
      "\n",
      "~~~~~~~~~~ RESULTS ~~~~~~~~~~\n",
      "\n",
      "J = -1523065123.716088\n",
      "K = -17053.459672986864\n",
      "\n",
      "J with no prefactor = -0.16928300746813174\n",
      "K with no prefactor = -1.8954284332479098e-06\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "dipolewarning = 0\n",
    "warning = 0\n",
    "\n",
    "##################################################################\n",
    "######################## BEGIN USER INPUT ########################\n",
    "##################################################################\n",
    "\n",
    "# Choose atoms that give best representation of coordinate axes i.e. the most orthonormal (doesn't have to be exact).\n",
    "\n",
    "# Atom positions to describe long and wide axes of molecule. Atom 1 will be for both the wide and long axes, \n",
    "# Atom 2 will be for the wide axis, and atom 3 will be for the long axis.\n",
    "\n",
    "AtomGaussian1 = [11.551421, 10.160481, 5.027279]\n",
    "AtomGaussian2 = [11.136760, 11.164395, 5.038672]\n",
    "AtomGaussian3 = [9.256161, 9.233892, 5.019294]\n",
    "\n",
    "# Atom positions (must be same atoms as above) from KRM calculations\n",
    "\n",
    "AtomKRM1_m = [-6.251 , -5.602, -3.902]\n",
    "AtomKRM2_m = [ -6.694 , -5.939, -4.835]\n",
    "AtomKRM3_m = [-4.004 , -6.352, -4.642]\n",
    "\n",
    "AtomKRM1_n = [-16.259, -0.094, -9.883]\n",
    "AtomKRM2_n = [-15.573,  0.605, -9.414]\n",
    "AtomKRM3_n = [-15.315,  0.619, -12.018]\n",
    "\n",
    "# Dipole moment information from Gaussian Calculations\n",
    "\n",
    "TransitionDipoleMoment_x_m = 11.33 * 2.54 # mutliplied by 2.54 to change Au to Debye\n",
    "TransitionDipoleMoment_y_m = -5.578 * 2.54\n",
    "TransitionDipoleMoment_z_m = 7.541 * 2.54\n",
    "\n",
    "GroundStateDipoleMoment_x_m = 50.2194\n",
    "GroundStateDipoleMoment_y_m = 45.8879\n",
    "GroundStateDipoleMoment_z_m = 24.1195\n",
    "\n",
    "ExcitedStateDipoleMoment_x_m = 50.2665\n",
    "ExcitedStateDipoleMoment_y_m = 45.8418\n",
    "ExcitedStateDipoleMoment_z_m = 24.1195\n",
    "\n",
    "CenterOfMassFromKRM_m = [-4.87400, -5.74300, -3.73700]\n",
    "CenterOfMassFromKRM_n = [-16.20400, -0.16500, -11.27800]\n",
    "\n",
    "Permittivity = 1\n",
    "\n",
    "UseCorrection = 1 # Set to 1 if you want initial coordinate guesses to be corrected.\n",
    "\n",
    "##################################################################\n",
    "######################### END USER INPUT #########################\n",
    "##################################################################\n",
    "\n",
    "\n",
    "\n",
    "### Finding dye separation vector ###\n",
    "\n",
    "DyeSeparationVector = np.subtract(CenterOfMassFromKRM_m,CenterOfMassFromKRM_n)\n",
    "DyeSeparationLength = np.linalg.norm(DyeSeparationVector)\n",
    "print(\"Dye Separation =\", DyeSeparationLength, \"Angstroms\")\n",
    "\n",
    "\n",
    "\n",
    "## Correcting initial coordinate system for molecule n ###\n",
    "\n",
    "if UseCorrection == 1:\n",
    "    print(\"\\n~~~~~ Corrections are being used for the initial coordinate axes guesses! ~~~~~\")\n",
    "    LongInitial_m = np.subtract(AtomGaussian1, AtomGaussian3)\n",
    "    WideInitial_m = np.subtract(AtomGaussian1, AtomGaussian2)\n",
    "\n",
    "    Correction_m = (-LongInitial_m[0]*WideInitial_m[0]-LongInitial_m[1]*WideInitial_m[1]-LongInitial_m[2]*WideInitial_m[2])/(LongInitial_m[0]+LongInitial_m[1]+LongInitial_m[2])\n",
    "\n",
    "    NewAtom2_1_m = np.subtract(AtomGaussian2,Correction_m)\n",
    "    NewAtom2_2_m = np.add(AtomGaussian2,Correction_m)\n",
    "\n",
    "    NewWide1_m = np.subtract(AtomGaussian1,NewAtom2_1_m)\n",
    "    NewWide2_m = np.subtract(AtomGaussian1,NewAtom2_2_m)\n",
    "\n",
    "    TestDot1_m = np.dot(LongInitial_m,NewWide1_m)\n",
    "    TestDot2_m = np.dot(LongInitial_m,NewWide2_m)\n",
    "\n",
    "    if abs(TestDot1_m) > abs(TestDot2_m):\n",
    "        AtomGaussian2 = NewAtom2_1_m\n",
    "\n",
    "    if abs(TestDot1_m) < abs(TestDot2_m):\n",
    "        AtomGaussian2 = NewAtom2_1_m\n",
    "\n",
    "    \n",
    "    \n",
    "### Finding translation vector from the KRM calculations and applying to Gaussian structure ###\n",
    "\n",
    "TranslationAtom1 = np.subtract(AtomKRM1_m,AtomKRM1_n)\n",
    "TranslationAtom2 = np.subtract(AtomKRM2_m,AtomKRM2_n)\n",
    "TranslationAtom3 = np.subtract(AtomKRM3_m,AtomKRM3_n)\n",
    "\n",
    "AtomGaussian1Translated = np.add(AtomGaussian1, TranslationAtom1)\n",
    "AtomGaussian2Translated = np.add(AtomGaussian2, TranslationAtom2)\n",
    "AtomGaussian3Translated = np.add(AtomGaussian3, TranslationAtom3)\n",
    "\n",
    "    \n",
    "    \n",
    "## Correcting initial coordinate system for molecule n ###\n",
    "    \n",
    "if UseCorrection == 1:\n",
    "    LongInitial_n = np.subtract(AtomGaussian1Translated, AtomGaussian3Translated)\n",
    "    WideInitial_n = np.subtract(AtomGaussian1Translated, AtomGaussian2Translated)\n",
    "\n",
    "    Correction_n = (-LongInitial_n[0]*WideInitial_n[0]-LongInitial_n[1]*WideInitial_n[1]-LongInitial_n[2]*WideInitial_n[2])/(LongInitial_n[0]+LongInitial_n[1]+LongInitial_n[2])\n",
    "\n",
    "    NewAtom2_1_n = np.subtract(AtomGaussian2Translated,Correction_n)\n",
    "    NewAtom2_2_n = np.add(AtomGaussian2Translated,Correction_n)\n",
    "\n",
    "    NewWide1_n = np.subtract(AtomGaussian1Translated,NewAtom2_1_n)\n",
    "    NewWide2_n = np.subtract(AtomGaussian1Translated,NewAtom2_2_n)\n",
    "\n",
    "    TestDot1_n = np.dot(LongInitial_n,NewWide1_n)\n",
    "    TestDot2_n = np.dot(LongInitial_n,NewWide2_n)\n",
    "    TestDot3_n = np.dot(LongInitial_n,WideInitial_n)\n",
    "\n",
    "    if abs(TestDot1_n) > abs(TestDot2_n):\n",
    "        AtomGaussian2Translated = NewAtom2_1_n\n",
    "    if abs(TestDot1_n) < abs(TestDot2_n):\n",
    "        AtomGaussian2Translated = NewAtom2_1_n\n",
    "\n",
    "    \n",
    "    \n",
    "### Finding vectors describing coordinate system of molecule m and n from Gaussian calculation ###\n",
    "\n",
    "LongAxis_m = np.subtract(AtomGaussian1,AtomGaussian3)\n",
    "WideAxis_m = np.subtract(AtomGaussian1,AtomGaussian2)\n",
    "VerticalAxis_m = np.cross(LongAxis_m,WideAxis_m)\n",
    "LengthLongAxis_m = np.linalg.norm(LongAxis_m)\n",
    "LenthWideAxis_m = np.linalg.norm(WideAxis_m)\n",
    "LengthVerticalAxis_m = np.linalg.norm(VerticalAxis_m)\n",
    "LongAxisUnit_m = LongAxis_m/LengthLongAxis_m\n",
    "WideAxisUnit_m = WideAxis_m/LenthWideAxis_m\n",
    "VerticalAxisUnit_m = VerticalAxis_m/LengthVerticalAxis_m\n",
    "\n",
    "LongAxis_n = np.subtract(AtomGaussian1Translated,AtomGaussian3Translated)\n",
    "WideAxis_n = np.subtract(AtomGaussian1Translated,AtomGaussian2Translated)\n",
    "VerticalAxis_n = np.cross(LongAxis_n,WideAxis_n)\n",
    "LengthLongAxis_n = np.linalg.norm(LongAxis_n)\n",
    "LenthWideAxis_n = np.linalg.norm(WideAxis_n)\n",
    "LengthVerticalAxis_n = np.linalg.norm(VerticalAxis_n)\n",
    "LongAxisUnit_n = LongAxis_n/LengthLongAxis_n\n",
    "WideAxisUnit_n = WideAxis_n/LenthWideAxis_n\n",
    "VerticalAxisUnit_n = VerticalAxis_n/LengthVerticalAxis_n\n",
    "\n",
    "\n",
    "\n",
    "### Check to make sure coordinate systems are set up correctly ###\n",
    "\n",
    "LongAxis_mDotWideAxis_m = np.dot(LongAxis_m,WideAxis_m)\n",
    "WideAxis_mDotVerticalAxis_m = np.dot(WideAxis_m,VerticalAxis_m)\n",
    "VerticalAxis_mDotLongAxis_m = np.dot(VerticalAxis_m,LongAxis_m)\n",
    "\n",
    "LongAxis_nDotWideAxis_n = np.dot(LongAxis_n,WideAxis_n)\n",
    "WideAxis_nDotVerticalAxis_n = np.dot(WideAxis_n,VerticalAxis_n)\n",
    "VerticalAxis_nDotLongAxis_n = np.dot(VerticalAxis_n,LongAxis_n)\n",
    "\n",
    "if abs(LongAxis_mDotWideAxis_m) > .000001:\n",
    "    print(\"\\nWARNING! The long axis and wide axis for molecule m aren't orthogonal.\")\n",
    "    warning = warning + 1\n",
    "if abs(WideAxis_mDotVerticalAxis_m) > .000001:\n",
    "    print(\"WARNING! The wide axis and vertical axis for molecule m aren't orthogonal.\")\n",
    "    warning = warning + 1\n",
    "if abs(VerticalAxis_mDotLongAxis_m) > .000001:\n",
    "    print(\"WARNING! The vertical axis and long axis for molecule m aren't orthogonal.\")\n",
    "    warning = warning + 1\n",
    "if abs(LongAxis_nDotWideAxis_n) > .000001:\n",
    "    print(\"WARNING! The long axis and wide axis for molecule n aren't orthogonal.\")\n",
    "    warning = warning + 1\n",
    "if abs(WideAxis_nDotVerticalAxis_n) > .000001:\n",
    "    print(\"WARNING! The wide axis and vertical axis for molecule n aren't orthogonal.\")\n",
    "    warning = warning + 1\n",
    "if abs(VerticalAxis_nDotLongAxis_n) > .000001:\n",
    "    print(\"WARNING! The vertical axis and long axis for molecule n aren't orthogonal.\")\n",
    "    warning = warning + 1\n",
    "\n",
    "    \n",
    "    \n",
    "### Finding projections of dipole moments onto molecule m's coordinates ###\n",
    "\n",
    "GroundStateDipoleMoment_m = np.array([GroundStateDipoleMoment_x_m,GroundStateDipoleMoment_y_m,GroundStateDipoleMoment_z_m])\n",
    "GroundStateDipoleMomentLength_m = np.linalg.norm(GroundStateDipoleMoment_m)\n",
    "ExcitedStateDipoleMoment_m = np.array([ExcitedStateDipoleMoment_x_m,ExcitedStateDipoleMoment_y_m,ExcitedStateDipoleMoment_z_m])\n",
    "ExcitedStateDipoleMomentLength_m = np.linalg.norm(ExcitedStateDipoleMoment_m)\n",
    "TransitionDipoleMoment_m = np.array([TransitionDipoleMoment_x_m,TransitionDipoleMoment_y_m,TransitionDipoleMoment_z_m])\n",
    "TransitionDipoleMomentLength_m = np.linalg.norm(TransitionDipoleMoment_m)\n",
    "\n",
    "GroundStateDipoleMomentProjection_x_m = np.dot(LongAxisUnit_m,GroundStateDipoleMoment_m)\n",
    "GroundStateDipoleMomentProjection_y_m = np.dot(WideAxisUnit_m,GroundStateDipoleMoment_m)\n",
    "GroundStateDipoleMomentProjection_z_m = np.dot(VerticalAxisUnit_m,GroundStateDipoleMoment_m)\n",
    "\n",
    "ExcitedStateDipoleMomentProjection_x_m = np.dot(LongAxisUnit_m,ExcitedStateDipoleMoment_m)\n",
    "ExcitedStateDipoleMomentProjection_y_m = np.dot(WideAxisUnit_m,ExcitedStateDipoleMoment_m)\n",
    "ExcitedStateDipoleMomentProjection_z_m = np.dot(VerticalAxisUnit_m,ExcitedStateDipoleMoment_m)\n",
    "\n",
    "TransitionDipoleMomentProjection_x_m = np.dot(LongAxisUnit_m,TransitionDipoleMoment_m)\n",
    "TransitionDipoleMomentProjection_y_m = np.dot(WideAxisUnit_m,TransitionDipoleMoment_m)\n",
    "TransitionDipoleMomentProjection_z_m = np.dot(VerticalAxisUnit_m,TransitionDipoleMoment_m)\n",
    "\n",
    "\n",
    "\n",
    "### Finding molecule n's dipole moments ###\n",
    "\n",
    "GroundStateDipoleMomentProjection_x_n = GroundStateDipoleMomentProjection_x_m*LongAxisUnit_n[0] + GroundStateDipoleMomentProjection_y_m*WideAxisUnit_n[0] + GroundStateDipoleMomentProjection_z_m*VerticalAxisUnit_n[0]\n",
    "GroundStateDipoleMomentProjection_y_n = GroundStateDipoleMomentProjection_x_m*LongAxisUnit_n[1] + GroundStateDipoleMomentProjection_y_m*WideAxisUnit_n[1] + GroundStateDipoleMomentProjection_z_m*VerticalAxisUnit_n[1]\n",
    "GroundStateDipoleMomentProjection_z_n = GroundStateDipoleMomentProjection_x_m*LongAxisUnit_n[2] + GroundStateDipoleMomentProjection_y_m*WideAxisUnit_n[2] + GroundStateDipoleMomentProjection_z_m*VerticalAxisUnit_n[2]\n",
    "\n",
    "GroundStateDipoleMoment_n = np.array([GroundStateDipoleMomentProjection_x_n,GroundStateDipoleMomentProjection_y_n,GroundStateDipoleMomentProjection_z_n])\n",
    "GroundStateDipoleMomentLength_n = np.linalg.norm(GroundStateDipoleMoment_n)\n",
    "\n",
    "ExcitedStateDipoleMomentProjection_x_n = ExcitedStateDipoleMomentProjection_x_m*LongAxisUnit_n[0] + ExcitedStateDipoleMomentProjection_y_m*WideAxisUnit_n[0] + ExcitedStateDipoleMomentProjection_z_m*VerticalAxisUnit_n[0]\n",
    "ExcitedStateDipoleMomentProjection_y_n = ExcitedStateDipoleMomentProjection_x_m*LongAxisUnit_n[1] + ExcitedStateDipoleMomentProjection_y_m*WideAxisUnit_n[1] + ExcitedStateDipoleMomentProjection_z_m*VerticalAxisUnit_n[1]\n",
    "ExcitedStateDipoleMomentProjection_z_n = ExcitedStateDipoleMomentProjection_x_m*LongAxisUnit_n[2] + ExcitedStateDipoleMomentProjection_y_m*WideAxisUnit_n[2] + ExcitedStateDipoleMomentProjection_z_m*VerticalAxisUnit_n[2]\n",
    "\n",
    "ExcitedStateDipoleMoment_n = np.array([ExcitedStateDipoleMomentProjection_x_n,ExcitedStateDipoleMomentProjection_y_n,ExcitedStateDipoleMomentProjection_z_n])\n",
    "ExcitedStateDipoleMomentLength_n = np.linalg.norm(ExcitedStateDipoleMoment_n)\n",
    "\n",
    "TransitionDipoleMomentProjection_x_n = TransitionDipoleMomentProjection_x_m*LongAxisUnit_n[0] + TransitionDipoleMomentProjection_y_m*WideAxisUnit_n[0] + TransitionDipoleMomentProjection_z_m*VerticalAxisUnit_n[0]\n",
    "TransitionDipoleMomentProjection_y_n = TransitionDipoleMomentProjection_x_m*LongAxisUnit_n[1] + TransitionDipoleMomentProjection_y_m*WideAxisUnit_n[1] + TransitionDipoleMomentProjection_z_m*VerticalAxisUnit_n[1]\n",
    "TransitionDipoleMomentProjection_z_n = TransitionDipoleMomentProjection_x_m*LongAxisUnit_n[2] + TransitionDipoleMomentProjection_y_m*WideAxisUnit_n[2] + TransitionDipoleMomentProjection_z_m*VerticalAxisUnit_n[2]\n",
    "\n",
    "TransitionDipoleMoment_n = np.array([TransitionDipoleMomentProjection_x_n,TransitionDipoleMomentProjection_y_n,TransitionDipoleMomentProjection_z_n])\n",
    "TransitionDipoleMomentLength_n = np.linalg.norm(TransitionDipoleMoment_n)\n",
    "\n",
    "StaticDipoleDifference_m = np.subtract(ExcitedStateDipoleMoment_m,GroundStateDipoleMoment_m)\n",
    "StaticDipoleDifferenceLength_m = np.linalg.norm(StaticDipoleDifference_m)\n",
    "StaticDipoleDifference_n = np.subtract(ExcitedStateDipoleMoment_n,GroundStateDipoleMoment_n)\n",
    "StaticDipoleDifferenceLength_n = np.linalg.norm(StaticDipoleDifference_n)\n",
    "\n",
    "\n",
    "\n",
    "### Printing out dipole vector lengths and verifying values ###\n",
    "\n",
    "print(\"\\nMagnitude of ground state dipole vector for molecule m =\", GroundStateDipoleMomentLength_m)\n",
    "print(\"Magnitude of ground state dipole vector for molecule n =\", GroundStateDipoleMomentLength_n)\n",
    "\n",
    "print(\"\\nMagnitude of excited state dipole vector for molecule m =\", ExcitedStateDipoleMomentLength_m)\n",
    "print(\"Magnitude of excited state dipole vector for molecule n =\", ExcitedStateDipoleMomentLength_n)\n",
    "\n",
    "print(\"\\nMagnitude of transition dipole vector for molecule m =\", TransitionDipoleMomentLength_m)\n",
    "print(\"Magnitude of transition dipole vector for molecule n =\", TransitionDipoleMomentLength_n)\n",
    "\n",
    "print(\"\\nMagnitude of static dipole difference vector for molecule m =\", StaticDipoleDifferenceLength_m)\n",
    "print(\"Magnitude of static dipole difference vector for molecule n =\", StaticDipoleDifferenceLength_n , \"\\n\")\n",
    "\n",
    "\n",
    "if abs(GroundStateDipoleMomentLength_m - GroundStateDipoleMomentLength_n) > .00000001:\n",
    "    warning = warning + 1\n",
    "    dipolewarning = dipolewarning + 1\n",
    "if abs(ExcitedStateDipoleMomentLength_m - ExcitedStateDipoleMomentLength_n) > .00000001:\n",
    "    dipolewarning = dipolewarning + 1    \n",
    "    warning = warning + 1\n",
    "if abs(TransitionDipoleMomentLength_m - TransitionDipoleMomentLength_n) > .00000001:\n",
    "    dipolewarning = dipolewarning + 1    \n",
    "    warning = warning + 1\n",
    "\n",
    "if dipolewarning != 0:\n",
    "    print(\"WARNING! One or more of the dipole magnitudes for molecules m and n are different. \\nCoordinate systems might not be defined well.\")\n",
    "    \n",
    "if warning == 0:\n",
    "    print(\"\\nDipole vector magnitudes are equal, the coordinate systems are OK.\")\n",
    "\n",
    "\n",
    "### Calculating J and K ###\n",
    "\n",
    "print(\"\\n\\n~~~~~~~~~~ RESULTS ~~~~~~~~~~\\n\")\n",
    "\n",
    "DotProductStaticDipoleDifferenceVectors = np.dot(StaticDipoleDifference_m,StaticDipoleDifference_n)\n",
    "DotProductStaticDipoleDifferenceSeparation_m = np.dot(StaticDipoleDifference_m,DyeSeparationVector)\n",
    "DotProductStaticDipoleDifferenceSeparation_n = np.dot(StaticDipoleDifference_n,DyeSeparationVector)\n",
    "DotProductTranistionDipoleVectors = np.dot(TransitionDipoleMoment_m,TransitionDipoleMoment_n)\n",
    "DotProductTranistionDipoleSeparation_m = np.dot(TransitionDipoleMoment_m,DyeSeparationVector)\n",
    "DotProductTranistionDipoleSeparation_n = np.dot(TransitionDipoleMoment_n,DyeSeparationVector)\n",
    "\n",
    "J = (1/(4*3.1415*Permittivity*0.000000000008845))*((DotProductTranistionDipoleVectors/(DyeSeparationLength**3))-(3*DotProductTranistionDipoleSeparation_m*DotProductTranistionDipoleSeparation_n/(DyeSeparationLength**5)))\n",
    "K = (1/(4*3.1415*Permittivity*0.000000000008845))*((DotProductStaticDipoleDifferenceVectors/(DyeSeparationLength**3))-(3*DotProductStaticDipoleDifferenceSeparation_m*DotProductStaticDipoleDifferenceSeparation_n/(DyeSeparationLength**5)))\n",
    "\n",
    "JNoPreFactor = ((DotProductTranistionDipoleVectors/(DyeSeparationLength**3))-(3*DotProductTranistionDipoleSeparation_m*DotProductTranistionDipoleSeparation_n/(DyeSeparationLength**5)))\n",
    "KNoPreFactor = ((DotProductStaticDipoleDifferenceVectors/(DyeSeparationLength**3))-(3*DotProductStaticDipoleDifferenceSeparation_m*DotProductStaticDipoleDifferenceSeparation_n/(DyeSeparationLength**5)))\n",
    "\n",
    "print(\"J =\", J)\n",
    "print(\"K =\", K)\n",
    "\n",
    "print(\"\\nJ with no prefactor =\", JNoPreFactor)\n",
    "print(\"K with no prefactor =\", KNoPreFactor)\n",
    "\n",
    "if warning !=0:\n",
    "    print(\"\\n!!! Calculated J and K values are probably not accurate, check coordinate descriptions. !!!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}