2020-01-06 19:43:55 +01:00
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Test of F12 matrix elements"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Initialization"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let png_image = print_endline ;;\n",
"\n",
"(* --------- *)\n",
"\n",
"#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"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"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\";;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Printers"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"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",
"(*\n",
"#install_printer DeterminantSpace.pp;;\n",
"*)\n",
"#install_printer SpindeterminantSpace.pp;;\n",
"#install_printer Bitstring.pp;;\n",
"\n",
"(* --------- *)\n",
"\n",
"open Lacaml.D\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Run"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Simulation\n"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
2020-01-06 19:43:55 +01:00
"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 \"c\" \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": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let n_elec_alfa, n_elec_beta, n_elec = \n",
" let e = Simulation.electrons simulation in\n",
" Electrons.(n_alfa e, n_beta e, n_elec e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Hartree-Fock"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let hf = HartreeFock.make ~guess:`Hcore ~max_scf:1 simulation ;;\n",
"\n",
"let mo_basis = MOBasis.of_hartree_fock hf"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# FCI-F12"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Common functions"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"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",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"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": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let () = ignore @@ MOBasis.f12_ints aux_basis\n",
"let () = ignore @@ MOBasis.two_e_ints aux_basis"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Integral-based functions"
]
},
{
"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",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let cancel_singles = false \n",
"\n",
"let mos_cabs = \n",
" Util.list_range (mo_num+1) aux_num\n",
" \n",
"let mos_abs = \n",
" Util.list_range 1 aux_num\n",
" \n",
"let mos_in = \n",
" Util.list_range 1 mo_num\n",
"\n",
"let mos_a k =\n",
" Determinant.alfa k\n",
" |> Spindeterminant.to_list\n",
" \n",
"let mos_b k =\n",
" Determinant.beta k\n",
" |> Spindeterminant.to_list\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### H integrals"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let h_one =\n",
" let h = \n",
" MOBasis.one_e_ints aux_basis\n",
" in fun i j _ -> h.{i,j}\n",
" \n",
"let h_two = \n",
" let two_e_ints = MOBasis.two_e_ints aux_basis in\n",
" let h2 i j k l (s:Spin.t) (s':Spin.t) =\n",
" if s' <> s then\n",
" ERI.get_phys two_e_ints i j k l\n",
" else\n",
" (ERI.get_phys two_e_ints i j k l) -. \n",
" (ERI.get_phys two_e_ints i j l k)\n",
" in\n",
" h2\n",
"\n",
" \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### F12 integrals"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let f_two = \n",
" let two_e_ints = MOBasis.f12_ints aux_basis in\n",
" let f2 i j k l (s:Spin.t) (s':Spin.t) =\n",
" if s' <> s then\n",
" 0.5 *. F12.get_phys two_e_ints i j k l\n",
" else\n",
" 0.5 *. (\n",
" (F12.get_phys two_e_ints i j k l) -. \n",
" (F12.get_phys two_e_ints i j l k) )\n",
" in\n",
" let f3 i j k l (s:Spin.t) (s':Spin.t) = \n",
" if (i=k && j<>l) || (j=l && i<>k) then\n",
" 0.\n",
" else\n",
" f2 i j k l s s'\n",
" in\n",
" if cancel_singles then f3 else f2\n",
"\n",
"let f_one = fun _ _ _ -> 0.\n",
"\n",
"(*\n",
"let f_two = h_two\n",
"\n",
"let f_one = h_one\n",
2020-01-07 16:45:14 +01:00
"*)\n"
2020-01-06 19:43:55 +01:00
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Determinant-based functions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Integrals"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let f12_integrals mo_basis =\n",
" ( f_one, f_two, None )\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",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"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",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"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",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {
"scrolled": false
},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let ci = CI.make ~n_states:state in_space\n",
"\n",
"let ci_coef, ci_energy = Lazy.force ci.eigensystem \n",
"\n",
"let _ = print_newline () \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": [
"## Matrices $\\langle I | H | \\alpha \\rangle$ and $\\langle I | F | \\alpha \\rangle$ "
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {
"scrolled": true
},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let randomize = false\n",
"\n",
"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 =\n",
" if randomize then\n",
" let n = 123456789 in\n",
" in_list\n",
" |> List.map (fun k -> (Random.int n, k))\n",
" |> List.sort compare\n",
" |> List.map (fun (_,k) -> k)\n",
" |> Array.of_list\n",
" else\n",
" Array.of_list in_list\n"
]
},
{
"cell_type": "raw",
"metadata": {
"raw_mimetype": "text/markdown"
},
"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"
]
},
{
"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",
2020-01-07 16:45:14 +01:00
"* `exc` is the degree of excitation between $|I\\rangle$ and $|J\\rangle$"
2020-01-06 19:43:55 +01:00
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let generate_alphas ki kj exc =\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",
" if hole = particle then None else\n",
" Some (Determinant.single_excitation Spin.Alfa hole particle ki)\n",
" ) mos_abs\n",
" ) mos_a\n",
" ;\n",
" List.map (fun hole -> \n",
" List.map (fun particle ->\n",
" if hole = particle then None else\n",
" Some (Determinant.single_excitation Spin.Beta hole particle ki)\n",
" ) mos_abs\n",
" ) mos_b \n",
" ]\n",
" |> List.concat\n",
" |> List.concat\n",
" |> Util.list_some\n",
" |> List.filter (fun x -> Determinant.is_none x = false)\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 = particle || hole' = particle' then None else\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_abs\n",
" ) mos_a \n",
" ) mos_abs\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 && hole <> particle && hole' <> particle' then\n",
" Some (Determinant.double_excitation Spin.Beta hole particle Spin.Beta hole' particle' ki)\n",
" else None\n",
" ) mos_abs\n",
" ) mos_b \n",
" ) mos_abs\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",
" if hole = particle || hole' = particle' then None else\n",
" Some (Determinant.double_excitation Spin.Alfa hole particle Spin.Beta hole' particle' ki)\n",
" ) mos_abs\n",
" ) mos_b \n",
" ) mos_abs\n",
" ) mos_a\n",
" ]\n",
" |> List.concat\n",
" |> List.concat\n",
" |> List.concat\n",
" |> List.concat\n",
" |> Util.list_some\n",
" |> List.filter (fun x -> Determinant.is_none x = false)\n",
" |> List.map (fun x -> Determinant.set_phase Phase.Pos x)\n",
" in\n",
"\n",
" (* Generate left and right excitations *)\n",
" let al = List.concat [ all_singles ki ; all_doubles ki ] in\n",
" let ar = List.concat [ all_singles kj ; all_doubles kj ] 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",
" match Bitstring.popcount a + Bitstring.popcount b with\n",
" | 1 | 2 -> true\n",
" | _ -> false\n",
" in\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",
" \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",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let check n integral_value exc =\n",
" let cpudet, cpuint = ref 0., ref 0. in\n",
" let det_list =\n",
" match n with\n",
" | 0 -> det_I\n",
" | n -> Array.sub det_I 0 n\n",
" in\n",
" let result =\n",
" Printf.printf \"Checking ... \\n%!\";\n",
" let percent = ref 0 in\n",
" let task (i,ki) =\n",
" (let p = (10 * (i+1))/(Array.length det_list) in\n",
" if p <> !percent then\n",
" ( percent := p ; Printf.printf \" - %3d %%\\n%!\" (p*10) ));\n",
" Array.mapi (fun j kj -> \n",
" if i > j || Determinant.degree ki kj <> exc then\n",
" (0,0,0.,0.)\n",
" else\n",
" begin\n",
" let alphas = generate_alphas ki kj exc in\n",
" let det_value =\n",
" let t0 = Unix.gettimeofday () in\n",
" let result = compute_HaaF ki alphas kj in\n",
" cpudet := !cpudet +. Unix.gettimeofday () -. t0;\n",
" result\n",
" in\n",
" let int_value = \n",
" let t0 = Unix.gettimeofday () in\n",
" let result = integral_value ki kj in\n",
" cpuint := !cpuint +. Unix.gettimeofday () -. t0;\n",
" result\n",
" in\n",
"(* Printf.printf \"%d %d %e %e\\n%!\" i j det_value int_value; *)\n",
" (i,j,det_value,int_value)\n",
" end\n",
" ) det_list\n",
" in\n",
" det_list\n",
" |> Array.mapi (fun i ki -> (i,ki))\n",
" |> Array.to_list\n",
" |> Stream.of_list\n",
" |> Farm.run ~f:task\n",
" |> Util.stream_to_list\n",
" |> Array.concat\n",
" in\n",
" let i,j,d,v = \n",
" let rec aux k imax jmax emax dmax vmax = \n",
" if k = -1 then\n",
" imax, jmax, dmax, vmax\n",
" else\n",
" let i, j, d, v = result.(k) in\n",
" let e = abs_float (d -. v) in\n",
" if e >= emax then\n",
" aux (k-1) i j e d v\n",
" else\n",
" aux (k-1) imax jmax emax dmax vmax\n",
" in\n",
" aux (Array.length result - 1) 0 0 0. 0. 0.\n",
" in\n",
" let error = abs_float (d -. v) in\n",
" if error < epsilon_float then\n",
" (*\n",
" Printf.printf \"OK: %e\\n%!\" error\n",
" *)\n",
" Printf.printf \"OK: (%d, %d) | %e %e | %e | cpu : %f %f\\n%!\" i j d v error !cpudet !cpuint\n",
" else\n",
" Printf.printf \"Failed: (%d, %d) | %e %e | %e | cpu : %f %f\\n%!\" i j d v error !cpudet !cpuint\n",
"\n",
" \n",
"let sum l f = List.fold_left (fun accu i -> accu +. f i) 0. l"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let array_3_init d1 d2 d3 f =\n",
" let result = \n",
" Bigarray.(Array3.create Float64 fortran_layout) d1 d2 d3\n",
" in\n",
" for k=1 to d3 do\n",
" for j=1 to d2 do\n",
" for i=1 to d1 do\n",
" result.{i,j,k} <- f i j k\n",
" done\n",
" done\n",
" done;\n",
" result\n",
"\n",
"\n",
"let array_4_init d1 d2 d3 d4 f =\n",
" let result = \n",
" Bigarray.(Genarray.create Float64 fortran_layout) [| d1;d2;d3;d4 |]\n",
" in\n",
" for l=1 to d4 do\n",
" for k=1 to d3 do\n",
" for j=1 to d2 do\n",
" for i=1 to d1 do\n",
" result.{i,j,k,l} <- f i j k l\n",
" done\n",
" done\n",
" done\n",
" done;\n",
" result\n",
"\n",
"\n",
"let array_5_init d1 d2 d3 d4 d5 f =\n",
" let result = \n",
" Bigarray.(Genarray.create Float64 fortran_layout) [| d1;d2;d3;d4;d5 |]\n",
" in\n",
" for m=1 to d5 do\n",
" for l=1 to d4 do\n",
" for k=1 to d3 do\n",
" for j=1 to d2 do\n",
" for i=1 to d1 do\n",
" result.{i,j,k,l,m} <- f i j k l m\n",
" done\n",
" done\n",
" done\n",
" done\n",
" done;\n",
" result\n",
"\n",
"(* ----- *)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"******"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 1. 0 "
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let m_0111_1H_1F = \n",
" Vec.init mo_num (fun i -> \n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_one a i Spin.Alfa ))\n",
"\n",
2020-01-07 16:45:14 +01:00
"let m_0111_1H_2Fa, m_0111_2Ha_2Fa =\n",
2020-01-06 19:43:55 +01:00
"\n",
2020-01-07 16:45:14 +01:00
" let m_0122_Haa = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a k Spin.Alfa Spin.Alfa *. f_two a k i j Spin.Alfa Spin.Alfa\n",
" ) )\n",
" in \n",
2020-01-06 19:43:55 +01:00
" \n",
2020-01-07 16:45:14 +01:00
" let m_0111_1H_2Fa = \n",
" Mat.init_cols mo_num mo_num (fun i j ->\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j i j Spin.Alfa Spin.Alfa +.\n",
" h_two i j a j Spin.Alfa Spin.Alfa *. f_one a i Spin.Alfa\n",
" ) +.\n",
" if i < j then 0. else\n",
" begin\n",
" sum mos_cabs (fun a ->\n",
" sum mos_cabs (fun b -> if b >= a then 0. else\n",
" h_two i j a b Spin.Alfa Spin.Alfa *. f_two a b i j Spin.Alfa Spin.Alfa\n",
" )\n",
" ) +.\n",
" sum mos_in (fun k -> m_0122_Haa.{i,j,k}) \n",
" end\n",
2020-01-06 19:43:55 +01:00
" )\n",
2020-01-07 16:45:14 +01:00
" in\n",
" \n",
" let m_0111_2Ha_2Fa =\n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
" f_two a k i k Spin.Alfa Spin.Alfa \n",
" ) -. if i < j then 0. else m_0122_Haa.{i,j,k}\n",
" )\n",
" in m_0111_1H_2Fa, m_0111_2Ha_2Fa\n",
2020-01-06 19:43:55 +01:00
"\n",
"\n",
2020-01-07 16:45:14 +01:00
" \n",
"let m_0111_1H_2Fb, m_0111_2Hb_2Fb =\n",
" let m_0122_Hab = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a k Spin.Alfa Spin.Beta *. f_two a k i j Spin.Alfa Spin.Beta\n",
" ) )\n",
" in\n",
" \n",
" let m_0111_1H_2Fb = \n",
" Mat.init_cols mo_num mo_num (fun i j ->\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j i j Spin.Alfa Spin.Beta +. \n",
" h_two i j a j Spin.Alfa Spin.Beta *. f_one a i Spin.Alfa +.\n",
" h_one j a Spin.Alfa *. f_two a i j i Spin.Alfa Spin.Beta +. \n",
" h_two j i a i Spin.Alfa Spin.Beta *. f_one a j Spin.Alfa\n",
" ) +.\n",
" sum mos_in (fun k -> m_0122_Hab.{i,j,k} +. m_0122_Hab.{j,i,k} ) +.\n",
" sum mos_cabs (fun a ->\n",
" sum mos_cabs (fun b ->\n",
" h_two i j a b Spin.Alfa Spin.Beta *. f_two a b i j Spin.Alfa Spin.Beta\n",
" )\n",
" )\n",
" )\n",
" in \n",
" \n",
" let m_0111_2Hb_2Fb =\n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two k i a i Spin.Alfa Spin.Beta *.\n",
" f_two a j k j Spin.Alfa Spin.Beta +.\n",
" h_two i k a k Spin.Alfa Spin.Beta *.\n",
" f_two a j i j Spin.Alfa Spin.Alfa \n",
" ) -. m_0122_Hab.{k,i,j}\n",
" )\n",
" in\n",
" m_0111_1H_2Fb, m_0111_2Hb_2Fb\n",
" \n",
2020-01-06 19:43:55 +01:00
"\n",
"let m_0111_2Ha_2Fb =\n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
" f_two a k i k Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
"\n",
"\n",
"\n",
"\n",
"let integral_value ki kj = \n",
"\n",
" let mos_i, mos_i' = mos_a ki, mos_b ki in\n",
" let same = (mos_i = mos_i') in\n",
" \n",
" (* Alpha *)\n",
" let a = \n",
" sum mos_i (fun i -> m_0111_1H_1F.{i}) \n",
" in\n",
" \n",
" let b = \n",
" if same then a else\n",
" sum mos_i' (fun i -> m_0111_1H_1F.{i})\n",
" in\n",
" \n",
" let aa = \n",
" sum mos_i (fun j ->\n",
" sum mos_i (fun i -> m_0111_1H_2Fa.{i,j} ))\n",
" in\n",
" \n",
" let bb = \n",
" if same then aa else\n",
" sum mos_i' (fun j ->\n",
" sum mos_i' (fun i -> m_0111_1H_2Fa.{i,j} ))\n",
" in\n",
" \n",
" let ab = \n",
" sum mos_i' (fun j ->\n",
" sum mos_i (fun i -> m_0111_1H_2Fb.{i,j} )) \n",
" in\n",
" \n",
" let aaa = \n",
" sum mos_i (fun k ->\n",
" sum mos_i (fun j ->\n",
" sum mos_i (fun i -> m_0111_2Ha_2Fa.{i,j,k} ))) \n",
" in\n",
" \n",
" let bbb = \n",
" if same then aaa else\n",
" sum mos_i' (fun k ->\n",
" sum mos_i' (fun j ->\n",
" sum mos_i' (fun i -> m_0111_2Ha_2Fa.{i,j,k} )))\n",
" in\n",
" \n",
" let baa = \n",
" sum mos_i' (fun k ->\n",
" sum mos_i (fun j ->\n",
" sum mos_i (fun i ->\n",
" m_0111_2Ha_2Fb.{i,j,k} +. m_0111_2Hb_2Fb.{i,j,k}\n",
" )))\n",
" in\n",
" \n",
" let bba = \n",
" sum mos_i (fun k ->\n",
" sum mos_i' (fun j ->\n",
" sum mos_i' (fun i ->\n",
" m_0111_2Ha_2Fb.{i,j,k} +. m_0111_2Hb_2Fb.{j,i,k} \n",
" ))) \n",
" in\n",
"\n",
" a +. b +. aa +. bb +. ab +. aaa +. baa +. bba +. bbb\n",
" \n",
" \n",
"let _ =\n",
2020-01-07 16:45:14 +01:00
" check 0 integral_value 0 \n",
2020-01-06 19:43:55 +01:00
" \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2. 1"
]
},
{
"cell_type": "code",
2020-01-07 16:45:14 +01:00
"execution_count": null,
2020-01-06 19:43:55 +01:00
"metadata": {
"scrolled": false
},
2020-01-07 16:45:14 +01:00
"outputs": [],
2020-01-06 19:43:55 +01:00
"source": [
"let m_1111_1H_1F = \n",
" Mat.init_cols mo_num mo_num (fun i k -> \n",
" sum mos_cabs (fun a -> h_one i a Spin.Alfa *. f_one a k Spin.Alfa ))\n",
"\n",
"\n",
" \n",
"\n",
"let m_1111_2Ha_2Fa =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
" if l=i then\n",
" sum mos_cabs (fun a ->\n",
" h_two j l a l Spin.Alfa Spin.Alfa *.\n",
" f_two a i j k Spin.Alfa Spin.Alfa \n",
" )\n",
" else\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
" f_two a l k l Spin.Alfa Spin.Alfa +.\n",
" h_two j l a l Spin.Alfa Spin.Alfa *.\n",
" f_two a i j k Spin.Alfa Spin.Alfa )\n",
2020-01-06 19:43:55 +01:00
" )\n",
"\n",
"\n",
2020-01-07 16:45:14 +01:00
"\n",
2020-01-06 19:43:55 +01:00
"let m_1111_2Hb_2Fa =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
" if l=i then\n",
" sum mos_cabs (fun a ->\n",
" h_two j l a l Spin.Alfa Spin.Beta *.\n",
" f_two a i j k Spin.Alfa Spin.Beta \n",
" )\n",
" else\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Beta *.\n",
" f_two a l k l Spin.Alfa Spin.Alfa +.\n",
" h_two j l a l Spin.Alfa Spin.Beta *.\n",
" f_two a i j k Spin.Alfa Spin.Beta \n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
"\n",
"\n",
"let m_1111_2Ha_2Fb =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
2020-01-07 16:45:14 +01:00
" f_two a l k l Spin.Alfa Spin.Beta +.\n",
" h_two j l a l Spin.Alfa Spin.Beta *.\n",
2020-01-06 19:43:55 +01:00
" f_two a i j k Spin.Alfa Spin.Alfa \n",
" )\n",
" )\n",
"\n",
"\n",
"\n",
2020-01-07 16:45:14 +01:00
"let m_1111_2Hb_2Fb =\n",
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 16:45:14 +01:00
" h_two i j a j Spin.Alfa Spin.Beta *.\n",
" f_two a l k l Spin.Alfa Spin.Beta +.\n",
" h_two j l a l Spin.Alfa Spin.Alfa *.\n",
2020-01-06 19:43:55 +01:00
" f_two a i j k Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
"\n",
"\n",
"\n",
"\n",
" \n",
"\n",
"\n",
"let m_1121_2Ha_2Fa =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
" h_two i j k a Spin.Alfa Spin.Alfa *.\n",
2020-01-07 16:45:14 +01:00
" f_two l a l j Spin.Alfa Spin.Alfa \n",
2020-01-06 19:43:55 +01:00
" )\n",
" )\n",
"\n",
"\n",
"let m_1121_2Hb_2Fa =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
" h_two i j k a Spin.Alfa Spin.Beta *.\n",
2020-01-07 16:45:14 +01:00
" f_two l a l j Spin.Alfa Spin.Alfa \n",
2020-01-06 19:43:55 +01:00
" )\n",
" )\n",
"\n",
"let m_1121_2Ha_2Fb =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
" h_two i j k a Spin.Alfa Spin.Alfa *.\n",
2020-01-07 16:45:14 +01:00
" f_two l a l j Spin.Alfa Spin.Beta \n",
2020-01-06 19:43:55 +01:00
" )\n",
" )\n",
"\n",
"\n",
"let m_1121_2Hb_2Fb =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
" h_two i j k a Spin.Alfa Spin.Beta *.\n",
2020-01-07 16:45:14 +01:00
" f_two l a l j Spin.Alfa Spin.Beta \n",
2020-01-06 19:43:55 +01:00
" )\n",
" )\n",
"\n",
"let m_1122_va =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 16:45:14 +01:00
" h_two j i a l Spin.Alfa Spin.Alfa *.\n",
" f_two l a k j Spin.Alfa Spin.Alfa \n",
2020-01-06 19:43:55 +01:00
" )\n",
" )\n",
2020-01-07 16:45:14 +01:00
" \n",
"let m_1111_1H_2Fa = \n",
" array_3_init mo_num mo_num mo_num (fun j i k ->\n",
" sum mos_in (fun l -> m_1122_va.{l,j,i,k}) +.\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j k j Spin.Alfa Spin.Alfa +.\n",
" h_two i j a j Spin.Alfa Spin.Alfa *. f_one a k Spin.Alfa +.\n",
" h_one j a Spin.Alfa *. f_two a i j k Spin.Alfa Spin.Alfa +.\n",
" h_two i j k a Spin.Alfa Spin.Alfa *. f_one a j Spin.Alfa +.\n",
" sum mos_cabs (fun b -> if b > a then 0. else\n",
" h_two i j a b Spin.Alfa Spin.Alfa *.\n",
" f_two a b k j Spin.Alfa Spin.Alfa )\n",
" )\n",
" )\n",
"\n",
2020-01-06 19:43:55 +01:00
"\n",
"let m_1122_v2 =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 16:45:14 +01:00
" h_two i j l a Spin.Alfa Spin.Beta *.\n",
" f_two l a k j Spin.Alfa Spin.Beta \n",
2020-01-06 19:43:55 +01:00
" )\n",
" )\n",
"\n",
2020-01-07 16:45:14 +01:00
"\n",
2020-01-06 19:43:55 +01:00
"let m_1122_v3 =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 16:45:14 +01:00
" h_two i j a l Spin.Alfa Spin.Beta *.\n",
" f_two a l k j Spin.Alfa Spin.Beta \n",
2020-01-06 19:43:55 +01:00
" )\n",
" )\n",
"\n",
2020-01-07 16:45:14 +01:00
" \n",
"let m_1111_1H_2Fb = \n",
" array_3_init mo_num mo_num mo_num (fun j i k ->\n",
" sum mos_in (fun l -> m_1122_v2.{l,j,i,k} +. m_1122_v3.{l,j,i,k}) +.\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j k j Spin.Alfa Spin.Beta +.\n",
" h_two i j a j Spin.Alfa Spin.Beta *. f_one a k Spin.Alfa +.\n",
" h_one j a Spin.Beta *. f_two a i j k Spin.Alfa Spin.Beta +.\n",
" h_two i j k a Spin.Alfa Spin.Beta *. f_one a j Spin.Beta +.\n",
" sum mos_cabs (fun b ->\n",
" h_two i j a b Spin.Alfa Spin.Beta *.\n",
" f_two a b k j Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
" )\n",
" \n",
2020-01-06 19:43:55 +01:00
"let m_1122_oa =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
" if l > j then\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
" h_two j l a k Spin.Alfa Spin.Alfa *.\n",
" f_two i a l j Spin.Alfa Spin.Alfa \n",
" )\n",
2020-01-07 16:45:14 +01:00
" else 0.\n",
2020-01-06 19:43:55 +01:00
" )\n",
"\n",
"let m_1122_o =\n",
2020-01-07 16:45:14 +01:00
" array_4_init mo_num mo_num mo_num mo_num (fun l j i k ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
" h_two l j k a Spin.Alfa Spin.Beta *.\n",
" f_two i a l j Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
" \n",
2020-01-07 16:45:14 +01:00
"\n",
"\n",
2020-01-06 19:43:55 +01:00
"(*----*)\n",
"\n",
"let integral_value ki kj = \n",
" let i, k, s, phase =\n",
" match Excitation.of_det ki kj with\n",
" | Excitation.(Single (phase, { hole ; particle ; spin })) ->\n",
" hole, particle, spin, phase\n",
" | _ -> assert false\n",
" in\n",
" \n",
2020-01-07 16:45:14 +01:00
" let mos_novirt, mos_novirt' =\n",
" let alfa = \n",
" let i = Spindeterminant.bitstring @@ Determinant.alfa ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.alfa kj in\n",
" Bitstring.to_list (Bitstring.logor i j)\n",
" in\n",
" let beta = \n",
" let i = Spindeterminant.bitstring @@ Determinant.beta ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.beta kj in\n",
" Bitstring.to_list (Bitstring.logor i j)\n",
" in\n",
" match s with\n",
" | Spin.Alfa -> alfa, beta\n",
" | Spin.Beta -> beta, alfa\n",
2020-01-06 19:43:55 +01:00
" in\n",
" \n",
" let mos_ij, mos_ij' =\n",
" let alfa = \n",
" let i = Spindeterminant.bitstring @@ Determinant.alfa ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.alfa kj in\n",
" Bitstring.to_list (Bitstring.logand i j)\n",
" in\n",
" let beta = \n",
" let i = Spindeterminant.bitstring @@ Determinant.beta ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.beta kj in\n",
" Bitstring.to_list (Bitstring.logand i j)\n",
" in\n",
" match s with\n",
" | Spin.Alfa -> alfa, beta\n",
" | Spin.Beta -> beta, alfa\n",
" in\n",
" \n",
" let mos_i, mos_i' =\n",
" match s with\n",
" | Spin.Alfa -> mos_a ki, mos_b ki\n",
" | Spin.Beta -> mos_b ki, mos_a ki\n",
" in\n",
" \n",
" let mos_j, mos_j' =\n",
" match s with\n",
" | Spin.Alfa -> mos_a kj, mos_b kj\n",
" | Spin.Beta -> mos_b kj, mos_a kj\n",
" in\n",
" \n",
" let result = \n",
" m_1111_1H_1F.{i,k} +. \n",
" sum mos_ij (fun j -> \n",
2020-01-07 16:45:14 +01:00
" m_1111_1H_2Fa.{j,i,k} \n",
" +. sum mos_i (fun l -> m_1111_2Ha_2Fa.{l,j,i,k})\n",
" +. sum mos_i' (fun l -> m_1111_2Ha_2Fb.{l,j,i,k})\n",
" +. sum mos_j (fun l -> m_1121_2Ha_2Fa.{l,j,i,k})\n",
" +. sum mos_j' (fun l -> m_1121_2Ha_2Fb.{l,j,i,k})\n",
" -. sum mos_novirt (fun l -> m_1122_va.{l,j,i,k})\n",
" -. sum mos_ij (fun l -> m_1122_oa.{l,j,i,k} )\n",
" ) +.\n",
2020-01-06 19:43:55 +01:00
" sum mos_ij' (fun j ->\n",
2020-01-07 16:45:14 +01:00
" m_1111_1H_2Fb.{j,i,k} \n",
" +. sum mos_i (fun l -> m_1111_2Hb_2Fa.{l,j,i,k})\n",
" +. sum mos_i' (fun l -> m_1111_2Hb_2Fb.{l,j,i,k})\n",
" +. sum mos_j (fun l -> m_1121_2Hb_2Fb.{l,j,i,k})\n",
" +. sum mos_j' (fun l -> m_1121_2Hb_2Fa.{l,j,i,k})\n",
" -. sum mos_novirt (fun l -> m_1122_v2.{l,j,i,k}) \n",
" -. sum mos_novirt' (fun l -> m_1122_v3.{l,j,i,k})\n",
" -. sum mos_ij (fun l -> m_1122_o.{l,j,i,k})\n",
" ) \n",
2020-01-06 19:43:55 +01:00
" in\n",
" match phase with\n",
" | Phase.Pos -> result\n",
" | Phase.Neg -> -. result\n",
" \n",
"\n",
"(*\n",
"let ki = det_I.(77)\n",
"let kj = det_I.(83)\n",
"\n",
"let _ = integral_value ki kj\n",
"let _ = \n",
" let alphas = generate_alphas ki kj 1 1\n",
" in compute_HaaF ki alphas kj\n",
"*)\n",
"\n",
2020-01-07 16:45:14 +01:00
"let _ = check 100 integral_value 1 \n",
2020-01-06 19:43:55 +01:00
"\n"
]
},
{
2020-01-07 16:45:14 +01:00
"cell_type": "raw",
2020-01-06 19:43:55 +01:00
"metadata": {},
"source": [
2020-01-07 16:45:14 +01:00
"Timing : 40.020974 0.019294"
2020-01-06 19:43:55 +01:00
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
2020-01-07 16:45:14 +01:00
"# 3. 2"
2020-01-06 19:43:55 +01:00
]
},
{
"cell_type": "code",
2020-01-07 18:47:54 +01:00
"execution_count": 129,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 18:47:54 +01:00
"outputs": [
{
"data": {
"text/plain": [
"val m_2112_1H_2Fa :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2112_1H_2Fb :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2112_2Ha_2Fa :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2112_2Hb_2Fa :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2112_2Ha_2Fb :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2121_2Ha_2Fa :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2121_2Hb_2Fa :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2121_2Ha_2Fb :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2122_2Ha_2Fa_ij :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2122_2Hb_2Fb_ij :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2122_2Hb_2Fb_ij2 :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2122_2Ha_2Fa_ij2 :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2122_2Ha_2Fa_nv :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2122_2Hb_2Fb_nv :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val m_2122_2Hb_2Fb_nv2 :\n",
" (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Genarray.t =\n",
" <abstr>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val integral_value : Determinant.t -> Determinant.t -> float = <fun>\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Checking ... \n",
" - 10 %\n",
" - 20 %\n",
" - 30 %\n",
" - 40 %\n",
" - 50 %\n",
" - 60 %\n",
" - 70 %\n",
" - 80 %\n",
" - 90 %\n",
" - 100 %\n",
"OK: (2, 45) | 2.332967e-02 2.332967e-02 | 2.428613e-17 | cpu : 109.679883 0.039116\n"
]
},
{
"data": {
"text/plain": [
"- : unit = ()\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val ki : Determinant.t =\n",
" phase:+1\n",
" a:+1 +--++-----------------------------------------------------------\n",
" b:+1 +++-------------------------------------------------------------\n",
"\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"val kj : Determinant.t =\n",
" phase:+1\n",
" a:+1 +-+-+-----------------------------------------------------------\n",
" b:+1 ++-+------------------------------------------------------------\n",
"\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"- : float = 0.000896378780435275082\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"- : float = 0.000896378780435274107\n"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
}
],
2020-01-06 19:43:55 +01:00
"source": [
"let m_2112_1H_2Fa =\n",
" array_4_init mo_num mo_num mo_num mo_num (fun i j k l ->\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j k l Spin.Alfa Spin.Alfa +.\n",
2020-01-07 18:47:54 +01:00
" h_one j a Spin.Alfa *. f_two i a k l Spin.Alfa Spin.Alfa +. \n",
" h_two i j a l Spin.Alfa Spin.Alfa *. f_one a k Spin.Alfa +.\n",
" h_two i j k a Spin.Alfa Spin.Alfa *. f_one a l Spin.Alfa +.\n",
" sum mos_in (fun m -> -. h_two i j a m Spin.Alfa Spin.Alfa *.\n",
" f_two m a k l Spin.Alfa Spin.Alfa) +.\n",
" sum mos_cabs (fun b -> if b >= a then 0. else\n",
" h_two i j a b Spin.Alfa Spin.Alfa *. f_two a b k l Spin.Alfa Spin.Alfa \n",
" )\n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
"\n",
"let m_2112_1H_2Fb =\n",
" array_4_init mo_num mo_num mo_num mo_num (fun i j k l ->\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j k l Spin.Alfa Spin.Beta +.\n",
2020-01-07 18:47:54 +01:00
" h_one j a Spin.Alfa *. f_two i a k l Spin.Alfa Spin.Beta +.\n",
" h_two i j a l Spin.Alfa Spin.Beta *. f_one a k Spin.Alfa +.\n",
" h_two i j k a Spin.Alfa Spin.Beta *. f_one a l Spin.Alfa +.\n",
" sum mos_in (fun m ->\n",
" h_two i j a m Spin.Alfa Spin.Beta *. f_two a m k l Spin.Alfa Spin.Beta +.\n",
" h_two i j m a Spin.Alfa Spin.Beta *. f_two m a k l Spin.Alfa Spin.Beta ) +.\n",
" sum mos_cabs (fun b -> \n",
" h_two i j a b Spin.Alfa Spin.Beta *. f_two a b k l Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
"\n",
"let m_2112_2Ha_2Fa =\n",
2020-01-07 18:47:54 +01:00
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i n a n Spin.Alfa Spin.Alfa *. f_two a j k l Spin.Alfa Spin.Alfa +. \n",
" h_two j n a n Spin.Alfa Spin.Alfa *. f_two a i l k Spin.Alfa Spin.Alfa \n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
" \n",
"let m_2112_2Hb_2Fa =\n",
2020-01-07 18:47:54 +01:00
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i n a n Spin.Alfa Spin.Beta *. f_two a j k l Spin.Alfa Spin.Alfa +.\n",
" h_two j n a n Spin.Alfa Spin.Beta *. f_two a i l k Spin.Alfa Spin.Alfa \n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
" \n",
"let m_2112_2Ha_2Fb =\n",
2020-01-07 18:47:54 +01:00
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i n a n Spin.Alfa Spin.Alfa *. f_two a j k l Spin.Alfa Spin.Beta +.\n",
" h_two j n a n Spin.Alfa Spin.Beta *. f_two a i l k Spin.Alfa Spin.Beta )\n",
2020-01-06 19:43:55 +01:00
" )\n",
" \n",
2020-01-07 18:47:54 +01:00
" \n",
"let m_2121_2Ha_2Fa =\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i j a l Spin.Alfa Spin.Alfa *. f_two a n k n Spin.Alfa Spin.Alfa +.\n",
" h_two j i a k Spin.Alfa Spin.Alfa *. f_two a n l n Spin.Alfa Spin.Alfa \n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
" \n",
"\n",
2020-01-07 18:47:54 +01:00
"let m_2121_2Hb_2Fa =\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i j a l Spin.Alfa Spin.Beta *. f_two a n k n Spin.Alfa Spin.Alfa +.\n",
" h_two j i a k Spin.Alfa Spin.Beta *. f_two a n l n Spin.Alfa Spin.Beta \n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
2020-01-07 18:47:54 +01:00
" \n",
"let m_2121_2Ha_2Fb =\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i j a l Spin.Alfa Spin.Alfa *. f_two a n k n Spin.Alfa Spin.Beta +.\n",
" h_two j i a k Spin.Alfa Spin.Alfa *. f_two a n l n Spin.Alfa Spin.Beta \n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
2020-01-07 18:47:54 +01:00
" \n",
2020-01-06 19:43:55 +01:00
"\n",
2020-01-07 18:47:54 +01:00
"let m_2122_2Ha_2Fa_ij =\n",
" let s = Spin.Alfa in\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i n a k s s *. f_two j a n l s s \n",
" +. h_two i n a l s s *. f_two j a k n s s \n",
" -. h_two j n a k s s *. f_two i a n l s s \n",
" -. h_two j n a l s s *. f_two i a k n s s\n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
" \n",
2020-01-07 18:47:54 +01:00
"let m_2122_2Hb_2Fb_ij =\n",
" let s, s' = Spin.(Alfa, Beta) in\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two n i a k s s *. f_two a j n l s s'\n",
" +. h_two n j a l s s' *. f_two i a k n s s \n",
" -. h_two n j k a s s' *. f_two i a n l s s'\n",
2020-01-06 19:43:55 +01:00
" )\n",
2020-01-07 18:47:54 +01:00
" )\n",
2020-01-06 19:43:55 +01:00
" \n",
2020-01-07 18:47:54 +01:00
"let m_2122_2Hb_2Fb_ij2 =\n",
" let s, s' = Spin.(Alfa, Beta) in\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" -. h_two i n a l s s' *. f_two a j k n s s' +.\n",
" (if n < j then\n",
" h_two i n k a s s' *. f_two j a l n s' s'\n",
" +. h_two n j a l s' s' *. f_two i a k n s s'\n",
" else \n",
" -. h_two i n k a s s' *. f_two j a n l s' s' \n",
" -. h_two j n a l s' s' *. f_two i a k n s s'\n",
" )\n",
2020-01-06 19:43:55 +01:00
" )\n",
2020-01-07 18:47:54 +01:00
" )\n",
2020-01-06 19:43:55 +01:00
" \n",
2020-01-07 18:47:54 +01:00
"let m_2122_2Ha_2Fa_ij2 =\n",
" let s, s' = Spin.(Alfa, Beta) in\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
2020-01-06 19:43:55 +01:00
" sum mos_cabs (fun a ->\n",
2020-01-07 18:47:54 +01:00
" h_two i n k a s s' *. f_two j a l n s s'\n",
" +. h_two j n l a s s' *. f_two i a k n s s'\n",
" -. h_two i n l a s s' *. f_two j a k n s s'\n",
" -. h_two j n k a s s' *. f_two i a l n s s'\n",
" )\n",
" ) \n",
" \n",
"let m_2122_2Ha_2Fa_nv =\n",
" let s = Spin.Alfa in\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
" sum mos_cabs (fun a -> h_two i j a n s s *. f_two n a k l s s ) ) \n",
" \n",
" \n",
" \n",
"let m_2122_2Hb_2Fb_nv =\n",
" let s, s' = Spin.(Alfa, Beta) in\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
" sum mos_cabs (fun a -> -. h_two i j a n s s' *. f_two a n k l s s' ) ) \n",
" \n",
"let m_2122_2Hb_2Fb_nv2 =\n",
" let s, s' = Spin.(Alfa, Beta) in\n",
" array_5_init mo_num mo_num mo_num mo_num mo_num (fun n i j k l ->\n",
" sum mos_cabs (fun a -> -. h_two i j n a s s' *. f_two n a k l s s' ) ) \n",
" \n",
" \n",
" \n",
2020-01-06 19:43:55 +01:00
"let integral_value ki kj = \n",
" let i, j, k, l, s, s', phase =\n",
" match Excitation.of_det ki kj with\n",
" | Excitation.(Double (phase, { hole ; particle ; spin }, {hole=hole' ; particle=particle' ; spin=spin' })) ->\n",
" hole, hole', particle, particle', spin, spin', phase\n",
" | _ -> assert false\n",
" in\n",
" let mos_i, mos_i' =\n",
" match s with\n",
" | Spin.Alfa -> mos_a ki, mos_b ki\n",
" | Spin.Beta -> mos_b ki, mos_a ki\n",
" in\n",
" \n",
" let mos_j, mos_j' =\n",
" match s with\n",
" | Spin.Alfa -> mos_a kj, mos_b kj\n",
" | Spin.Beta -> mos_b kj, mos_a kj\n",
" in\n",
" \n",
" let mos_ij, mos_ij' =\n",
" let alfa = \n",
" let i = Spindeterminant.bitstring @@ Determinant.alfa ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.alfa kj in\n",
" Bitstring.to_list (Bitstring.logand i j)\n",
" in\n",
" let beta = \n",
" let i = Spindeterminant.bitstring @@ Determinant.beta ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.beta kj in\n",
" Bitstring.to_list (Bitstring.logand i j)\n",
" in\n",
" match s with\n",
" | Spin.Alfa -> alfa, beta\n",
" | Spin.Beta -> beta, alfa\n",
" in\n",
" \n",
2020-01-07 18:47:54 +01:00
" let mos_novirt, mos_novirt' =\n",
" let alfa = \n",
" let i = Spindeterminant.bitstring @@ Determinant.alfa ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.alfa kj in\n",
" Bitstring.to_list (Bitstring.logor i j)\n",
" in\n",
" let beta = \n",
" let i = Spindeterminant.bitstring @@ Determinant.beta ki in\n",
" let j = Spindeterminant.bitstring @@ Determinant.beta kj in\n",
" Bitstring.to_list (Bitstring.logor i j)\n",
" in\n",
2020-01-06 19:43:55 +01:00
" match s with\n",
2020-01-07 18:47:54 +01:00
" | Spin.Alfa -> alfa, beta\n",
" | Spin.Beta -> beta, alfa\n",
2020-01-06 19:43:55 +01:00
" in\n",
2020-01-07 18:47:54 +01:00
" \n",
" let result = \n",
2020-01-06 19:43:55 +01:00
" if s = s' then\n",
" m_2112_1H_2Fa.{i,j,k,l} +. \n",
2020-01-07 18:47:54 +01:00
" sum mos_i (fun n -> m_2112_2Ha_2Fa.{n,i,j,k,l} ) +.\n",
" sum mos_i' (fun n -> m_2112_2Hb_2Fa.{n,i,j,k,l} ) +.\n",
" sum mos_j (fun n -> m_2121_2Ha_2Fa.{n,i,j,k,l} ) +.\n",
" sum mos_j' (fun n -> m_2121_2Ha_2Fb.{n,i,j,k,l} ) +.\n",
" sum mos_ij (fun n -> m_2122_2Ha_2Fa_ij.{n,i,j,k,l} ) +. \n",
" sum mos_ij' (fun n -> m_2122_2Ha_2Fa_ij2.{n,i,j,k,l} ) +. \n",
" sum mos_novirt (fun n -> m_2122_2Ha_2Fa_nv.{n,i,j,k,l} ) \n",
2020-01-06 19:43:55 +01:00
" else\n",
2020-01-07 18:47:54 +01:00
" m_2112_1H_2Fb.{i,j,k,l} +. \n",
" sum mos_i (fun n -> m_2112_2Ha_2Fb.{n,i,j,k,l} ) +.\n",
" sum mos_i' (fun n -> m_2112_2Ha_2Fb.{n,j,i,l,k} ) +.\n",
" sum mos_j (fun n -> m_2121_2Hb_2Fa.{n,i,j,k,l} ) +.\n",
" sum mos_j' (fun n -> m_2121_2Hb_2Fa.{n,j,i,l,k} ) +.\n",
" sum mos_novirt'(fun n -> m_2122_2Hb_2Fb_nv.{n,i,j,k,l} ) +.\n",
" sum mos_novirt (fun n -> m_2122_2Hb_2Fb_nv2.{n,i,j,k,l} )+.\n",
" sum mos_ij (fun n -> m_2122_2Hb_2Fb_ij.{n,i,j,k,l} ) +. \n",
" sum mos_ij' (fun n -> m_2122_2Hb_2Fb_ij2.{n,i,j,k,l} ) \n",
2020-01-06 19:43:55 +01:00
" in\n",
"\n",
" match phase with\n",
" | Phase.Pos -> result\n",
" | Phase.Neg -> -. result\n",
" \n",
2020-01-07 18:47:54 +01:00
"let _ = check 100 integral_value 2 \n",
2020-01-06 19:43:55 +01:00
"\n",
2020-01-07 18:47:54 +01:00
"let ki = det_I.(7)\n",
"let kj = det_I.(89)\n",
2020-01-06 19:43:55 +01:00
"\n",
"let _ = integral_value ki kj\n",
"let _ = \n",
2020-01-07 18:47:54 +01:00
" let alphas = generate_alphas ki kj 2 \n",
2020-01-06 19:43:55 +01:00
" in compute_HaaF ki alphas kj\n",
2020-01-07 18:47:54 +01:00
"\n"
2020-01-06 19:43:55 +01:00
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 4. 3"
]
},
{
"cell_type": "code",
2020-01-07 18:47:54 +01:00
"execution_count": 130,
2020-01-06 19:43:55 +01:00
"metadata": {},
2020-01-07 18:47:54 +01:00
"outputs": [
{
"data": {
"text/plain": [
"val integral_value : Determinant.t -> Determinant.t -> float = <fun>\n"
]
},
"execution_count": 130,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Checking ... \n",
" - 10 %\n",
" - 20 %\n",
" - 30 %\n",
" - 40 %\n",
" - 50 %\n",
" - 60 %\n",
" - 70 %\n",
" - 80 %\n",
" - 90 %\n",
" - 100 %\n",
"OK: (13, 52) | 6.122906e-04 6.122906e-04 | 3.252607e-19 | cpu : 77.238524 0.119682\n"
]
},
{
"data": {
"text/plain": [
"- : unit = ()\n"
]
},
"execution_count": 130,
"metadata": {},
"output_type": "execute_result"
}
],
2020-01-06 19:43:55 +01:00
"source": [
"let integral_value ki kj = \n",
" let i, j, m, k, l, n, s1, s2, s3, phase =\n",
" match Excitation.of_det ki kj with\n",
" | Excitation.(Triple (phase,\n",
" { hole=h1 ; particle=p1 ; spin=s1 },\n",
" { hole=h2 ; particle=p2 ; spin=s2 },\n",
" { hole=h3 ; particle=p3 ; spin=s3 }) ) -> h1, h2, h3, p1, p2, p3, s1, s2, s3, phase\n",
" | _ -> assert false\n",
" in\n",
"\n",
" let result = \n",
" let open Spin in \n",
" match s1, s2, s3 with\n",
" | Alfa, Alfa, Alfa\n",
" | Beta, Beta, Beta -> \n",
" sum mos_cabs (fun a -> \n",
" h_two i j a k s1 s2 *. f_two m a l n s3 s3 \n",
" +. h_two i j a n s1 s2 *. f_two m a k l s3 s2 \n",
" +. h_two i m a l s1 s3 *. f_two j a k n s2 s3 \n",
" +. h_two j m a k s2 s3 *. f_two i a l n s1 s3 \n",
" +. h_two j m a n s2 s3 *. f_two i a k l s1 s2 \n",
" -. h_two i j a l s1 s2 *. f_two m a k n s3 s3 \n",
" -. h_two i m a k s1 s3 *. f_two j a l n s2 s3 \n",
" -. h_two i m a n s1 s3 *. f_two j a k l s2 s2 \n",
" -. h_two j m a l s2 s3 *. f_two i a k n s1 s3 )\n",
" | Alfa, Alfa, Beta\n",
" | Beta, Beta, Alfa -> \n",
" sum mos_cabs (fun a -> \n",
" h_two i j a l s1 s2 *. f_two a m k n s1 s3\n",
" +. h_two i m k a s1 s3 *. f_two j a l n s2 s3\n",
" +. h_two j m a n s2 s3 *. f_two i a k l s1 s2 \n",
" +. h_two j m l a s2 s3 *. f_two i a k n s1 s3\n",
" -. h_two i j a k s1 s2 *. f_two a m l n s1 s3\n",
" -. h_two i m a n s1 s3 *. f_two j a k l s2 s2 \n",
" -. h_two i m l a s1 s3 *. f_two j a k n s2 s3\n",
" -. h_two j m k a s2 s3 *. f_two i a l n s1 s3\n",
" ) \n",
" | Alfa, Beta, Beta\n",
" | Beta, Alfa, Alfa -> \n",
" sum mos_cabs (fun a -> \n",
" h_two i j a l s1 s2 *. f_two a m k n s1 s3 \n",
" +. h_two i m a n s1 s3 *. f_two a j k l s1 s2 \n",
" +. h_two i m k a s1 s3 *. f_two j a l n s2 s3 \n",
" +. h_two j m a n s2 s3 *. f_two i a k l s1 s2 \n",
" -. h_two i j a n s1 s2 *. f_two a m k l s1 s2 \n",
" -. h_two i j k a s1 s2 *. f_two m a l n s2 s3 \n",
" -. h_two i m a l s1 s3 *. f_two a j k n s1 s3 \n",
" -. h_two j m a l s2 s3 *. f_two i a k n s1 s3 \n",
" ) \n",
" | Beta, Alfa, Beta\n",
" | Alfa, Beta, Alfa -> assert false (*TODO *)\n",
" in\n",
" match phase with\n",
" | Phase.Pos -> result\n",
" | Phase.Neg -> -. result\n",
" \n",
"\n",
2020-01-07 18:47:54 +01:00
"let _ = check 100 integral_value 3 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---------------------------"
2020-01-06 19:43:55 +01:00
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"let ki = det_I.(129)\n",
"let kj = det_I.(349)\n",
"\n",
"let alpha_to_string alpha = \n",
" \n",
" let exc0 = Array.init (aux_num+1) (fun _ -> [|\"-\";\"-\"|]) in\n",
" \n",
" let i, j, m, k, l, n, s, s', s'', phase =\n",
" match Excitation.of_det ki kj with\n",
" | Excitation.(Triple (phase,\n",
" { hole ; particle ; spin },\n",
" {hole=hole' ; particle=particle' ; spin=spin' }, \n",
" {hole=hole''; particle=particle''; spin=spin''} )) ->\n",
" hole, hole', hole'', particle, particle', particle'', spin, spin', spin'', phase\n",
" | _ -> assert false\n",
" in\n",
" let spin = function\n",
" | Spin.Alfa -> 0\n",
" | _ -> 1\n",
" in\n",
" exc0.(i).(spin s ) <- \"i\" \n",
" ; exc0.(j).(spin s' ) <- \"j\" \n",
" ; exc0.(k).(spin s ) <- \"k\" \n",
" ; exc0.(l).(spin s' ) <- \"l\" \n",
" ; exc0.(m).(spin s'') <- \"m\" \n",
" ; exc0.(n).(spin s'') <- \"n\" \n",
" ;\n",
" let s0, s0', s0'' = s, s', s'' in\n",
" \n",
" let i, j, k, l, s, s', p1 =\n",
" match Excitation.of_det ki alpha with\n",
" | Excitation.(Double (phase, { hole ; particle ; spin }, {hole=hole' ; particle=particle' ; spin=spin' })) ->\n",
" hole, hole', particle, particle', spin, spin', phase\n",
" | _ -> assert false\n",
" in\n",
" \n",
" if exc0.(i).(spin s ) = \"-\" then exc0.(i).(spin s ) <- \"p\";\n",
" if exc0.(j).(spin s') = \"-\" then exc0.(j).(spin s') <- \"p\";\n",
" if exc0.(k).(spin s ) = \"-\" then exc0.(k).(spin s ) <- if k > mo_num then \"a\" else \"q\";\n",
" if exc0.(l).(spin s') = \"-\" then exc0.(l).(spin s') <- if l > mo_num then \"a\" else \"q\";\n",
" \n",
" let string_h = \n",
" Printf.sprintf \"h_two %s %s %s %s %s %s *. \" \n",
" exc0.(i).(spin s )\n",
" exc0.(j).(spin s')\n",
" exc0.(k).(spin s )\n",
" exc0.(l).(spin s')\n",
" (if s = s0 then \"s \" else if s = s0' then \"s'\" else \"s''\")\n",
" (if s' = s0' then \"s'\" else if s = s0'' then \"s''\" else \"s\" )\n",
" in \n",
" \n",
" let i, j, k, l, s, s', p2 =\n",
" match Excitation.of_det alpha kj with\n",
" | Excitation.(Double (phase, { hole ; particle ; spin }, {hole=hole' ; particle=particle' ; spin=spin' })) ->\n",
" hole, hole', particle, particle', spin, spin', phase\n",
" | _ -> assert false\n",
" in\n",
" \n",
" let string_f = \n",
" Printf.sprintf \"f_two %s %s %s %s %s %s\" \n",
" exc0.(i).(spin s )\n",
" exc0.(j).(spin s')\n",
" exc0.(k).(spin s )\n",
" exc0.(l).(spin s')\n",
" (if s = s0 then \"s \" else if s = s0' then \"s'\" else \"s''\")\n",
" (if s' = s0' then \"s'\" else if s = s0'' then \"s''\" else \"s\" )\n",
" in\n",
" (*\n",
" Format.printf \"|I> -> |a> : %a | %s\\n@.\" Excitation.pp (Excitation.of_det ki alpha) string_h ;\n",
" Format.printf \"|a> -> |J> : %a | %s\\n@.\" Excitation.pp (Excitation.of_det alpha kj) string_f ;\n",
" *)\n",
"\n",
" \n",
" let sign = \n",
" if Phase.add p1 p2 = phase then \"+.\" else \"-.\"\n",
" in\n",
" sign ^ string_h ^ string_f\n",
" \n",
"\n",
"let alpha_debug alpha = \n",
" \n",
" let i, j, k, l, s, s', p1 =\n",
" match Excitation.of_det ki alpha with\n",
" | Excitation.(Double (phase, { hole ; particle ; spin }, {hole=hole' ; particle=particle' ; spin=spin' })) ->\n",
" hole, hole', particle, particle', spin, spin', phase\n",
" | _ -> assert false\n",
" in\n",
" Printf.printf \"%d %d %d %d \" i j k l;\n",
" \n",
" let i, j, k, l, s, s', p2 =\n",
" match Excitation.of_det alpha kj with\n",
" | Excitation.(Double (phase, { hole ; particle ; spin }, {hole=hole' ; particle=particle' ; spin=spin' })) ->\n",
" hole, hole', particle, particle', spin, spin', phase\n",
" | _ -> assert false\n",
" in\n",
" (*\n",
" Format.printf \"|I> -> |a> : %a | \\n@.\" Excitation.pp (Excitation.of_det ki alpha) ;\n",
" Format.printf \"|a> -> |J> : %a | \\n@.\" Excitation.pp (Excitation.of_det alpha kj) ;\n",
" *)\n",
" Printf.printf \"%d %d %d %d \\n%!\" i j k l\n",
"\n",
" \n",
"let strings = \n",
" Format.printf \"|I> -> |J> : %a |\\n@.\" Excitation.pp (Excitation.of_det ki kj) ;\n",
" generate_alphas ki kj 3 1 2 2\n",
" |> Array.of_list\n",
" |> Array.mapi (fun kk alpha -> alpha_to_string alpha)\n",
" |> Array.to_list\n",
" |> List.sort_uniq compare\n",
" |> Array.of_list\n",
"\n",
"let _ = Array.iteri (fun i x -> Printf.printf \"%d %s \\n%!\" i x) strings\n",
"\n",
"let _ =\n",
" let v =\n",
" let alphas =\n",
" generate_alphas ki kj 3 1 2 2\n",
" (*\n",
" |> List.filter (fun alpha ->\n",
" let x = alpha_to_string alpha in\n",
" x = strings.(6)\n",
" )\n",
" *)\n",
" in\n",
" (*\n",
" List.iter alpha_debug alphas ;\n",
" Printf.printf \"\\n%!\";\n",
" *)\n",
" compute_HaaF ki alphas kj \n",
" in\n",
" let x = (integral_value ki kj) in\n",
" Printf.printf \"%20.8e %20.8e %20.8e\\n%!\" x v (v-. x)\n"
]
}
],
"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": 4
}
