open Common type t = { coefs_and_shell_pairs : (float * Primitive_shell_pair.t) list; shell_a : Contracted_shell.t; shell_b : Contracted_shell.t; } module Am = Angular_momentum module Co = Coordinate module Cs = Contracted_shell module Ps = Primitive_shell module Psp = Primitive_shell_pair (** Creates an contracted shell pair : a list of pairs of primitive shells. A contracted shell with N functions combined with a contracted shell with M functions generates a NxM array of shell pairs. *) let make ?(cutoff=Constants.epsilon) s_a s_b = let make = Psp.create_make_of (Cs.primitives s_a).(0) (Cs.primitives s_b).(0) in let coefs_and_shell_pairs = Array.mapi (fun i p_a -> let c_a = (Cs.coefficients s_a).(i) in let make = make p_a in Array.mapi (fun j p_b -> let c_b = (Cs.coefficients s_b).(j) in let coef = c_a *. c_b in assert (coef <> 0.); let cutoff = cutoff /. abs_float coef in coef, make p_b cutoff) (Cs.primitives s_b)) (Cs.primitives s_a) |> Array.to_list |> Array.concat |> Array.to_list |> List.filter (function (_, Some _) -> true | _ -> false) |> List.map (function (c, Some x) -> (c *. Psp.normalization x, x) | _ -> assert false) in match coefs_and_shell_pairs with | [] -> None | coefs_and_shell_pairs -> Some { shell_a = s_a ; shell_b = s_b ; coefs_and_shell_pairs } let shell_a x = x.shell_a let shell_b x = x.shell_b let coefs_and_shell_pairs x = x.coefs_and_shell_pairs let shell_pairs x = List.map snd x.coefs_and_shell_pairs |> Array.of_list let coefficients x = List.map fst x.coefs_and_shell_pairs |> Array.of_list let exponents_inv x = List.map (fun (_,sp) -> Psp.exponent_inv sp) x.coefs_and_shell_pairs |> Array.of_list let a_minus_b x = match x.coefs_and_shell_pairs with | [] -> assert false | (_,sp)::_ -> Psp.a_minus_b sp let a_minus_b_sq x = match x.coefs_and_shell_pairs with | [] -> assert false | (_,sp)::_ -> Psp.a_minus_b_sq sp let ang_mom x = match x.coefs_and_shell_pairs with | [] -> assert false | (_,sp)::_ -> Psp.ang_mom sp let norm_scales x = match x.coefs_and_shell_pairs with | [] -> assert false | (_,sp)::_ -> Psp.norm_scales sp let monocentric x = match x.coefs_and_shell_pairs with | [] -> assert false | (_,sp)::_ -> Psp.monocentric sp (** Returns an integer characteristic of a contracted shell pair *) let hash a = List.rev_map Hashtbl.hash a |> Array.of_list (** Comparison function, used for sorting *) let compare t t' = let a = hash t.coefs_and_shell_pairs in let b = hash t'.coefs_and_shell_pairs in if a = b then 0 else if (Array.length a < Array.length b) then -1 else if (Array.length a > Array.length b) then 1 else let out = ref 0 in begin try for k=0 to (Array.length a - 1) do if a.(k) < b.(k) then (out := (-1); raise Not_found) else if a.(k) > b.(k) then (out := 1; raise Not_found); done with Not_found -> (); end; !out (** The array of all shell pairs with their correspondance in the list of contracted shells. *) let of_contracted_shell_array ?(cutoff=Constants.epsilon) basis = let rec loop accu = function | [] -> accu | (s_a :: rest) as l -> let new_accu = (List.map (fun s_b -> make ~cutoff s_a s_b) l) :: accu in (loop [@tailcall]) new_accu rest in loop [] (List.rev (Array.to_list basis)) |> List.concat |> Util.list_some (* let equivalent x y = (Array.length x = Array.length y) && let rec eqv = function | 0 -> true | k -> if Psp.equivalent x.(k) y.(k) then (eqv [@tailcall]) (k-1) else false in eqv (Array.length x - 1) (** A list of unique shell pairs *) let unique sp = let sp = Array.to_list sp |> Array.concat |> Array.to_list in let rec aux accu = function | [] -> accu | x::rest -> let newaccu = try ignore @@ List.find (fun y -> equivalent x y) accu; accu with Not_found -> (x::accu) in (aux [@tailcall]) newaccu rest in aux [] sp *) let zkey_array x = Am.zkey_array (Am.Doublet Cs.(ang_mom x.shell_a, ang_mom x.shell_b) )