2014-08-27 16:38:13 +02:00
|
|
|
open Qputils;;
|
|
|
|
open Qptypes;;
|
|
|
|
open Core.Std;;
|
|
|
|
|
|
|
|
let spec =
|
|
|
|
let open Command.Spec in
|
|
|
|
empty
|
2015-05-02 14:50:23 +02:00
|
|
|
+> flag "o" (optional string)
|
2014-11-16 18:05:04 +01:00
|
|
|
~doc:"file Name of the created EZFIO file."
|
2014-08-27 16:38:13 +02:00
|
|
|
+> flag "b" (required string)
|
2015-01-11 15:31:26 +01:00
|
|
|
~doc:"string Name of basis set."
|
2014-08-27 16:38:13 +02:00
|
|
|
+> flag "c" (optional_with_default 0 int)
|
|
|
|
~doc:"int Total charge of the molecule. Default is 0."
|
2015-11-17 22:25:26 +01:00
|
|
|
+> flag "d" (optional_with_default 0. float)
|
|
|
|
~doc:"float Add dummy atoms. x * (covalent radii of the atoms)"
|
2015-05-02 14:50:23 +02:00
|
|
|
+> flag "m" (optional_with_default 1 int)
|
2014-11-16 18:05:04 +01:00
|
|
|
~doc:"int Spin multiplicity (2S+1) of the molecule. Default is 1."
|
2015-05-04 20:19:59 +02:00
|
|
|
+> flag "p" no_arg
|
2015-09-08 15:29:05 +02:00
|
|
|
~doc:" Using pseudopotentials"
|
2015-11-25 23:46:09 +01:00
|
|
|
+> anon ("xyz_file" %: file )
|
2014-08-27 16:38:13 +02:00
|
|
|
|
2015-11-17 22:25:26 +01:00
|
|
|
|
|
|
|
let dummy_centers ~threshold ~molecule ~nuclei =
|
|
|
|
let d =
|
|
|
|
Molecule.distance_matrix molecule
|
|
|
|
in
|
|
|
|
let n =
|
|
|
|
Array.length d
|
|
|
|
in
|
|
|
|
let nuclei =
|
|
|
|
Array.of_list nuclei
|
|
|
|
in
|
|
|
|
let rec aux accu = function
|
|
|
|
| (-1,_) -> accu
|
|
|
|
| (i,-1) -> aux accu (i-1,i-1)
|
|
|
|
| (i,j) when (i>j) ->
|
|
|
|
let new_accu =
|
|
|
|
let x,y =
|
|
|
|
Element.covalent_radius (nuclei.(i)).Atom.element |> Positive_float.to_float,
|
|
|
|
Element.covalent_radius (nuclei.(j)).Atom.element |> Positive_float.to_float
|
|
|
|
in
|
|
|
|
let r =
|
|
|
|
( x +. y ) *. threshold
|
|
|
|
in
|
|
|
|
if d.(i).(j) < r then
|
|
|
|
(i,x,j,y,d.(i).(j)) :: accu
|
|
|
|
else
|
|
|
|
accu
|
|
|
|
in aux new_accu (i,j-1)
|
|
|
|
| (i,j) when (i=j) -> aux accu (i,j-1)
|
|
|
|
| _ -> assert false
|
|
|
|
in
|
|
|
|
aux [] (n-1,n-1)
|
|
|
|
|> List.map ~f:(fun (i,x,j,y,r) ->
|
|
|
|
let f =
|
|
|
|
x /. (x +. y)
|
|
|
|
in
|
|
|
|
let u =
|
|
|
|
Point3d.of_tuple ~units:Units.Bohr
|
|
|
|
( nuclei.(i).Atom.coord.Point3d.x +.
|
|
|
|
(nuclei.(j).Atom.coord.Point3d.x -. nuclei.(i).Atom.coord.Point3d.x) *. f,
|
|
|
|
nuclei.(i).Atom.coord.Point3d.y +.
|
|
|
|
(nuclei.(j).Atom.coord.Point3d.y -. nuclei.(i).Atom.coord.Point3d.y) *. f,
|
|
|
|
nuclei.(i).Atom.coord.Point3d.z +.
|
|
|
|
(nuclei.(j).Atom.coord.Point3d.z -. nuclei.(i).Atom.coord.Point3d.z) *. f)
|
|
|
|
in
|
|
|
|
Atom.{ element = Element.X ; charge = Charge.of_int 0 ; coord = u }
|
|
|
|
)
|
|
|
|
|
|
|
|
|
2015-11-25 23:46:09 +01:00
|
|
|
let list_basis () =
|
|
|
|
let basis_list =
|
|
|
|
Qpackage.root ^ "/install/emsl/EMSL_api.py list_basis"
|
|
|
|
|> Unix.open_process_in
|
|
|
|
|> In_channel.input_lines
|
|
|
|
|> List.map ~f:(fun x ->
|
|
|
|
match String.split x ~on:'\'' with
|
|
|
|
| [] -> ""
|
|
|
|
| a :: []
|
|
|
|
| _ :: a :: _ -> String.strip a
|
|
|
|
)
|
|
|
|
in
|
|
|
|
List.sort basis_list ~cmp:String.ascending
|
|
|
|
|> String.concat ~sep:"\t"
|
|
|
|
|
2015-11-17 22:25:26 +01:00
|
|
|
|
|
|
|
let run ?o b c d m p xyz_file =
|
2014-08-27 16:38:13 +02:00
|
|
|
|
|
|
|
(* Read molecule *)
|
|
|
|
let molecule =
|
2014-10-26 17:29:11 +01:00
|
|
|
(Molecule.of_xyz_file xyz_file ~charge:(Charge.of_int c)
|
|
|
|
~multiplicity:(Multiplicity.of_int m) )
|
2014-08-27 16:38:13 +02:00
|
|
|
in
|
2015-11-17 22:25:26 +01:00
|
|
|
let dummy =
|
|
|
|
dummy_centers ~threshold:d ~molecule ~nuclei:molecule.Molecule.nuclei
|
|
|
|
in
|
|
|
|
(*
|
|
|
|
List.iter dummy ~f:(fun x ->
|
|
|
|
Printf.printf "%s\n" (Atom.to_string ~units:Units.Angstrom x)
|
|
|
|
);
|
|
|
|
*)
|
|
|
|
let nuclei =
|
|
|
|
molecule.Molecule.nuclei @ dummy
|
|
|
|
in
|
|
|
|
|
2014-11-16 18:05:04 +01:00
|
|
|
|
2015-11-24 17:21:38 +01:00
|
|
|
let basis_table =
|
|
|
|
Hashtbl.Poly.create ()
|
|
|
|
in
|
|
|
|
|
2014-11-16 18:05:04 +01:00
|
|
|
(* Open basis set channels *)
|
|
|
|
let basis_channel element =
|
2015-11-17 22:25:26 +01:00
|
|
|
let key =
|
|
|
|
Element.to_string element
|
|
|
|
in
|
2014-11-16 18:05:04 +01:00
|
|
|
match Hashtbl.find basis_table key with
|
|
|
|
| Some in_channel ->
|
|
|
|
in_channel
|
2015-11-22 15:18:51 +01:00
|
|
|
| None ->
|
|
|
|
let msg =
|
|
|
|
Printf.sprintf "%s is not defined in basis %s.%!"
|
|
|
|
(Element.to_long_string element) b ;
|
|
|
|
in
|
|
|
|
failwith msg
|
2014-11-16 18:05:04 +01:00
|
|
|
in
|
|
|
|
|
2015-01-16 00:48:09 +01:00
|
|
|
let temp_filename =
|
|
|
|
Filename.temp_file "qp_create_" ".basis"
|
|
|
|
in
|
2015-11-22 15:18:51 +01:00
|
|
|
let () =
|
|
|
|
Sys.remove temp_filename
|
|
|
|
in
|
|
|
|
|
2015-11-24 17:21:38 +01:00
|
|
|
let fetch_channel basis =
|
|
|
|
let command =
|
|
|
|
Qpackage.root ^ "/scripts/get_basis.sh \"" ^ temp_filename
|
|
|
|
^ "." ^ basis ^ "\" \"" ^ basis ^"\""
|
|
|
|
in
|
|
|
|
match Sys.is_file basis with
|
|
|
|
| `Yes ->
|
|
|
|
In_channel.create basis
|
|
|
|
| _ ->
|
|
|
|
begin
|
|
|
|
let filename =
|
|
|
|
Unix.open_process_in command
|
|
|
|
|> In_channel.input_all
|
|
|
|
|> String.strip
|
|
|
|
in
|
|
|
|
let new_channel =
|
|
|
|
In_channel.create filename
|
|
|
|
in
|
|
|
|
Unix.unlink filename;
|
|
|
|
new_channel
|
|
|
|
end
|
|
|
|
in
|
|
|
|
|
2014-11-16 18:05:04 +01:00
|
|
|
let rec build_basis = function
|
|
|
|
| [] -> ()
|
|
|
|
| elem_and_basis_name :: rest ->
|
|
|
|
begin
|
|
|
|
match (String.lsplit2 ~on:':' elem_and_basis_name) with
|
|
|
|
| None -> (* Principal basis *)
|
|
|
|
begin
|
2015-11-24 17:21:38 +01:00
|
|
|
let basis =
|
|
|
|
elem_and_basis_name
|
2014-11-16 18:05:04 +01:00
|
|
|
in
|
2015-01-12 16:58:22 +01:00
|
|
|
let new_channel =
|
2015-11-24 17:21:38 +01:00
|
|
|
fetch_channel basis
|
2015-01-12 16:58:22 +01:00
|
|
|
in
|
|
|
|
List.iter nuclei ~f:(fun elem->
|
2015-11-17 22:25:26 +01:00
|
|
|
let key =
|
|
|
|
Element.to_string elem.Atom.element
|
2014-11-16 18:05:04 +01:00
|
|
|
in
|
|
|
|
match Hashtbl.add basis_table ~key:key ~data:new_channel with
|
|
|
|
| `Ok -> ()
|
|
|
|
| `Duplicate -> ()
|
|
|
|
)
|
|
|
|
end
|
|
|
|
| Some (key, basis) -> (*Aux basis *)
|
|
|
|
begin
|
2015-11-24 17:21:38 +01:00
|
|
|
let elem =
|
|
|
|
Element.of_string key
|
|
|
|
and basis =
|
|
|
|
String.lowercase basis
|
2014-11-16 18:05:04 +01:00
|
|
|
in
|
2015-11-17 22:25:26 +01:00
|
|
|
let key =
|
|
|
|
Element.to_string elem
|
2014-11-16 18:05:04 +01:00
|
|
|
in
|
2015-11-24 17:21:38 +01:00
|
|
|
let new_channel =
|
|
|
|
fetch_channel basis
|
2015-01-12 16:58:22 +01:00
|
|
|
in
|
|
|
|
begin
|
|
|
|
match Hashtbl.add basis_table ~key:key ~data:new_channel with
|
|
|
|
| `Ok -> ()
|
|
|
|
| `Duplicate -> failwith ("Duplicate definition of basis for "^(Element.to_long_string elem))
|
|
|
|
end
|
|
|
|
end
|
2014-11-16 18:05:04 +01:00
|
|
|
end;
|
|
|
|
build_basis rest
|
|
|
|
in
|
2015-01-12 16:58:22 +01:00
|
|
|
String.split ~on:'|' b
|
2014-11-16 18:05:04 +01:00
|
|
|
|> List.rev_map ~f:String.strip
|
|
|
|
|> build_basis;
|
2014-08-27 16:38:13 +02:00
|
|
|
|
|
|
|
(* Build EZFIO File name *)
|
|
|
|
let ezfio_file =
|
|
|
|
match o with
|
|
|
|
| Some x -> x
|
|
|
|
| None ->
|
|
|
|
begin
|
|
|
|
match String.rsplit2 ~on:'.' xyz_file with
|
|
|
|
| Some (x,"xyz") -> x^".ezfio"
|
|
|
|
| _ -> xyz_file^".ezfio"
|
|
|
|
end
|
|
|
|
in
|
|
|
|
if Sys.file_exists_exn ezfio_file then
|
|
|
|
failwith (ezfio_file^" already exists");
|
|
|
|
|
|
|
|
(* Create EZFIO *)
|
|
|
|
Ezfio.set_file ezfio_file;
|
|
|
|
|
|
|
|
(* Write Electrons *)
|
2014-10-23 14:42:14 +02:00
|
|
|
Ezfio.set_electrons_elec_alpha_num ( Elec_alpha_number.to_int
|
2014-08-27 16:38:13 +02:00
|
|
|
molecule.Molecule.elec_alpha ) ;
|
2014-10-23 14:42:14 +02:00
|
|
|
Ezfio.set_electrons_elec_beta_num ( Elec_beta_number.to_int
|
2014-08-27 16:38:13 +02:00
|
|
|
molecule.Molecule.elec_beta ) ;
|
|
|
|
|
|
|
|
(* Write Nuclei *)
|
|
|
|
let labels =
|
|
|
|
List.map ~f:(fun x->Element.to_string x.Atom.element) nuclei
|
|
|
|
and charges =
|
|
|
|
List.map ~f:(fun x-> Atom.(Charge.to_float x.charge)) nuclei
|
|
|
|
and coords =
|
|
|
|
(List.map ~f:(fun x-> x.Atom.coord.Point3d.x) nuclei) @
|
|
|
|
(List.map ~f:(fun x-> x.Atom.coord.Point3d.y) nuclei) @
|
|
|
|
(List.map ~f:(fun x-> x.Atom.coord.Point3d.z) nuclei) in
|
|
|
|
let nucl_num = (List.length labels) in
|
|
|
|
Ezfio.set_nuclei_nucl_num nucl_num ;
|
|
|
|
Ezfio.set_nuclei_nucl_label (Ezfio.ezfio_array_of_list
|
|
|
|
~rank:1 ~dim:[| nucl_num |] ~data:labels);
|
|
|
|
Ezfio.set_nuclei_nucl_charge (Ezfio.ezfio_array_of_list
|
|
|
|
~rank:1 ~dim:[| nucl_num |] ~data:charges);
|
|
|
|
Ezfio.set_nuclei_nucl_coord (Ezfio.ezfio_array_of_list
|
|
|
|
~rank:2 ~dim:[| nucl_num ; 3 |] ~data:coords);
|
|
|
|
|
|
|
|
(* Write Basis set *)
|
2014-09-17 23:47:13 +02:00
|
|
|
let basis =
|
2014-11-15 11:01:30 +01:00
|
|
|
|
2015-11-22 15:18:51 +01:00
|
|
|
let nmax =
|
|
|
|
Nucl_number.get_max ()
|
|
|
|
in
|
2014-10-23 14:42:14 +02:00
|
|
|
let rec do_work (accu:(Atom.t*Nucl_number.t) list) (n:int) = function
|
2014-09-17 23:47:13 +02:00
|
|
|
| [] -> accu
|
2014-11-15 11:01:30 +01:00
|
|
|
| e::tail ->
|
2015-11-22 15:18:51 +01:00
|
|
|
let new_accu =
|
|
|
|
(e,(Nucl_number.of_int ~max:nmax n))::accu
|
|
|
|
in
|
2014-09-17 23:47:13 +02:00
|
|
|
do_work new_accu (n+1) tail
|
|
|
|
in
|
2014-11-15 11:01:30 +01:00
|
|
|
let result = do_work [] 1 nuclei
|
2014-09-17 23:47:13 +02:00
|
|
|
|> List.rev
|
|
|
|
|> List.map ~f:(fun (x,i) ->
|
2014-11-15 11:01:30 +01:00
|
|
|
try
|
2015-11-17 22:25:26 +01:00
|
|
|
let e =
|
|
|
|
match x.Atom.element with
|
|
|
|
| Element.X -> Element.H
|
|
|
|
| e -> e
|
|
|
|
in
|
|
|
|
Basis.read_element (basis_channel x.Atom.element) i e
|
2014-11-15 11:01:30 +01:00
|
|
|
with
|
2015-11-22 15:18:51 +01:00
|
|
|
| End_of_file -> failwith
|
|
|
|
("Element "^(Element.to_string x.Atom.element)^" not found in basis set.")
|
2014-11-15 11:01:30 +01:00
|
|
|
)
|
2014-09-17 23:47:13 +02:00
|
|
|
|> List.concat
|
2014-11-15 11:01:30 +01:00
|
|
|
in
|
|
|
|
(* close all in_channels *)
|
|
|
|
result
|
2014-09-17 23:47:13 +02:00
|
|
|
in
|
|
|
|
let long_basis = Long_basis.of_basis basis in
|
|
|
|
let ao_num = List.length long_basis in
|
|
|
|
Ezfio.set_ao_basis_ao_num ao_num;
|
2014-10-09 10:47:08 +02:00
|
|
|
Ezfio.set_ao_basis_ao_basis b;
|
2014-09-17 23:47:13 +02:00
|
|
|
let ao_prim_num = List.map long_basis ~f:(fun (_,g,_) -> List.length g.Gto.lc)
|
2014-10-23 14:42:14 +02:00
|
|
|
and ao_nucl = List.map long_basis ~f:(fun (_,_,n) -> Nucl_number.to_int n)
|
2014-09-18 17:01:43 +02:00
|
|
|
and ao_power=
|
|
|
|
let l = List.map long_basis ~f:(fun (x,_,_) -> x) in
|
|
|
|
(List.map l ~f:(fun t -> Positive_int.to_int Symmetry.Xyz.(t.x)) )@
|
|
|
|
(List.map l ~f:(fun t -> Positive_int.to_int Symmetry.Xyz.(t.y)) )@
|
|
|
|
(List.map l ~f:(fun t -> Positive_int.to_int Symmetry.Xyz.(t.z)) )
|
|
|
|
in
|
|
|
|
let ao_prim_num_max = List.fold ~init:0 ~f:(fun s x ->
|
|
|
|
if x > s then x
|
|
|
|
else s) ao_prim_num
|
|
|
|
in
|
|
|
|
let gtos = List.map long_basis ~f:(fun (_,x,_) -> x) in
|
|
|
|
|
|
|
|
let create_expo_coef ec =
|
|
|
|
let coefs =
|
|
|
|
begin match ec with
|
|
|
|
| `Coefs -> List.map gtos ~f:(fun x->
|
|
|
|
List.map x.Gto.lc ~f:(fun (_,coef) -> AO_coef.to_float coef) )
|
|
|
|
| `Expos -> List.map gtos ~f:(fun x->
|
2014-10-23 14:42:14 +02:00
|
|
|
List.map x.Gto.lc ~f:(fun (prim,_) -> AO_expo.to_float
|
2014-09-18 17:01:43 +02:00
|
|
|
prim.Primitive.expo) )
|
|
|
|
end
|
|
|
|
in
|
|
|
|
let rec get_n n accu = function
|
|
|
|
| [] -> List.rev accu
|
|
|
|
| h::tail ->
|
|
|
|
let y =
|
|
|
|
begin match List.nth h n with
|
|
|
|
| Some x -> x
|
|
|
|
| None -> 0.
|
|
|
|
end
|
|
|
|
in
|
|
|
|
get_n n (y::accu) tail
|
|
|
|
in
|
|
|
|
let rec build accu = function
|
|
|
|
| n when n=ao_prim_num_max -> accu
|
|
|
|
| n -> build ( accu @ (get_n n [] coefs) ) (n+1)
|
|
|
|
in
|
|
|
|
build [] 0
|
|
|
|
in
|
|
|
|
|
|
|
|
let ao_coef = create_expo_coef `Coefs
|
|
|
|
and ao_expo = create_expo_coef `Expos
|
2014-09-17 23:47:13 +02:00
|
|
|
in
|
|
|
|
Ezfio.set_ao_basis_ao_prim_num (Ezfio.ezfio_array_of_list
|
|
|
|
~rank:1 ~dim:[| ao_num |] ~data:ao_prim_num) ;
|
|
|
|
Ezfio.set_ao_basis_ao_nucl(Ezfio.ezfio_array_of_list
|
|
|
|
~rank:1 ~dim:[| ao_num |] ~data:ao_nucl) ;
|
2014-09-18 17:01:43 +02:00
|
|
|
Ezfio.set_ao_basis_ao_power(Ezfio.ezfio_array_of_list
|
|
|
|
~rank:2 ~dim:[| ao_num ; 3 |] ~data:ao_power) ;
|
|
|
|
Ezfio.set_ao_basis_ao_coef(Ezfio.ezfio_array_of_list
|
|
|
|
~rank:2 ~dim:[| ao_num ; ao_prim_num_max |] ~data:ao_coef) ;
|
|
|
|
Ezfio.set_ao_basis_ao_expo(Ezfio.ezfio_array_of_list
|
|
|
|
~rank:2 ~dim:[| ao_num ; ao_prim_num_max |] ~data:ao_expo) ;
|
2015-01-06 19:12:17 +01:00
|
|
|
|
2015-05-02 14:50:23 +02:00
|
|
|
|
|
|
|
(* Doesn't work... *)
|
2015-05-04 20:19:59 +02:00
|
|
|
if (p) then
|
|
|
|
begin
|
2016-01-25 16:11:26 +01:00
|
|
|
Qpackage.root ^ "/scripts/pseudo/put_pseudo_in_ezfio.py " ^ ezfio_file ^ " " ^ " BFD-Pseudo"
|
2015-05-04 20:19:59 +02:00
|
|
|
|> Sys.command_exn
|
|
|
|
end;
|
2015-05-02 14:50:23 +02:00
|
|
|
|
2015-01-06 19:12:17 +01:00
|
|
|
match Input.Ao_basis.read () with
|
|
|
|
| None -> failwith "Error in basis"
|
|
|
|
| Some x -> Input.Ao_basis.write x
|
|
|
|
|
2015-11-17 22:25:26 +01:00
|
|
|
|
2014-08-27 16:38:13 +02:00
|
|
|
|
|
|
|
let command =
|
|
|
|
Command.basic
|
|
|
|
~summary: "Quantum Package command"
|
2014-11-16 18:05:04 +01:00
|
|
|
~readme:(fun () -> "
|
2015-11-25 23:46:09 +01:00
|
|
|
|
|
|
|
=== Available basis sets ===
|
|
|
|
|
|
|
|
" ^ (list_basis ()) ^ "
|
|
|
|
|
|
|
|
============================
|
|
|
|
|
2015-11-24 17:31:22 +01:00
|
|
|
Creates an EZFIO directory from a standard xyz file. The basis set is defined
|
|
|
|
as a single string if all the atoms are taken from the same basis set,
|
|
|
|
otherwise specific elements can be defined as follows:
|
2014-11-16 18:05:04 +01:00
|
|
|
|
2015-01-12 16:58:22 +01:00
|
|
|
-b \"cc-pcvdz | H:cc-pvdz | C:6-31g\"
|
2014-11-16 18:05:04 +01:00
|
|
|
|
2015-11-24 17:31:22 +01:00
|
|
|
If a file with the same name as the basis set exists, this file will be read.
|
|
|
|
Otherwise, the basis set is obtained from the database.
|
|
|
|
|
2015-11-25 23:46:09 +01:00
|
|
|
" )
|
2014-08-27 16:38:13 +02:00
|
|
|
spec
|
2015-11-17 22:25:26 +01:00
|
|
|
(fun o b c d m p xyz_file () ->
|
|
|
|
run ?o b c d m p xyz_file )
|
|
|
|
|
2014-08-27 16:38:13 +02:00
|
|
|
|
|
|
|
let () =
|
|
|
|
Command.run command
|
2015-11-17 22:25:26 +01:00
|
|
|
|
2014-08-27 16:38:13 +02:00
|
|
|
|
|
|
|
|
|
|
|
|