{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test of F12 matrix elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#cd \"/home/scemama/QCaml\";;\n",
    "#use \"topfind\";;\n",
    "#require \"jupyter.notebook\";;\n",
    "\n",
    "let png_image name = \n",
    "    Jupyter_notebook.display_file ~base64:true \"image/png\" (\"Notebooks/images/\"^name)\n",
    ";;\n",
    "\n",
    "#require \"lacaml.top\";;\n",
    "#require \"alcotest\";;\n",
    "#require \"str\";;\n",
    "#require \"bigarray\";;\n",
    "#require \"zarith\";;\n",
    "#require \"getopt\";;\n",
    "#directory \"_build\";;\n",
    "#directory \"_build/Basis\";;\n",
    "#directory \"_build/CI\";;\n",
    "#directory \"_build/MOBasis\";;\n",
    "#directory \"_build/Nuclei\";;\n",
    "#directory \"_build/Parallel\";;\n",
    "#directory \"_build/Perturbation\";;\n",
    "#directory \"_build/SCF\";;\n",
    "#directory \"_build/Utils\";;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules to load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load \"Constants.cmo\";;\n",
    "#load_rec \"Util.cma\";;\n",
    "#load_rec \"Matrix.cmo\";;\n",
    "#load_rec \"Simulation.cmo\";;\n",
    "#load_rec \"Spindeterminant.cmo\";;\n",
    "#load_rec \"Determinant.cmo\";;\n",
    "#load_rec \"HartreeFock.cmo\";;\n",
    "#load_rec \"MOBasis.cmo\";;\n",
    "#load_rec \"F12CI.cmo\";;\n",
    "\n",
    "open Lacaml.D;;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#install_printer AngularMomentum.pp_string ;;\n",
    "#install_printer Basis.pp ;;\n",
    "#install_printer Charge.pp ;;\n",
    "#install_printer Coordinate.pp ;;\n",
    "#install_printer Vector.pp;;\n",
    "#install_printer Matrix.pp;;\n",
    "#install_printer Util.pp_float_2darray;;\n",
    "#install_printer Util.pp_float_array;;\n",
    "#install_printer Util.pp_matrix;;\n",
    "#install_printer HartreeFock.pp ;;\n",
    "#install_printer Fock.pp ;;\n",
    "#install_printer MOClass.pp ;;\n",
    "let pp_mo ppf t = MOBasis.pp ~start:1 ~finish:0 ppf t ;;\n",
    "#install_printer pp_mo;;\n",
    "#install_printer DeterminantSpace.pp;;\n",
    "#install_printer SpindeterminantSpace.pp;;\n",
    "#install_printer Bitstring.pp;;\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let basis_filename  = \"/home/scemama/qp2/data/basis/6-31g\" \n",
    "let aux_basis_filename = \"/home/scemama/qp2/data/basis/cc-pvdz\" \n",
    "let nuclei = Nuclei.of_zmt_string \"be\" \n",
    "let frozen_core = false\n",
    "let multiplicity = 1\n",
    "let state = 1\n",
    "\n",
    "let basis =  Basis.of_nuclei_and_basis_filenames ~nuclei [basis_filename] \n",
    "let aux_basis =  Basis.of_nuclei_and_basis_filenames ~nuclei (basis_filename :: aux_basis_filename :: []) \n",
    "let f12 = F12factor.gaussian_geminal 1.0 \n",
    "let charge = 0 \n",
    "\n",
    "\n",
    "let simulation =\n",
    "    Simulation.make \n",
    "        ~f12 ~charge ~multiplicity ~nuclei\n",
    "        ~cartesian:true\n",
    "        basis\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hartree-Fock"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let hf =  HartreeFock.make ~guess:`Hcore  simulation  ;;\n",
    "\n",
    "let mo_basis = MOBasis.of_hartree_fock hf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FCI-F12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notations:\n",
    "\n",
    "* $\\langle ij || kl \\rangle = \\int \\phi_i(r_1) \\phi_j(r_2) \\frac{1}{r_{12}} \\phi_k(r1) \\phi_l(r2) $ \n",
    "* $\\left[ ij || kl \\right] = \\int \\phi_i(r_1) \\phi_j(r_2) f_{12} \\phi_k(r1) \\phi_l(r2) $ \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let f12 = Util.of_some @@ Simulation.f12 simulation \n",
    "\n",
    "let mo_num = MOBasis.size mo_basis \n",
    "\n",
    "let pp_spindet = Spindeterminant.pp mo_num\n",
    "\n",
    "let pp_det = Determinant.pp mo_num\n",
    "\n",
    ";;\n",
    "\n",
    "#install_printer pp_spindet ;;\n",
    "#install_printer pp_det ;;\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let simulation_aux = \n",
    "    let charge        = Charge.to_int @@ Simulation.charge simulation \n",
    "    and multiplicity  = Electrons.multiplicity @@ Simulation.electrons simulation\n",
    "    and nuclei        = Simulation.nuclei simulation\n",
    "    in\n",
    "    let general_basis = \n",
    "      Basis.general_basis @@ Simulation.basis simulation\n",
    "    in\n",
    "    GeneralBasis.combine [\n",
    "      general_basis ; GeneralBasis.read aux_basis_filename\n",
    "    ]\n",
    "    |> Basis.of_nuclei_and_general_basis nuclei\n",
    "    |> Simulation.make ~f12 ~charge ~multiplicity ~nuclei \n",
    "\n",
    "\n",
    "let aux_basis = \n",
    "  MOBasis.of_mo_basis simulation_aux mo_basis\n",
    "\n",
    "let aux_num = \n",
    "  MOBasis.size aux_basis\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "let () = ignore @@ MOBasis.f12_ints   aux_basis\n",
    "let () = ignore @@ MOBasis.two_e_ints aux_basis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Determinant-based functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integrals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation}\n",
    "\\langle I | \\hat{H} | J \\rangle = \\begin{cases}\n",
    "\\sum_i h_{ii} + \\frac{1}{2} \\sum_{ij} \\langle ij || ij \\rangle \\text{ when } |J\\rangle = |I\\rangle \\\\\n",
    "h_{ik} + \\sum_{j} \\langle ij || kj \\rangle \\text{ when } |J\\rangle = \\hat{T}_i^k |I\\rangle \\\\\n",
    "\\langle ij || kl \\rangle \\text{ when } |J\\rangle = \\hat{T}_{ij}^{kl} |I\\rangle \\\\\n",
    "\\end{cases}\n",
    "\\end{equation}\n",
    "\n",
    "\n",
    "\\begin{equation}\n",
    "\\langle I | \\hat{F} | J \\rangle = \\begin{cases}\n",
    "\\sum_i f_{ii} + \\frac{1}{2} \\sum_{ij} \\langle ij || ij \\rangle \\text{ when } |J\\rangle = |I\\rangle \\\\\n",
    "f_{ik} + \\sum_{j} \\langle ij || kj \\rangle \\text{ when } |J\\rangle = \\hat{T}_i^k |I\\rangle \\\\\n",
    "\\langle ij || kl \\rangle \\text{ when } |J\\rangle = \\hat{T}_{ij}^{kl} |I\\rangle \\\\\n",
    "\\end{cases}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let cancel_singles = false \n",
    "\n",
    "let f12_integrals mo_basis =\n",
    "\n",
    "  \n",
    "  let two_e_ints  = MOBasis.f12_ints mo_basis in\n",
    "  let f2 i j k l s s' =\n",
    "      let ijkl = F12.get_phys two_e_ints i j k l in\n",
    "      let ijlk = F12.get_phys two_e_ints i j l k in\n",
    "      if s' <> s then\n",
    "        ijkl \n",
    "      else\n",
    "        (ijkl -. ijlk) \n",
    "  in\n",
    "  ( (fun _ _ _ -> 0.),\n",
    "    (if cancel_singles then\n",
    "        (fun i j k l s s' ->\n",
    "        (* Required to cancel out single excitations *)\n",
    "           if (i=k && j<>l) || (j=l && i<>k) then\n",
    "              0.\n",
    "           else\n",
    "              f2 i j k l s s'\n",
    "        ) \n",
    "    else f2),\n",
    "    None\n",
    "  )\n",
    "\n",
    "let h_ij mo_basis ki kj =\n",
    "  let integrals =\n",
    "    List.map (fun f -> f mo_basis)\n",
    "      [ CI.h_integrals ]\n",
    "  in\n",
    "  CIMatrixElement.make integrals ki kj \n",
    "  |> List.hd\n",
    "\n",
    "\n",
    "let f_ij mo_basis ki kj =\n",
    "  let integrals =\n",
    "    List.map (fun f -> f mo_basis)\n",
    "      [ f12_integrals ]\n",
    "  in\n",
    "  CIMatrixElement.make integrals ki kj \n",
    "  |> List.hd                                                                                  \n",
    "\n",
    "\n",
    "let hf_ij mo_basis ki kj =\n",
    "  let integrals =\n",
    "    List.map (fun f -> f mo_basis)\n",
    "      [ CI.h_integrals ; f12_integrals ]\n",
    "  in\n",
    "  CIMatrixElement.make integrals ki kj\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determinant space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let is_a_double det_space =\n",
    "    let mo_class      = DeterminantSpace.mo_class det_space in\n",
    "    let mo_num = Array.length @@ MOClass.mo_class_array mo_class in\n",
    "    let m l =\n",
    "      List.fold_left (fun accu i ->\n",
    "          let j = i-1 in Bitstring.logor accu (Bitstring.shift_left_one mo_num j)\n",
    "        ) (Bitstring.zero mo_num) l\n",
    "    in\n",
    "    let aux_mask   = m (MOClass.auxiliary_mos mo_class) in\n",
    "    fun k ->                                                                                  \n",
    "      let alfa =\n",
    "        Determinant.alfa k\n",
    "        |> Spindeterminant.bitstring\n",
    "      in\n",
    "      let beta =\n",
    "        Determinant.beta k\n",
    "        |> Spindeterminant.bitstring\n",
    "      in\n",
    "      let a = Bitstring.logand aux_mask alfa\n",
    "      and b = Bitstring.logand aux_mask beta\n",
    "      in\n",
    "      match Bitstring.popcount a + Bitstring.popcount b with\n",
    "      | 2 | 1 -> true\n",
    "      | 0 | _ -> false\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let in_space = \n",
    "    DeterminantSpace.fci_f12_of_mo_basis aux_basis ~frozen_core mo_num\n",
    "    \n",
    "let aux_space = \n",
    "    DeterminantSpace.fci_of_mo_basis aux_basis ~frozen_core \n",
    "\n",
    "let det_space_in () =\n",
    "    DeterminantSpace.determinant_stream in_space\n",
    "\n",
    "let det_space_out () =\n",
    "    let s = \n",
    "        DeterminantSpace.determinant_stream aux_space\n",
    "    in\n",
    "    Stream.from (fun _ ->\n",
    "        try\n",
    "          let is_a_double = is_a_double in_space in\n",
    "          let rec result () =\n",
    "            let ki = Stream.next s in\n",
    "            if is_a_double ki then\n",
    "              Some (ki,ki)\n",
    "            else\n",
    "              result ()\n",
    "          in\n",
    "          result ()\n",
    "        with Stream.Failure -> None\n",
    "      )\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let ci = CI.make ~n_states:state in_space\n",
    "\n",
    "let ci_coef, ci_energy = Lazy.force ci.eigensystem \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Permutation operator $p_{12}$ that generates a new determinant with electrons 1 and 2 swapped."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "let p12 det_space =\n",
    "    let mo_class      = DeterminantSpace.mo_class det_space in\n",
    "    let mo_num = Array.length @@ MOClass.mo_class_array mo_class in\n",
    "    let m l =\n",
    "      List.fold_left (fun accu i ->\n",
    "          let j = i-1 in Bitstring.logor accu (Bitstring.shift_left_one mo_num j)\n",
    "        ) (Bitstring.zero mo_num) l\n",
    "    in\n",
    "    let aux_mask = m (MOClass.auxiliary_mos mo_class) in\n",
    "    let not_aux_mask =\n",
    "      Bitstring.(shift_left_one mo_num (mo_num-1) |> minus_one |> logxor aux_mask)\n",
    "    in\n",
    "    fun k ->\n",
    "      let alfa =\n",
    "        Determinant.alfa k\n",
    "        |> Spindeterminant.bitstring\n",
    "      in\n",
    "      let beta =\n",
    "        Determinant.beta k\n",
    "        |> Spindeterminant.bitstring\n",
    "      in\n",
    "      let a = Bitstring.logand aux_mask alfa\n",
    "      and b = Bitstring.logand aux_mask beta\n",
    "      in\n",
    "      match Bitstring.popcount a, Bitstring.popcount b with\n",
    "      | 2, 0  \n",
    "      | 0, 2 -> Some (Determinant.negate_phase k)\n",
    "      | 1, 1 -> Some (Determinant.of_spindeterminants\n",
    "                  (Spindeterminant.of_bitstring  @@\n",
    "                    Bitstring.(logor b (logand not_aux_mask alfa)) )\n",
    "                  (Spindeterminant.of_bitstring  @@\n",
    "                    Bitstring.(logor a (logand not_aux_mask beta))\n",
    "                  ) )\n",
    "      | 1, 0 \n",
    "      | 0, 1 -> Some k\n",
    "      | _ -> None\n",
    "                    \n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integral-based functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrices $\\langle I | H | \\alpha \\rangle$ and $\\langle I | F | \\alpha \\rangle$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let out_list =\n",
    "    Util.stream_to_list (det_space_out ())\n",
    "    \n",
    "let in_list =\n",
    "    Util.stream_to_list (det_space_in ())\n",
    "    \n",
    "let det_a = Array.of_list out_list\n",
    "            |> Array.map (fun (i,_) -> i)\n",
    "\n",
    "let det_I = Array.of_list in_list\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "let m_H_aux, m_F_aux = \n",
    "        \n",
    "    let rec col_vecs_list accu_H accu_F = function\n",
    "    | [] -> \n",
    "        List.rev accu_H, \n",
    "        List.rev accu_F \n",
    "    | (ki, ki') :: rest when ki = ki' ->\n",
    "        begin\n",
    "            let h, f = \n",
    "              List.map (fun kj ->\n",
    "              match hf_ij aux_basis kj ki with\n",
    "              | [ a ; b ] -> a, b\n",
    "              | _ -> assert false ) in_list\n",
    "              |> List.split\n",
    "            in\n",
    "            let h  = Vec.of_list h in\n",
    "            let f  = Vec.of_list f in\n",
    "            scal 0.5 f;  (* Specific to He singlet *)\n",
    "            col_vecs_list (h::accu_H) (f::accu_F) rest\n",
    "        end\n",
    "    | (ki, ki') :: rest ->\n",
    "        begin\n",
    "        assert false;\n",
    "        end\n",
    "    in\n",
    "    let h, f = \n",
    "      col_vecs_list [] [] out_list\n",
    "    in\n",
    "    Mat.of_col_vecs_list h,\n",
    "    Mat.of_col_vecs_list f\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function to generate all intermediate external determinants $|\\alpha \\rangle$ between $|I\\rangle$ and $|J\\rangle$, with a positive phase factor.\n",
    "\n",
    "* `exc` is the degree of excitation between $|I\\rangle$ and $|J\\rangle$\n",
    "* `cabs` is the number of electrons in the CABS\n",
    "* `l` is the degree of excitation between $|I\\rangle$ and $|\\alpha \\rangle$\n",
    "* `r` is the degree of excitation between $|\\alpha \\rangle$ and $|J\\rangle$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let mos_cabs = \n",
    "  Util.list_range (mo_num+1) aux_num\n",
    "\n",
    "\n",
    "let generate_alphas ki kj exc cabs l r =\n",
    "  (* Check input excitation degree *)\n",
    "  let d = Determinant.degree ki kj in\n",
    "  if d <> exc then\n",
    "    Printf.sprintf \"Invalid excitation degree. Expected %d and found %d.\" exc d\n",
    "    |> failwith;\n",
    "    \n",
    "  (* Generate single excitations *)\n",
    "  let all_singles ki =\n",
    "      let mos_a, mos_b = Determinant.to_lists ki in\n",
    "      [ List.map (fun hole -> \n",
    "          List.map (fun particle ->\n",
    "                  Determinant.single_excitation Spin.Alfa hole particle ki\n",
    "              ) mos_cabs\n",
    "          ) mos_a\n",
    "      ;\n",
    "        List.map (fun hole -> \n",
    "          List.map (fun particle ->\n",
    "                  Determinant.single_excitation Spin.Beta hole particle ki\n",
    "              ) mos_cabs\n",
    "          ) mos_b \n",
    "      ]\n",
    "      |> List.concat\n",
    "      |> List.concat\n",
    "      |> List.map (fun x -> Determinant.set_phase Phase.Pos x)\n",
    "  in\n",
    "  \n",
    "  (* Generate double excitations *)\n",
    "  let all_doubles ki =\n",
    "      let mos_a, mos_b = Determinant.to_lists ki in\n",
    "      [ List.map (fun hole ->  (* Alpha-Alpha *)\n",
    "          List.map (fun particle ->\n",
    "            List.map (fun hole' -> \n",
    "              List.map (fun particle' ->\n",
    "                if hole' > hole && particle' < particle then\n",
    "                  Some (Determinant.double_excitation Spin.Alfa hole particle Spin.Alfa hole' particle' ki)\n",
    "                else None\n",
    "                      ) mos_cabs\n",
    "                  ) mos_a \n",
    "              ) mos_cabs\n",
    "          ) mos_a\n",
    "        ; \n",
    "        List.map (fun hole ->  (* Beta-Beta *)\n",
    "          List.map (fun particle ->\n",
    "            List.map (fun hole' -> \n",
    "              List.map (fun particle' ->\n",
    "                if hole' > hole && particle' < particle then\n",
    "                  Some (Determinant.double_excitation Spin.Beta hole particle Spin.Beta hole' particle' ki)\n",
    "                else None\n",
    "                      ) mos_cabs\n",
    "                  ) mos_b \n",
    "              ) mos_cabs\n",
    "          ) mos_b\n",
    "        ;\n",
    "        List.map (fun hole ->  (* Alpha-Beta *)\n",
    "          List.map (fun particle ->\n",
    "            List.map (fun hole' -> \n",
    "              List.map (fun particle' ->\n",
    "                  Some (Determinant.double_excitation Spin.Alfa hole particle Spin.Beta hole' particle' ki)\n",
    "                      ) mos_cabs\n",
    "                  ) mos_a \n",
    "              ) mos_cabs\n",
    "          ) mos_a\n",
    "      ]\n",
    "      |> List.concat\n",
    "      |> List.concat\n",
    "      |> List.concat\n",
    "      |> List.concat\n",
    "      |> Util.list_some\n",
    "      |> List.map (fun x -> Determinant.set_phase Phase.Pos x)\n",
    "  in\n",
    "\n",
    "  (* Generate left and right excitations *)\n",
    "  let al = \n",
    "      match l with\n",
    "      | 1 -> all_singles ki\n",
    "      | 2 -> all_doubles ki\n",
    "      | _ -> assert false\n",
    "  in\n",
    "  let ar = \n",
    "      match r with\n",
    "      | 1 -> all_singles kj\n",
    "      | 2 -> all_doubles kj\n",
    "      | _ -> assert false\n",
    "  in\n",
    "  \n",
    "  let mo_class = DeterminantSpace.mo_class in_space in\n",
    "  let m l =\n",
    "    List.fold_left (fun accu i ->\n",
    "        let j = i-1 in Bitstring.logor accu (Bitstring.shift_left_one mo_num j)\n",
    "      ) (Bitstring.zero mo_num) l\n",
    "  in\n",
    "  let aux_mask = m (MOClass.auxiliary_mos mo_class) in\n",
    "  let good_cabs k = \n",
    "      let alfa =\n",
    "        Determinant.alfa k\n",
    "        |> Spindeterminant.bitstring\n",
    "      in\n",
    "      let beta =\n",
    "        Determinant.beta k\n",
    "        |> Spindeterminant.bitstring\n",
    "      in\n",
    "      let a = Bitstring.logand aux_mask alfa\n",
    "      and b = Bitstring.logand aux_mask beta\n",
    "      in\n",
    "      Bitstring.popcount a + Bitstring.popcount b = cabs\n",
    "  in\n",
    "  let good_lr k =\n",
    "    Determinant.degree ki k = l &&\n",
    "    Determinant.degree k kj = r \n",
    "  in\n",
    "\n",
    "\n",
    "  \n",
    "  (* Merge lists in a set of unique determinants *)\n",
    "  List.concat [ al; ar ]\n",
    "  |> List.sort_uniq compare\n",
    "  \n",
    "  (* Filter out all determinants with incorrect numbers of electrons in the CABS *)\n",
    "  |> List.filter good_cabs\n",
    "  \n",
    "  (* Filter out all determinants with incorrect excitation numbers *)\n",
    "  |> List.filter good_lr\n",
    "  \n",
    "  \n",
    "let compute_HaaF ki alphas kj =\n",
    "  List.fold_left (fun accu alpha -> accu\n",
    "      +. h_ij aux_basis ki alpha\n",
    "      *. f_ij aux_basis alpha kj\n",
    "    ) 0. alphas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let ki = det_I.(0) \n",
    "let kj = det_I.(0)\n",
    "let alphas =\n",
    "    generate_alphas ki kj 0 1 1 1\n",
    "\n",
    "let _ =\n",
    "    compute_HaaF ki alphas kj\n",
    "\n",
    "    \n",
    "(*\n",
    "|> SetDet.iter (fun x -> Format.printf \"@[%a@]@;\" (Determinant.pp 24) x)\n",
    "*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "String.concat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0 1 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "png_image \"0_1_11.png\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "OCaml 4.07.1",
   "language": "OCaml",
   "name": "ocaml-jupyter"
  },
  "language_info": {
   "codemirror_mode": "text/x-ocaml",
   "file_extension": ".ml",
   "mimetype": "text/x-ocaml",
   "name": "OCaml",
   "nbconverter_exporter": null,
   "pygments_lexer": "OCaml",
   "version": "4.07.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}