{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "quickstart-intro",
   "metadata": {},
   "source": [
    "# Quickstart\n",
    "\n",
    "**GaInt** (Gaussian Integration) is a Python package for computing molecular integrals of primitive Cartesian Gaussian orbitals.\n",
    "\n",
    "This tutorial will guide you through the basic usage of GaInt for quantum chemistry calculations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "import-section",
   "metadata": {},
   "source": [
    "## Importing Required Modules\n",
    "\n",
    "First, import the core modules of GaInt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "import-modules",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GaInt modules imported successfully!\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from gaint.gauss import PrimitiveGaussian\n",
    "from gaint.obara_saika.overlap import Overlap\n",
    "from gaint.obara_saika.kinetic import Kinetic\n",
    "from gaint.obara_saika.nuclear_attraction import NuclearAttraction\n",
    "from gaint.obara_saika.electron_repulsion import ElectronRepulsion\n",
    "\n",
    "print(\"GaInt modules imported successfully!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "basic-usage",
   "metadata": {},
   "source": [
    "## Basic Usage: Creating Gaussian Orbitals\n",
    "\n",
    "Create a primitive Gaussian orbital:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "create-gaussian",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orbital type: s orbital\n",
      "Origin: [0.0, 0.0, 0.0]\n",
      "Exponent: 1.0\n",
      "Normalization factor: 0.7127054703549901\n"
     ]
    }
   ],
   "source": [
    "# Create an s-type Gaussian orbital\n",
    "# Parameters: coefficient, origin, angular momentum, exponent\n",
    "s_orbital = PrimitiveGaussian(\n",
    "    coefficient=1.0,\n",
    "    origin=[0.0, 0.0, 0.0],\n",
    "    shell=[0, 0, 0],  # s orbital: angular momentum [0,0,0]\n",
    "    exponent=1.0\n",
    ")\n",
    "\n",
    "print(f\"Orbital type: s orbital\")\n",
    "print(f\"Origin: {s_orbital.origin}\")\n",
    "print(f\"Exponent: {s_orbital.exponent}\")\n",
    "print(f\"Normalization factor: {s_orbital.norm}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "p-orbitals",
   "metadata": {},
   "source": [
    "## Creating p Orbitals\n",
    "\n",
    "Create p orbitals in different directions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "create-p-orbitals",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "px orbital normalization factor: 1.4254109407099802\n",
      "py orbital normalization factor: 1.4254109407099802\n",
      "pz orbital normalization factor: 1.4254109407099802\n"
     ]
    }
   ],
   "source": [
    "# Create px orbital (angular momentum [1,0,0])\n",
    "px_orbital = PrimitiveGaussian(\n",
    "    coefficient=1.0,\n",
    "    origin=[0.0, 0.0, 0.0],\n",
    "    shell=[1, 0, 0],  # px orbital\n",
    "    exponent=1.0\n",
    ")\n",
    "\n",
    "# Create py orbital (angular momentum [0,1,0])\n",
    "py_orbital = PrimitiveGaussian(\n",
    "    coefficient=1.0,\n",
    "    origin=[0.0, 0.0, 0.0],\n",
    "    shell=[0, 1, 0],  # py orbital\n",
    "    exponent=1.0\n",
    ")\n",
    "\n",
    "# Create pz orbital (angular momentum [0,0,1])\n",
    "pz_orbital = PrimitiveGaussian(\n",
    "    coefficient=1.0,\n",
    "    origin=[0.0, 0.0, 0.0],\n",
    "    shell=[0, 0, 1],  # pz orbital\n",
    "    exponent=1.0\n",
    ")\n",
    "\n",
    "print(f\"px orbital normalization factor: {px_orbital.norm}\")\n",
    "print(f\"py orbital normalization factor: {py_orbital.norm}\")\n",
    "print(f\"pz orbital normalization factor: {pz_orbital.norm}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "overlap-integral",
   "metadata": {},
   "source": [
    "## Computing Overlap Integrals\n",
    "\n",
    "Calculate overlap integrals between two orbitals using the Obara-Saika scheme:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "calculate-overlap",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s-s orbital overlap: 1.968701\n",
      "s-px orbital overlap: 0.000000 (should be close to 0 due to orthogonality)\n",
      "px-px orbital overlap: 0.492175\n"
     ]
    }
   ],
   "source": [
    "# Create overlap integral calculator\n",
    "overlap_calculator = Overlap()\n",
    "\n",
    "# Compute s-s orbital overlap (same center)\n",
    "s_s_overlap = overlap_calculator(s_orbital, s_orbital)\n",
    "print(f\"s-s orbital overlap: {s_s_overlap:.6f}\")\n",
    "\n",
    "# Compute s-px orbital overlap (orthogonality test)\n",
    "s_px_overlap = overlap_calculator(s_orbital, px_orbital)\n",
    "print(f\"s-px orbital overlap: {s_px_overlap:.6f} (should be close to 0 due to orthogonality)\")\n",
    "\n",
    "# Compute px-px orbital overlap\n",
    "px_px_overlap = overlap_calculator(px_orbital, px_orbital)\n",
    "print(f\"px-px orbital overlap: {px_px_overlap:.6f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "kinetic-integral",
   "metadata": {},
   "source": [
    "## Computing Kinetic Energy Integrals\n",
    "\n",
    "Calculate kinetic energy integrals:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "calculate-kinetic",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s orbital kinetic integral: 2.953052\n",
      "px orbital kinetic integral: 1.230438\n"
     ]
    }
   ],
   "source": [
    "# Create kinetic integral calculator\n",
    "kinetic_calculator = Kinetic()\n",
    "\n",
    "# Compute kinetic integral for s orbital\n",
    "s_kinetic = kinetic_calculator(s_orbital, s_orbital)\n",
    "print(f\"s orbital kinetic integral: {s_kinetic:.6f}\")\n",
    "\n",
    "# Compute kinetic integral for px orbital\n",
    "px_kinetic = kinetic_calculator(px_orbital, px_orbital)\n",
    "print(f\"px orbital kinetic integral: {px_kinetic:.6f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nuclear-attraction",
   "metadata": {},
   "source": [
    "## Computing Nuclear Attraction Integrals\n",
    "\n",
    "Calculate attraction integrals between electrons and nuclei:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "calculate-nuclear-attraction",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s orbital nuclear attraction integral: 3.141593\n",
      "px orbital nuclear attraction integral: 0.523599\n"
     ]
    }
   ],
   "source": [
    "# Create nuclear attraction integral calculator\n",
    "nuclear_calculator = NuclearAttraction()\n",
    "\n",
    "# Define nucleus position and charge\n",
    "nucleus_position = [0.0, 0.0, 0.0]  # Nucleus position\n",
    "nuclear_charge = 1.0  # Hydrogen nucleus charge\n",
    "\n",
    "# Compute nuclear attraction integral for s orbital\n",
    "s_nuclear = nuclear_calculator(s_orbital, s_orbital, nucleus_position)\n",
    "print(f\"s orbital nuclear attraction integral: {s_nuclear:.6f}\")\n",
    "\n",
    "# Compute nuclear attraction integral for px orbital\n",
    "px_nuclear = nuclear_calculator(px_orbital, px_orbital, nucleus_position)\n",
    "print(f\"px orbital nuclear attraction integral: {px_nuclear:.6f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdde5c73",
   "metadata": {},
   "source": [
    "## Computing Electron Repulsion Integrals\n",
    "\n",
    "Calculate repulsion integrals between electrons:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "803a4368",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s orbital repulsion integral: 4.373355\n",
      "px orbital repulsion integral: 0.223223\n"
     ]
    }
   ],
   "source": [
    "# Create electron repulsion integral calculator\n",
    "eri_calculator = ElectronRepulsion()\n",
    "\n",
    "# Compute kinetic integral for s orbital\n",
    "eri1717 = eri_calculator(s_orbital,s_orbital,s_orbital,s_orbital)\n",
    "print(f\"s orbital repulsion integral: {eri1717:.6f}\")\n",
    "\n",
    "# Compute kinetic integral for px orbital\n",
    "eri1717 = eri_calculator(px_orbital,px_orbital,px_orbital,px_orbital)\n",
    "print(f\"px orbital repulsion integral: {eri1717:.6f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.13.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}