diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..99956fdc --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +*.irp.f linguist-language=IRPF90 +*.f linguist-language=Fortran +*.ml linguist-language=Ocaml +*.sh linguist-language=Bash +*.py linguist-language=Python diff --git a/.gitignore b/.gitignore index cdcdc6d8..2a924323 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,5 @@ bin/ quantum_package_static.tar.gz resultsFile opam_installer.sh +*.mod +*.p \ No newline at end of file diff --git a/.travis.yml b/.travis.yml index 0db0f5d1..9aadf7ef 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,5 +1,9 @@ sudo: true +language: python +python: + - "2.6" + before_script: - sudo apt-get update - sudo apt-get install gfortran liblapack-dev @@ -9,4 +13,4 @@ script: - source ./quantum_package.rc - cp ./src/Makefile.config.gfortran ./src/Makefile.config - make build - + - ./tests/unit_test/unit_test.py diff --git a/INSTALL.md b/INSTALL.md index 712e3d8f..47319c9c 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -6,8 +6,9 @@ * m4 * GNU make * Fortran compiler (ifort or gfortran are tested) -* Python >= 2.7 +* Python >= 2.6 * Bash +* Patch (for opam) ## Standard installation diff --git a/Makefile b/Makefile index 29f11113..ec555670 100644 --- a/Makefile +++ b/Makefile @@ -44,6 +44,6 @@ ocaml: $(MAKE) ocaml/Qptypes.ml veryclean: - rm -f EZFIO + rm -rf EZFIO $(MAKE) EZFIO $(MAKE) -C src veryclean diff --git a/src/BiInts/ASSUMPTIONS.rst b/data/ezfio_defaults/.empty similarity index 100% rename from src/BiInts/ASSUMPTIONS.rst rename to data/ezfio_defaults/.empty diff --git a/data/ezfio_defaults/.gitignore b/data/ezfio_defaults/.gitignore new file mode 100644 index 00000000..f88730c3 --- /dev/null +++ b/data/ezfio_defaults/.gitignore @@ -0,0 +1 @@ +*ezfio_interface_default \ No newline at end of file diff --git a/data/ezfio_defaults b/data/ezfio_defaults/WILL_BE_DELETED.ezfio_default similarity index 91% rename from data/ezfio_defaults rename to data/ezfio_defaults/WILL_BE_DELETED.ezfio_default index 347e3751..cf54a1dd 100644 --- a/data/ezfio_defaults +++ b/data/ezfio_defaults/WILL_BE_DELETED.ezfio_default @@ -43,11 +43,6 @@ all_singles pt2_max 1.e-8 do_pt2_end False -cassd - n_det_max_cassd 10000 - pt2_max 1.e-4 - do_pt2_end True - hartree_fock n_it_scf_max 200 thresh_scf 1.e-10 diff --git a/data/ezfio_defaults/cisd.ezfio_default b/data/ezfio_defaults/cisd.ezfio_default new file mode 100644 index 00000000..95991f8f --- /dev/null +++ b/data/ezfio_defaults/cisd.ezfio_default @@ -0,0 +1,4 @@ +cisd_selected + n_det_max_cisd 10000 + pt2_max 1.e-4 + diff --git a/data/ezfio_defaults/determinants.ezfio_default b/data/ezfio_defaults/determinants.ezfio_default new file mode 100644 index 00000000..2cfbe3ea --- /dev/null +++ b/data/ezfio_defaults/determinants.ezfio_default @@ -0,0 +1,9 @@ +determinants + n_states 1 + n_states_diag determinants_n_states + n_det_max_jacobi 1000 + threshold_generators 0.99 + threshold_selectors 0.999 + read_wf false + s2_eig false + only_single_double_dm false diff --git a/data/ezfio_defaults/properties.ezfio_default b/data/ezfio_defaults/properties.ezfio_default new file mode 100644 index 00000000..ce06d413 --- /dev/null +++ b/data/ezfio_defaults/properties.ezfio_default @@ -0,0 +1,2 @@ +properties + z_one_point 3.9 diff --git a/ocaml/Input.ml b/ocaml/Input.ml index df293cc7..01bb54a0 100644 --- a/ocaml/Input.ml +++ b/ocaml/Input.ml @@ -2,16 +2,10 @@ open Qputils;; open Qptypes;; open Core.Std;; - include Input_ao_basis;; -include Input_bi_integrals;; include Input_bitmasks;; -include Input_cisd_sc2;; include Input_determinants;; include Input_electrons;; -include Input_full_ci;; -include Input_hartree_fock;; include Input_mo_basis;; include Input_nuclei;; - - +include Input_auto_generated;; \ No newline at end of file diff --git a/ocaml/Input_cisd_sc2.ml b/ocaml/Input_cisd_sc2.ml deleted file mode 100644 index ed046d79..00000000 --- a/ocaml/Input_cisd_sc2.ml +++ /dev/null @@ -1,127 +0,0 @@ -open Qptypes;; -open Qputils;; -open Core.Std;; - -module Cisd_sc2 : sig - type t = - { n_det_max_cisd_sc2 : Det_number_max.t; - pt2_max : PT2_energy.t; - do_pt2_end : bool; - } with sexp - ;; - val read : unit -> t option - val write : t -> unit - val to_string : t -> string - val to_rst : t -> Rst_string.t - val of_rst : Rst_string.t -> t option -end = struct - type t = - { n_det_max_cisd_sc2 : Det_number_max.t; - pt2_max : PT2_energy.t; - do_pt2_end : bool; - } with sexp - ;; - - let get_default = Qpackage.get_ezfio_default "cisd_sc2_selected";; - - let read_n_det_max_cisd_sc2 () = - if not (Ezfio.has_cisd_sc2_selected_n_det_max_cisd_sc2 ()) then - get_default "n_det_max_cisd_sc2" - |> Int.of_string - |> Ezfio.set_cisd_sc2_selected_n_det_max_cisd_sc2 - ; - Ezfio.get_cisd_sc2_selected_n_det_max_cisd_sc2 () - |> Det_number_max.of_int - ;; - - let write_n_det_max_cisd_sc2 n = - Det_number_max.to_int n - |> Ezfio.set_cisd_sc2_selected_n_det_max_cisd_sc2 - ;; - - - let read_pt2_max () = - if not (Ezfio.has_cisd_sc2_selected_pt2_max ()) then - get_default "pt2_max" - |> Float.of_string - |> Ezfio.set_cisd_sc2_selected_pt2_max - ; - Ezfio.get_cisd_sc2_selected_pt2_max () - |> PT2_energy.of_float - ;; - - let write_pt2_max p = - PT2_energy.to_float p - |> Ezfio.set_cisd_sc2_selected_pt2_max - ;; - - - let read_do_pt2_end () = - if not (Ezfio.has_cisd_sc2_selected_do_pt2_end ()) then - get_default "do_pt2_end" - |> Bool.of_string - |> Ezfio.set_cisd_sc2_selected_do_pt2_end - ; - Ezfio.get_cisd_sc2_selected_do_pt2_end () - ;; - - let write_do_pt2_end = - Ezfio.set_cisd_sc2_selected_do_pt2_end - ;; - - - let read () = - Some - { n_det_max_cisd_sc2 = read_n_det_max_cisd_sc2 (); - pt2_max = read_pt2_max (); - do_pt2_end = read_do_pt2_end (); - } - ;; - - let write { n_det_max_cisd_sc2 ; - pt2_max ; - do_pt2_end ; - } = - write_n_det_max_cisd_sc2 n_det_max_cisd_sc2; - write_pt2_max pt2_max; - write_do_pt2_end do_pt2_end; - ;; - - let to_string b = - Printf.sprintf " -n_det_max_cisd_sc2 = %s -pt2_max = %s -do_pt2_end = %s -" - (Det_number_max.to_string b.n_det_max_cisd_sc2) - (PT2_energy.to_string b.pt2_max) - (Bool.to_string b.do_pt2_end) - ;; - - let to_rst b = - Printf.sprintf " -Stop when the `n_det` > `n_det_max_cisd_sc2` :: - - n_det_max_cisd_sc2 = %s - -Stop when -E(PT2) < `pt2_max` :: - - pt2_max = %s - -Compute E(PT2) at the end :: - - do_pt2_end = %s - -" - (Det_number_max.to_string b.n_det_max_cisd_sc2) - (PT2_energy.to_string b.pt2_max) - (Bool.to_string b.do_pt2_end) - |> Rst_string.of_string - ;; - - include Generic_input_of_rst;; - let of_rst = of_rst t_of_sexp;; - -end - - diff --git a/ocaml/Input_full_ci.ml b/ocaml/Input_full_ci.ml deleted file mode 100644 index 01548e88..00000000 --- a/ocaml/Input_full_ci.ml +++ /dev/null @@ -1,153 +0,0 @@ -open Qptypes;; -open Qputils;; -open Core.Std;; - -module Full_ci : sig - type t = - { n_det_max_fci : Det_number_max.t; - pt2_max : PT2_energy.t; - do_pt2_end : bool; - var_pt2_ratio : Normalized_float.t; - } with sexp - ;; - val read : unit -> t option - val write : t-> unit - val to_string : t -> string - val to_rst : t -> Rst_string.t - val of_rst : Rst_string.t -> t option -end = struct - type t = - { n_det_max_fci : Det_number_max.t; - pt2_max : PT2_energy.t; - do_pt2_end : bool; - var_pt2_ratio : Normalized_float.t; - } with sexp - ;; - - let get_default = Qpackage.get_ezfio_default "full_ci";; - - let read_n_det_max_fci () = - if not (Ezfio.has_full_ci_n_det_max_fci ()) then - get_default "n_det_max_fci" - |> Int.of_string - |> Ezfio.set_full_ci_n_det_max_fci - ; - Ezfio.get_full_ci_n_det_max_fci () - |> Det_number_max.of_int - ;; - - let write_n_det_max_fci ndet = - Det_number_max.to_int ndet - |> Ezfio.set_full_ci_n_det_max_fci - ;; - - let read_var_pt2_ratio () = - if not (Ezfio.has_full_ci_var_pt2_ratio ()) then - get_default "var_pt2_ratio" - |> Float.of_string - |> Ezfio.set_full_ci_var_pt2_ratio - ; - Ezfio.get_full_ci_var_pt2_ratio () - |> Normalized_float.of_float - ;; - - let write_var_pt2_ratio ratio = - Normalized_float.to_float ratio - |> Ezfio.set_full_ci_var_pt2_ratio - ;; - - let read_pt2_max () = - if not (Ezfio.has_full_ci_pt2_max ()) then - get_default "pt2_max" - |> Float.of_string - |> Ezfio.set_full_ci_pt2_max - ; - Ezfio.get_full_ci_pt2_max () - |> PT2_energy.of_float - ;; - - let write_pt2_max pt2_max = - PT2_energy.to_float pt2_max - |> Ezfio.set_full_ci_pt2_max - ;; - - let read_do_pt2_end () = - if not (Ezfio.has_full_ci_do_pt2_end ()) then - get_default "do_pt2_end" - |> Bool.of_string - |> Ezfio.set_full_ci_do_pt2_end - ; - Ezfio.get_full_ci_do_pt2_end () - ;; - - let write_do_pt2_end = - Ezfio.set_full_ci_do_pt2_end - ;; - - - let read () = - Some - { n_det_max_fci = read_n_det_max_fci (); - pt2_max = read_pt2_max (); - do_pt2_end = read_do_pt2_end (); - var_pt2_ratio = read_var_pt2_ratio (); - } - ;; - - - let write { n_det_max_fci ; - pt2_max ; - do_pt2_end ; - var_pt2_ratio ; - } = - write_n_det_max_fci n_det_max_fci; - write_pt2_max pt2_max; - write_do_pt2_end do_pt2_end; - write_var_pt2_ratio var_pt2_ratio; - ;; - - let to_string b = - Printf.sprintf " -n_det_max_fci = %s -pt2_max = %s -do_pt2_end = %s -var_pt2_ratio = %s -" - (Det_number_max.to_string b.n_det_max_fci) - (PT2_energy.to_string b.pt2_max) - (Bool.to_string b.do_pt2_end) - (Normalized_float.to_string b.var_pt2_ratio) - ;; - - let to_rst b = - Printf.sprintf " -Stop when the `n_det` > `n_det_max_fci` :: - - n_det_max_fci = %s - -Stop when -E(PT2) < `pt2_max` :: - - pt2_max = %s - -Compute E(PT2) at the end :: - - do_pt2_end = %s - -Target energy ratio variational/(variational+PT2) :: - - var_pt2_ratio = %s -" - (Det_number_max.to_string b.n_det_max_fci) - (PT2_energy.to_string b.pt2_max) - (Bool.to_string b.do_pt2_end) - (Normalized_float.to_string b.var_pt2_ratio) - |> Rst_string.of_string - ;; - - include Generic_input_of_rst;; - let of_rst = of_rst t_of_sexp;; - - -end - - diff --git a/ocaml/Input_hartree_fock.ml b/ocaml/Input_hartree_fock.ml deleted file mode 100644 index 82110647..00000000 --- a/ocaml/Input_hartree_fock.ml +++ /dev/null @@ -1,128 +0,0 @@ -open Qptypes;; -open Qputils;; -open Core.Std;; - -module Hartree_fock : sig - type t = - { n_it_scf_max : Strictly_positive_int.t; - thresh_scf : Threshold.t; - guess : MO_guess.t; - } with sexp - ;; - val read : unit -> t option - val write : t -> unit - val to_string : t -> string - val to_rst : t -> Rst_string.t - val of_rst : Rst_string.t -> t option -end = struct - type t = - { n_it_scf_max : Strictly_positive_int.t; - thresh_scf : Threshold.t; - guess : MO_guess.t; - } with sexp - ;; - - let get_default = Qpackage.get_ezfio_default "hartree_fock";; - - let read_n_it_scf_max () = - if not (Ezfio.has_hartree_fock_n_it_scf_max ()) then - get_default "n_it_scf_max" - |> Int.of_string - |> Ezfio.set_hartree_fock_n_it_scf_max - ; - Ezfio.get_hartree_fock_n_it_scf_max () - |> Strictly_positive_int.of_int - ;; - - let write_n_it_scf_max n_it_scf_max = - Strictly_positive_int.to_int n_it_scf_max - |> Ezfio.set_hartree_fock_n_it_scf_max - ;; - - let read_thresh_scf () = - if not (Ezfio.has_hartree_fock_thresh_scf()) then - get_default "thresh_scf" - |> Float.of_string - |> Ezfio.set_hartree_fock_thresh_scf - ; - Ezfio.get_hartree_fock_thresh_scf () - |> Threshold.of_float - ;; - - let write_thresh_scf thresh_scf = - Threshold.to_float thresh_scf - |> Ezfio.set_hartree_fock_thresh_scf - ;; - - let read_guess () = - if not (Ezfio.has_hartree_fock_guess ()) then - get_default "guess" - |> String.strip ~drop:(fun x -> x = '"') - |> Ezfio.set_hartree_fock_guess - ; - Ezfio.get_hartree_fock_guess () - |> MO_guess.of_string - ;; - - let write_guess guess = - MO_guess.to_string guess - |> Ezfio.set_hartree_fock_guess - ;; - - let read () = - Some - { n_it_scf_max = read_n_it_scf_max (); - thresh_scf = read_thresh_scf (); - guess = read_guess (); - } - ;; - - - let write { n_it_scf_max ; - thresh_scf ; - guess ; - } = - write_n_it_scf_max n_it_scf_max; - write_thresh_scf thresh_scf; - write_guess guess - ;; - - - let to_string b = - Printf.sprintf " -n_it_scf_max = %s -thresh_scf = %s -guess = %s -" - (Strictly_positive_int.to_string b.n_it_scf_max) - (Threshold.to_string b.thresh_scf) - (MO_guess.to_string b.guess) - ;; - - let to_rst b = - Printf.sprintf " -Type of MO guess [ Huckel | HCore ] :: - - guess = %s - -Max number of SCF iterations :: - - n_it_scf_max = %s - -SCF convergence criterion (on energy) :: - - thresh_scf = %s - -" - (MO_guess.to_string b.guess) - (Strictly_positive_int.to_string b.n_it_scf_max) - (Threshold.to_string b.thresh_scf) - |> Rst_string.of_string - ;; - - include Generic_input_of_rst;; - let of_rst = of_rst t_of_sexp;; - -end - - diff --git a/ocaml/Input_mo_basis.ml b/ocaml/Input_mo_basis.ml index f02dbfa9..ab75b869 100644 --- a/ocaml/Input_mo_basis.ml +++ b/ocaml/Input_mo_basis.ml @@ -2,27 +2,21 @@ open Qptypes;; open Qputils;; open Core.Std;; +type t_mo = + { mo_tot_num : MO_number.t ; + mo_label : MO_label.t; + mo_occ : MO_occ.t array; + mo_coef : (MO_coef.t array) array; + ao_md5 : MD5.t; + } with sexp + module Mo_basis : sig - type t = - { mo_tot_num : MO_number.t ; - mo_label : MO_label.t; - mo_occ : MO_occ.t array; - mo_coef : (MO_coef.t array) array; - ao_md5 : MD5.t; - } with sexp - ;; + type t = t_mo val read : unit -> t option val to_string : t -> string val to_rst : t -> Rst_string.t end = struct - type t = - { mo_tot_num : MO_number.t ; - mo_label : MO_label.t; - mo_occ : MO_occ.t array; - mo_coef : (MO_coef.t array) array; - ao_md5 : MD5.t; - } with sexp - ;; + type t = t_mo let get_default = Qpackage.get_ezfio_default "mo_basis";; diff --git a/ocaml/Qpackage.ml b/ocaml/Qpackage.ml index 143cff28..a3862f11 100644 --- a/ocaml/Qpackage.ml +++ b/ocaml/Qpackage.ml @@ -71,8 +71,8 @@ let executables = lazy ( ) -let get_ezfio_default directory data = - let filename = root^"/data/ezfio_defaults" in + +let get_ezfio_default_in_file ~directory ~data ~filename = let lines = In_channel.with_file filename ~f:(fun in_channel -> In_channel.input_lines in_channel) in let rec find_dir = function @@ -93,8 +93,10 @@ let get_ezfio_default directory data = begin match (String.lsplit2 ~on:' ' (String.strip line)) with | Some (l,r) -> - if (l = data) then (String.lowercase (String.strip r)) - else find_data rest + if (l = data) then + String.strip r + else + find_data rest | None -> raise Not_found end | [] -> raise Not_found @@ -102,3 +104,23 @@ let get_ezfio_default directory data = find_dir lines |> find_data ; ;; + +let get_ezfio_default directory data = + let dirname = root^"/data/ezfio_defaults/" in + + let rec aux = function + | [] -> raise Not_found + | filename :: tail -> + let filename = + dirname^filename + in + try + get_ezfio_default_in_file ~directory ~data ~filename + with + | Not_found -> aux tail + in + Sys.readdir dirname + |> Array.to_list + |> aux +;; + diff --git a/ocaml/qp_run.ml b/ocaml/qp_run.ml index 341a4ce6..2abea107 100644 --- a/ocaml/qp_run.ml +++ b/ocaml/qp_run.ml @@ -20,6 +20,10 @@ let run exe ezfio_file = Printf.printf "===============\nQuantum Package\n===============\n\n"; Printf.printf "Date : %s\n\n%!" (Time.to_string time_start); + match (Sys.command ("qp_edit -c "^ezfio_file)) with + | 0 -> () + | i -> failwith "Error: Input inconsistent\n"; + ; let exe = match (List.find ~f:(fun (x,_) -> x = exe) executables) with | None -> assert false diff --git a/ocaml/qptypes_generator.ml b/ocaml/qptypes_generator.ml index f5a62356..fd1739f1 100644 --- a/ocaml/qptypes_generator.ml +++ b/ocaml/qptypes_generator.ml @@ -150,19 +150,41 @@ end = struct let to_string = function | Huckel -> \"Huckel\" - | HCore -> \"HCore\" + | HCore -> \"Hcore\" let of_string s = - let s = - String.lowercase s - in match s with - | \"huckel\" -> Huckel - | \"hcore\" -> HCore + | \"Huckel\" -> Huckel + | \"Hcore\" -> HCore | _ -> failwith (\"Wrong Guess type : \"^s) +end + +module Disk_access : sig + type t with sexp + val to_string : t -> string + val of_string : string -> t +end = struct + type t = + | Read + | Write + | None + with sexp + + let to_string = function + | Read -> \"Read\" + | Write -> \"Write\" + | None -> \"None\" + let of_string s = + match s with + | \"Read\" -> Read + | \"Write\" -> Write + | \"None\" -> None + | _ -> failwith (\"Wrong IO type : \"^s) + end " + ;; let template = format_of_string " diff --git a/ocaml/test_input.ml b/ocaml/test_input.ml deleted file mode 100644 index d7e0c9d3..00000000 --- a/ocaml/test_input.ml +++ /dev/null @@ -1,177 +0,0 @@ -open Qptypes;; - -let test_ao () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Ao_basis.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Ao_basis.to_string b); - print_endline (Input.Ao_basis.to_rst b |> Rst_string.to_string); -;; - -let test_bielec_intergals () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Bielec_integrals.read () with - | Some x -> x - | None -> assert false - in - let output = Input.Bielec_integrals.to_string b - in - print_endline output; - let rst = Input.Bielec_integrals.to_rst b in - let b2 = match Input.Bielec_integrals.of_rst rst with - | Some x -> x - | None -> assert false - in - if (b = b2) then - print_endline "OK" - else - print_endline "rst failed"; -;; - -let test_bitmasks () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Bitmasks.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Bitmasks.to_string b); -;; - - -let test_dets () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Determinants.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Determinants.to_rst b |> Rst_string.to_string ) ; - print_endline (Input.Determinants.sexp_of_t b |> Sexplib.Sexp.to_string ) ; - let rst = Input.Determinants.to_rst b in - let b2 = match Input.Determinants.of_rst rst with - | Some x -> x - | None -> assert false - in - if (b2 = b) then - print_endline "OK" - else - print_endline "Failed" -;; - -let test_cisd_sc2 () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Cisd_sc2.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Cisd_sc2.to_string b); - let rst = Input.Cisd_sc2.to_rst b in - let b2 = match Input.Cisd_sc2.of_rst rst with - | Some x -> x - | None -> assert false - in - if (b = b2) then - print_endline "OK" - else - print_endline "rst failed"; - -;; - -let test_electrons () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Electrons.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Electrons.to_string b); - let rst = Input.Electrons.to_rst b in - let b2 = match Input.Electrons.of_rst rst with - | Some x -> x - | None -> assert false - in - if (b = b2) then - print_endline "OK" - else - print_endline "Failed in rst" -;; - -let test_fci () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Full_ci.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Full_ci.to_string b); - let rst = Input.Full_ci.to_rst b in - let b2 = match Input.Full_ci.of_rst rst with - | Some x -> x - | None -> assert false - in - print_endline (Input.Full_ci.to_string b); - if (b = b2) then - print_endline "OK" - else - print_endline "Failed in rst" -;; - -let test_hf () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Hartree_fock.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Hartree_fock.to_string b); - let rst = Input.Hartree_fock.to_rst b in - let b2 = match Input.Hartree_fock.of_rst rst with - | Some x -> x - | None -> assert false - in - print_endline (Input.Hartree_fock.to_string b); - if (b = b2) then - print_endline "OK" - else - print_endline "Failed in rst" -;; - -let test_mo () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Mo_basis.read () with - | Some x -> x - | None -> assert false - in - print_endline (Input.Mo_basis.to_string b); -;; - -let test_nucl () = - Ezfio.set_file "F2.ezfio" ; - let b = match Input.Nuclei.read () with - | Some x -> x - | None -> assert false - in - let rst = Input.Nuclei.to_rst b in - let b2 = match Input.Nuclei.of_rst rst with - | Some x -> x - | None -> assert false - in - print_endline (Input.Nuclei.to_string b); - if (b = b2) then - print_endline "OK" - else - print_endline "Failed in rst" -;; - -(* -test_ao ();; -test_bitmasks (); -test_cis (); -test_cisd_sc2 (); -test_dets (); -test_hf ();; -test_mo ();; -test_nucl (); -test_bielec_intergals ();; -test_electrons(); -*) -test_dets (); - diff --git a/scripts/create_rst_templates.sh b/scripts/create_rst_templates.sh index 931701ee..4d85b827 100755 --- a/scripts/create_rst_templates.sh +++ b/scripts/create_rst_templates.sh @@ -12,6 +12,8 @@ fi source ${QPACKAGE_ROOT}/scripts/qp_include.sh check_current_dir_is_module +MODULE=$(basename $PWD) + README="True" if [[ -f README.rst ]] diff --git a/scripts/docopt.py b/scripts/docopt.py new file mode 100755 index 00000000..59830d53 --- /dev/null +++ b/scripts/docopt.py @@ -0,0 +1,590 @@ +"""Pythonic command-line interface parser that will make you smile. + + * http://docopt.org + * Repository and issue-tracker: https://github.com/docopt/docopt + * Licensed under terms of MIT license (see LICENSE-MIT) + * Copyright (c) 2013 Vladimir Keleshev, vladimir@keleshev.com + +""" +import sys +import re + + +__all__ = ['docopt'] +__version__ = '0.6.1' + + +class DocoptLanguageError(Exception): + + """Error in construction of usage-message by developer.""" + + +class DocoptExit(SystemExit): + + """Exit in case user invoked program with incorrect arguments.""" + + usage = '' + + def __init__(self, message=''): + SystemExit.__init__(self, (message + '\n' + self.usage).strip()) + + +class Pattern(object): + + def __eq__(self, other): + return repr(self) == repr(other) + + def __hash__(self): + return hash(repr(self)) + + def fix(self): + self.fix_identities() + self.fix_repeating_arguments() + return self + + def fix_identities(self, uniq=None): + """Make pattern-tree tips point to same object if they are equal.""" + if not hasattr(self, 'children'): + return self + uniq = list(set(self.flat())) if uniq is None else uniq + for i, child in enumerate(self.children): + if not hasattr(child, 'children'): + assert child in uniq + self.children[i] = uniq[uniq.index(child)] + else: + child.fix_identities(uniq) + + def fix_repeating_arguments(self): + """Fix elements that should accumulate/increment values.""" + either = [list(child.children) for child in transform(self).children] + for case in either: + for e in [child for child in case if case.count(child) > 1]: + if isinstance( + e, + Argument) or isinstance( + e, + Option) and e.argcount: + if e.value is None: + e.value = [] + elif not isinstance(e.value, list): + e.value = e.value.split() + if isinstance( + e, + Command) or isinstance( + e, + Option) and e.argcount == 0: + e.value = 0 + return self + + +def transform(pattern): + """Expand pattern into an (almost) equivalent one, but with single Either. + + Example: ((-a | -b) (-c | -d)) => (-a -c | -a -d | -b -c | -b -d) + Quirks: [-a] => (-a), (-a...) => (-a -a) + + """ + result = [] + groups = [[pattern]] + while groups: + children = groups.pop(0) + parents = [Required, Optional, OptionsShortcut, Either, OneOrMore] + if any(t in map(type, children) for t in parents): + child = [c for c in children if type(c) in parents][0] + children.remove(child) + if isinstance(child, Either): + for c in child.children: + groups.append([c] + children) + elif isinstance(child, OneOrMore): + groups.append(child.children * 2 + children) + else: + groups.append(child.children + children) + else: + result.append(children) + return Either(*[Required(*e) for e in result]) + + +class LeafPattern(Pattern): + + """Leaf/terminal node of a pattern tree.""" + + def __init__(self, name, value=None): + self.name, self.value = name, value + + def __repr__(self): + return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.value) + + def flat(self, *types): + return [self] if not types or type(self) in types else [] + + def match(self, left, collected=None): + collected = [] if collected is None else collected + pos, match = self.single_match(left) + if match is None: + return False, left, collected + left_ = left[:pos] + left[pos + 1:] + same_name = [a for a in collected if a.name == self.name] + if type(self.value) in (int, list): + if isinstance(self.value, int): + increment = 1 + else: + increment = ([match.value] if isinstance(match.value, str) + else match.value) + if not same_name: + match.value = increment + return True, left_, collected + [match] + same_name[0].value += increment + return True, left_, collected + return True, left_, collected + [match] + + +class BranchPattern(Pattern): + + """Branch/inner node of a pattern tree.""" + + def __init__(self, *children): + self.children = list(children) + + def __repr__(self): + return '%s(%s)' % (self.__class__.__name__, + ', '.join(repr(a) for a in self.children)) + + def flat(self, *types): + if type(self) in types: + return [self] + return sum([child.flat(*types) for child in self.children], []) + + +class Argument(LeafPattern): + + def single_match(self, left): + for n, pattern in enumerate(left): + if isinstance(pattern, Argument): + return n, Argument(self.name, pattern.value) + return None, None + + @classmethod + def parse(class_, source): + name = re.findall('(<\S*?>)', source)[0] + value = re.findall('\[default: (.*)\]', source, flags=re.I) + return class_(name, value[0] if value else None) + + +class Command(Argument): + + def __init__(self, name, value=False): + self.name, self.value = name, value + + def single_match(self, left): + for n, pattern in enumerate(left): + if isinstance(pattern, Argument): + if pattern.value == self.name: + return n, Command(self.name, True) + else: + break + return None, None + + +class Option(LeafPattern): + + def __init__(self, short=None, long=None, argcount=0, value=False): + assert argcount in (0, 1) + self.short, self.long, self.argcount = short, long, argcount + self.value = None if value is False and argcount else value + + @classmethod + def parse(class_, option_description): + short, long, argcount, value = None, None, 0, False + options, _, description = option_description.strip().partition(' ') + options = options.replace(',', ' ').replace('=', ' ') + for s in options.split(): + if s.startswith('--'): + long = s + elif s.startswith('-'): + short = s + else: + argcount = 1 + if argcount: + matched = re.findall('\[default: (.*)\]', description, flags=re.I) + value = matched[0] if matched else None + return class_(short, long, argcount, value) + + def single_match(self, left): + for n, pattern in enumerate(left): + if self.name == pattern.name: + return n, pattern + return None, None + + @property + def name(self): + return self.long or self.short + + def __repr__(self): + return 'Option(%r, %r, %r, %r)' % (self.short, self.long, + self.argcount, self.value) + + +class Required(BranchPattern): + + def match(self, left, collected=None): + collected = [] if collected is None else collected + l = left + c = collected + for pattern in self.children: + matched, l, c = pattern.match(l, c) + if not matched: + return False, left, collected + return True, l, c + + +class Optional(BranchPattern): + + def match(self, left, collected=None): + collected = [] if collected is None else collected + for pattern in self.children: + m, left, collected = pattern.match(left, collected) + return True, left, collected + + +class OptionsShortcut(Optional): + + """Marker/placeholder for [options] shortcut.""" + + +class OneOrMore(BranchPattern): + + def match(self, left, collected=None): + assert len(self.children) == 1 + collected = [] if collected is None else collected + l = left + c = collected + l_ = None + matched = True + times = 0 + while matched: + # could it be that something didn't match but changed l or c? + matched, l, c = self.children[0].match(l, c) + times += 1 if matched else 0 + if l_ == l: + break + l_ = l + if times >= 1: + return True, l, c + return False, left, collected + + +class Either(BranchPattern): + + def match(self, left, collected=None): + collected = [] if collected is None else collected + outcomes = [] + for pattern in self.children: + matched, _, _ = outcome = pattern.match(left, collected) + if matched: + outcomes.append(outcome) + if outcomes: + return min(outcomes, key=lambda outcome: len(outcome[1])) + return False, left, collected + + +class Tokens(list): + + def __init__(self, source, error=DocoptExit): + self += source.split() if hasattr(source, 'split') else source + self.error = error + + @staticmethod + def from_pattern(source): + source = re.sub(r'([\[\]\(\)\|]|\.\.\.)', r' \1 ', source) + source = [s for s in re.split('\s+|(\S*<.*?>)', source) if s] + return Tokens(source, error=DocoptLanguageError) + + def move(self): + return self.pop(0) if len(self) else None + + def current(self): + return self[0] if len(self) else None + + +def parse_long(tokens, options): + """long ::= '--' chars [ ( ' ' | '=' ) chars ] ;""" + long, eq, value = tokens.move().partition('=') + assert long.startswith('--') + value = None if eq == value == '' else value + similar = [o for o in options if o.long == long] + if tokens.error is DocoptExit and similar == []: # if no exact match + similar = [o for o in options if o.long and o.long.startswith(long)] + if len(similar) > 1: # might be simply specified ambiguously 2+ times? + raise tokens.error('%s is not a unique prefix: %s?' % + (long, ', '.join(o.long for o in similar))) + elif len(similar) < 1: + argcount = 1 if eq == '=' else 0 + o = Option(None, long, argcount) + options.append(o) + if tokens.error is DocoptExit: + o = Option(None, long, argcount, value if argcount else True) + else: + o = Option(similar[0].short, similar[0].long, + similar[0].argcount, similar[0].value) + if o.argcount == 0: + if value is not None: + raise tokens.error('%s must not have an argument' % o.long) + else: + if value is None: + if tokens.current() in [None, '--']: + raise tokens.error('%s requires argument' % o.long) + value = tokens.move() + if tokens.error is DocoptExit: + o.value = value if value is not None else True + return [o] + + +def parse_shorts(tokens, options): + """shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;""" + token = tokens.move() + assert token.startswith('-') and not token.startswith('--') + left = token.lstrip('-') + parsed = [] + while left != '': + short, left = '-' + left[0], left[1:] + similar = [o for o in options if o.short == short] + if len(similar) > 1: + raise tokens.error('%s is specified ambiguously %d times' % + (short, len(similar))) + elif len(similar) < 1: + o = Option(short, None, 0) + options.append(o) + if tokens.error is DocoptExit: + o = Option(short, None, 0, True) + else: # why copying is necessary here? + o = Option(short, similar[0].long, + similar[0].argcount, similar[0].value) + value = None + if o.argcount != 0: + if left == '': + if tokens.current() in [None, '--']: + raise tokens.error('%s requires argument' % short) + value = tokens.move() + else: + value = left + left = '' + if tokens.error is DocoptExit: + o.value = value if value is not None else True + parsed.append(o) + return parsed + + +def parse_pattern(source, options): + tokens = Tokens.from_pattern(source) + result = parse_expr(tokens, options) + if tokens.current() is not None: + raise tokens.error('unexpected ending: %r' % ' '.join(tokens)) + return Required(*result) + + +def parse_expr(tokens, options): + """expr ::= seq ( '|' seq )* ;""" + seq = parse_seq(tokens, options) + if tokens.current() != '|': + return seq + result = [Required(*seq)] if len(seq) > 1 else seq + while tokens.current() == '|': + tokens.move() + seq = parse_seq(tokens, options) + result += [Required(*seq)] if len(seq) > 1 else seq + return [Either(*result)] if len(result) > 1 else result + + +def parse_seq(tokens, options): + """seq ::= ( atom [ '...' ] )* ;""" + result = [] + while tokens.current() not in [None, ']', ')', '|']: + atom = parse_atom(tokens, options) + if tokens.current() == '...': + atom = [OneOrMore(*atom)] + tokens.move() + result += atom + return result + + +def parse_atom(tokens, options): + """atom ::= '(' expr ')' | '[' expr ']' | 'options' + | long | shorts | argument | command ; + """ + token = tokens.current() + result = [] + if token in '([': + tokens.move() + matching, pattern = {'(': [')', Required], '[': [']', Optional]}[token] + result = pattern(*parse_expr(tokens, options)) + if tokens.move() != matching: + raise tokens.error("unmatched '%s'" % token) + return [result] + elif token == 'options': + tokens.move() + return [OptionsShortcut()] + elif token.startswith('--') and token != '--': + return parse_long(tokens, options) + elif token.startswith('-') and token not in ('-', '--'): + return parse_shorts(tokens, options) + elif token.startswith('<') and token.endswith('>') or token.isupper(): + return [Argument(tokens.move())] + else: + return [Command(tokens.move())] + + +def parse_argv(tokens, options, options_first=False): + """Parse command-line argument vector. + + If options_first: + argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ; + else: + argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ; + + """ + parsed = [] + while tokens.current() is not None: + if tokens.current() == '--': + return parsed + [Argument(None, v) for v in tokens] + elif tokens.current().startswith('--'): + parsed += parse_long(tokens, options) + elif tokens.current().startswith('-') and tokens.current() != '-': + parsed += parse_shorts(tokens, options) + elif options_first: + return parsed + [Argument(None, v) for v in tokens] + else: + parsed.append(Argument(None, tokens.move())) + return parsed + + +def parse_defaults(doc): + defaults = [] + for s in parse_section('options:', doc): + # FIXME corner case "bla: options: --foo" + _, _, s = s.partition(':') # get rid of "options:" + split = re.split('\n[ \t]*(-\S+?)', '\n' + s)[1:] + split = [s1 + s2 for s1, s2 in zip(split[::2], split[1::2])] + options = [Option.parse(s) for s in split if s.startswith('-')] + defaults += options + return defaults + + +def parse_section(name, source): + pattern = re.compile('^([^\n]*' + name + '[^\n]*\n?(?:[ \t].*?(?:\n|$))*)', + re.IGNORECASE | re.MULTILINE) + return [s.strip() for s in pattern.findall(source)] + + +def formal_usage(section): + _, _, section = section.partition(':') # drop "usage:" + pu = section.split() + return '( ' + ' '.join(') | (' if s == pu[0] else s for s in pu[1:]) + ' )' + + +def extras(help, version, options, doc): + if help and any((o.name in ('-h', '--help')) and o.value for o in options): + print(doc.strip("\n")) + sys.exit() + if version and any(o.name == '--version' and o.value for o in options): + print(version) + sys.exit() + + +class Dict(dict): + + def __repr__(self): + return '{%s}' % ',\n '.join('%r: %r' % i for i in sorted(self.items())) + + +def docopt(doc, argv=None, help=True, version=None, options_first=False): + """Parse `argv` based on command-line interface described in `doc`. + + `docopt` creates your command-line interface based on its + description that you pass as `doc`. Such description can contain + --options, , commands, which could be + [optional], (required), (mutually | exclusive) or repeated... + + Parameters + ---------- + doc : str + Description of your command-line interface. + argv : list of str, optional + Argument vector to be parsed. sys.argv[1:] is used if not + provided. + help : bool (default: True) + Set to False to disable automatic help on -h or --help + options. + version : any object + If passed, the object will be printed if --version is in + `argv`. + options_first : bool (default: False) + Set to True to require options precede positional arguments, + i.e. to forbid options and positional arguments intermix. + + Returns + ------- + args : dict + A dictionary, where keys are names of command-line elements + such as e.g. "--verbose" and "", and values are the + parsed values of those elements. + + Example + ------- + >>> from docopt import docopt + >>> doc = ''' + ... Usage: + ... my_program tcp [--timeout=] + ... my_program serial [--baud=] [--timeout=] + ... my_program (-h | --help | --version) + ... + ... Options: + ... -h, --help Show this screen and exit. + ... --baud= Baudrate [default: 9600] + ... ''' + >>> argv = ['tcp', '127.0.0.1', '80', '--timeout', '30'] + >>> docopt(doc, argv) + {'--baud': '9600', + '--help': False, + '--timeout': '30', + '--version': False, + '': '127.0.0.1', + '': '80', + 'serial': False, + 'tcp': True} + + See also + -------- + * For video introduction see http://docopt.org + * Full documentation is available in README.rst as well as online + at https://github.com/docopt/docopt#readme + + """ + argv = sys.argv[1:] if argv is None else argv + + usage_sections = parse_section('usage:', doc) + if len(usage_sections) == 0: + raise DocoptLanguageError('"usage:" (case-insensitive) not found.') + if len(usage_sections) > 1: + raise DocoptLanguageError('More than one "usage:" (case-insensitive).') + DocoptExit.usage = usage_sections[0] + + options = parse_defaults(doc) + pattern = parse_pattern(formal_usage(DocoptExit.usage), options) + # [default] syntax for argument is disabled + # for a in pattern.flat(Argument): + # same_name = [d for d in arguments if d.name == a.name] + # if same_name: + # a.value = same_name[0].value + argv = parse_argv(Tokens(argv), list(options), options_first) + pattern_options = set(pattern.flat(Option)) + for options_shortcut in pattern.flat(OptionsShortcut): + doc_options = parse_defaults(doc) + options_shortcut.children = list(set(doc_options) - pattern_options) + # if any_options: + # options_shortcut.children += [Option(o.short, o.long, o.argcount) + # for o in argv if type(o) is Option] + extras(help, version, argv, doc) + matched, left, collected = pattern.fix().match(argv) + if matched and left == []: # better error message if left? + return Dict((a.name, a.value) for a in (pattern.flat() + collected)) + raise DocoptExit() diff --git a/scripts/ezfio_interface.py b/scripts/ezfio_interface.py deleted file mode 100755 index 7c196cf8..00000000 --- a/scripts/ezfio_interface.py +++ /dev/null @@ -1,333 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -""" -Take a path in argv -Check if EZFIO.cfg exists. -EZFIO.cfg are in MODULE directories. -create : ezfio_interface.irp.f - folder_ezfio_inteface_config - -Example EZFIO.cfg: -``` -[thresh_SCF] -doc: Threshold on the convergence of the Hartree Fock energy -type: Threshold -default: 1.e-10 - -[do_pt2_end] -type: logical -doc: If true, compute the PT2 at the end of the selection -default: true -``` - -""" - -import sys -import os -import os.path - -import ConfigParser - -from collections import defaultdict -from collections import namedtuple - -Type = namedtuple('Type', 'ocaml fortran') -def bool_convertor(b): - return ( b.lower() in [ "true", ".true." ] ) - - -def get_type_dict(): - """ - This function makes the correspondance between the type of value read in - ezfio.cfg into the f90 and Ocam Type - return fancy_type[fancy_type] = namedtuple('Type', 'ocaml fortran') - For example fancy_type['Ndet'].fortran = interger - .ocaml = int - """ - - # ~#~#~#~ # - # I n i t # - # ~#~#~#~ # - - # Dict to change ocaml LowLevel type into FortranLowLevel type - ocaml_to_fortran = {"int": "integer", - "float": "double precision", - "logical": "logical", - "string": "character*60"} - - fancy_type = defaultdict(dict) - - # ~#~#~#~#~#~#~#~ # - # R a w _ t y p e # - # ~#~#~#~#~#~#~#~ # - - fancy_type['integer'] = Type("int", "integer") - fancy_type['int'] = Type("int", "integer") - - fancy_type['float'] = Type("float", "double precision") - fancy_type['double precision'] = Type("float", "double precision") - - fancy_type['logical'] = Type("bool", "logical") - fancy_type['bool'] = Type("bool", "logical") - - # ~#~#~#~#~#~#~#~ # - # q p _ t y p e s # - # ~#~#~#~#~#~#~#~ # - - src = os.environ['QPACKAGE_ROOT'] + "/ocaml/qptypes_generator.ml" - - with open(src, "r") as f: - l = [i for i in f.read().splitlines() if i.strip().startswith("*")] - - for i in l: - ocaml_fancy_type = i.split()[1].strip() - ocaml_type = i.split()[3] - fortran_type = ocaml_to_fortran[ocaml_type] - - fancy_type[ocaml_fancy_type] = Type(ocaml_type, fortran_type) - - return dict(fancy_type) - - -type_dict = get_type_dict() - - -def get_dict_config_file(config_file_path, module_lower): - """ - Input: - config_file_path is the config file path - (for example FULL_PATH/EZFIO.cfg) - module_lower is the MODULE name lowered - (Ex fullci) - - Return a dict d[provider_name] = {type, - doc, - ezfio_name, - ezfio_dir, - interface, - default} - - Type : Is a fancy_type named typle who containt fortran and ocaml type - doc : Is the doc - ezfio_name : Will be the name of the file - ezfio_dir : Will be the folder who containt the ezfio_name - * /ezfio_dir/ezfio_name - * equal to MODULE_lower name for the moment. - interface : The provider is a imput or a output - if is a output: - default : The default value - - """ - # ~#~#~#~ # - # I n i t # - # ~#~#~#~ # - - d = defaultdict(dict) - l_info_required = ["doc", "interface"] - l_info_optional = ["ezfio_name"] - - # ~#~#~#~#~#~#~#~#~#~#~ # - # L o a d _ C o n f i g # - # ~#~#~#~#~#~#~#~#~#~#~ # - - config_file = ConfigParser.ConfigParser() - config_file.readfp(open(config_file_path)) - - # ~#~#~#~#~#~#~#~#~ # - # F i l l _ d i c t # - # ~#~#~#~#~#~#~#~#~ # - - def error(o, p, c): - "o option ; p provider_name ;c config_file_path" - print "You need a {0} for {1} in {2}".format(o, p, c) - - for section in config_file.sections(): - # pvd = provider - pvd = section.lower() - - # Create the dictionary who containt the value per default - d_default = {"ezfio_name": pvd} - - # Set the ezfio_dir - d[pvd]["ezfio_dir"] = module_lower - - # Check if type if avalaible - type_ = config_file.get(section, "type") - if type_ not in type_dict: - print "{0} not avalaible. Choose in:".format(type_) - print ", ".join([i for i in type_dict]) - sys.exit(1) - else: - d[pvd]["type"] = type_dict[type_] - - # Fill the dict with REQUIRED information - for option in l_info_required: - try: - d[pvd][option] = config_file.get(section, option) - except ConfigParser.NoOptionError: - error(option, pvd, config_file_path) - sys.exit(1) - - # Fill the dict with OPTIONAL information - for option in l_info_optional: - try: - d[pvd][option] = config_file.get(section, option).lower() - except ConfigParser.NoOptionError: - d[pvd][option] = d_default[option] - - # If interface is output we need a default value information - if d[pvd]["interface"] == "input": - try: - d[pvd]["default"] = config_file.get(section, "default") - except ConfigParser.NoOptionError: - error("default", pvd, config_file_path) - sys.exit(1) - - return dict(d) - - -def create_ezfio_provider(dict_ezfio_cfg): - """ - From dict d[provider_name] = {type, - doc, - ezfio_name, - ezfio_dir, - interface, - default} - create the a list who containt all the code for the provider - return [code, ...] - """ - from ezfio_with_default import EZFIO_Provider - - dict_code_provider = dict() - - ez_p = EZFIO_Provider() - for provider_name, dict_info in dict_ezfio_cfg.iteritems(): - if "default" in dict_info: - ez_p.set_type(dict_info['type'].fortran) - ez_p.set_name(provider_name) - ez_p.set_doc(dict_info['doc']) - ez_p.set_ezfio_dir(dict_info['ezfio_dir']) - ez_p.set_ezfio_name(dict_info['ezfio_name']) - ez_p.set_default(dict_info['default']) - ez_p.set_output("output_%s" % dict_info['ezfio_dir']) - - dict_code_provider[provider_name] = str(ez_p) - - return dict_code_provider - - -def save_ezfio_provider(path_head, dict_code_provider): - """ - Write in path_head/"ezfio_interface.irp.f" the value of dict_code_provider - """ - - path = "{0}/ezfio_interface.irp.f".format(path_head) - -# print "Path = {}".format(path) - - try: - f = open(path, "r") - except IOError: - old_output = "" - else: - old_output = f.read() - f.close() - - output = "! DO NOT MODIFY BY HAND\n" + \ - "! Created by $QPACKAGE_ROOT/scripts/ezfio_interface.py\n" + \ - "! from file {0}/EZFIO.cfg\n".format(path_head) + \ - "\n" - for provider_name, code in dict_code_provider.iteritems(): - output += str(code) + "\n" - - if output != old_output: - with open(path, "w") as f: - f.write(output) - - -def create_ezfio_config(dict_ezfio_cfg, opt, module_lower): - """ - From dict_ezfio_cfg[provider_name] = {type, default, ezfio_name,ezfio_dir,doc} - Return the string ezfio_interface_config - """ - - result = [module_lower] - lenmax = max([len(i) for i in dict_ezfio_cfg]) + 2 - l = sorted(dict_ezfio_cfg.keys()) - for provider_name in l: - provider_info = dict_ezfio_cfg[provider_name] - s = " {0} {1}".format( - provider_name.lower().ljust(lenmax), - provider_info["type"].fortran) - result.append(s) - return "\n".join(result) - - -def save_ezfio_config(module_lower, str_ezfio_config): - """ - Write the str_ezfio_config in - $QPACKAGE_ROOT/EZFIO/{0}.ezfio_interface_config".format(module_lower) - """ - - ezfio_dir = "{0}/EZFIO".format(os.environ['QPACKAGE_ROOT']) - path = "{0}/config/{1}.ezfio_interface_config".format(ezfio_dir, - module_lower) - -# print "Path = {}".format(path) - - try: - f = open(path, "r") - except IOError: - old_output = "" - else: - old_output = f.read() - f.close() - - if str_ezfio_config != old_output: - with open(path, "w") as f: - f.write(str_ezfio_config) - - -def main(): - """ - Two condition: - -Take the EZFIO.cfg path in arg - or - -Look if EZFIO.cfg is present in the pwd - """ - - try: - config_file_path = sys.argv[1] - except: - config_file_path = "EZFIO.cfg" - if "EZFIO.cfg" not in os.listdir(os.getcwd()): - sys.exit(0) - - config_file_path = os.path.expanduser(config_file_path) - config_file_path = os.path.expandvars(config_file_path) - config_file_path = os.path.abspath(config_file_path) -# print config_file_path - - path_dirname = os.path.dirname(config_file_path) - module = [i for i in path_dirname.split("/") if i][-1] - module_lower = module.lower() - -# print "Read {0}".format(config_file_path) - dict_info_provider = get_dict_config_file(config_file_path, module_lower) - -# print "Generating the ezfio_interface.irp.f: \n" - d_config = create_ezfio_provider(dict_info_provider) - -# print "Saving the ezfio_interface.irp.f" - save_ezfio_provider(path_dirname, d_config) - -# print "Generating the ezfio_config" - config_ezfio = create_ezfio_config(dict_info_provider, "config", module_lower) - -# print "Saving ezfio_config" - save_ezfio_config(module_lower, config_ezfio) - - -if __name__ == "__main__": - main() diff --git a/scripts/ezfio_interface/convert_ezfio.sh b/scripts/ezfio_interface/convert_ezfio.sh new file mode 100755 index 00000000..ec0ab770 --- /dev/null +++ b/scripts/ezfio_interface/convert_ezfio.sh @@ -0,0 +1,27 @@ +#!/bin/bash +# Convert a old ezfio file (with option.irp.f ezfio_default) +# into a new EZFIO.cfg type + +# Hartree Fock +# Changin the case, don't know if is needed or not +mv $1/Hartree_Fock $1/hartree_fock 2> /dev/null + +mv $1/hartree_Fock/thresh_SCF $1/hartree_fock/thresh_scf 2> /dev/null + +# BiInts +mv $1/bi_integrals $1/bielect_integrals 2> /dev/null + +if [ -f $1/bielect_integrals/read_ao_integrals ]; then + if [ `cat $1/bielect_integrals/read_ao_integrals` -eq "True" ] + then + echo "Read" > $1/bielect_integrals/disk_access_ao_integrals + + elif [ `cat bielect_integrals/write_ao_integrals` -eq "True" ] + then + echo "Write" > $1/bielect_integrals/disk_access_ao_integrals + + else + echo "None" > $1/bielect_integrals/disk_access_ao_integrals + + fi +fi \ No newline at end of file diff --git a/scripts/ezfio_interface/ei_handler.py b/scripts/ezfio_interface/ei_handler.py new file mode 100755 index 00000000..91682f9e --- /dev/null +++ b/scripts/ezfio_interface/ei_handler.py @@ -0,0 +1,823 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Welcom the ei_handler. +We will create all the ezfio related stuff from a EZFIO.cfg file. + +Usage: + ei_handler.py [--path] [--irpf90] [--ezfio_config] [--ocaml] [--ezfio_default] [--global] + +By default all the option are executed. + +Options: + -h --help + --path The path of the `EZFIO.cfg`, by default will look in the ${pwd} + --irpf90 Create the `ezfio_interface.irpf90` + which contains all the providers needed + (aka all with the `interface: input` parameter) + in `${pwd}` + --ezfio_config Create the `${module_lower}_ezfio_interface_config` in + `${QPACKAGE_ROOT}/EZFIO/config/` + This file is needed by *EZFIO* to create the `libezfio.so` + --ocaml Create the `Input_module.lower.ml` for the *qp_edit* + --ezfio_default Create the `${module_lower}_ezfio_interface_default` in + `${QPACKAGE_ROOT}/data/ezfio_defaults` needed by + the ocaml + --global Create all the stuff who need all the EZFIO.cfg + +Format specification : + [provider_name] | the name of the provider in irp.f90 + doc:{str} | Is the doc + Type:{str} | Is a fancy_type supported by the ocaml + ezfio_name:{str} | Will be the name of the file for the ezfio + (optional by default is the name of the provider) + interface:{str} | The provider is a imput or a output + default:{str} | The default value if interface == input: + size:{str} | the size information + (like 1 or =sum(ao_num) or (ao_num,3) ) + +Example of EZFIO.cfg: +``` +[thresh_SCF] +doc: Threshold on the convergence of the Hartree Fock energy +type: Threshold +default: 1.e-10 +interface: input +size: 1 + +[energy] +type: double precision +doc: Calculated HF energy +interface: output +``` +""" +from docopt import docopt + +import sys +import os +import os.path + +import ConfigParser + +from collections import defaultdict +from collections import namedtuple + +Type = namedtuple('Type', 'fancy ocaml fortran') + + +def is_bool(str_): + """ + Take a string, if is a bool return the conversion into + fortran and ocaml. + """ + if str_.lower() in ['true', '.true.']: + return Type(None, "true", ".True.") + elif str_.lower() in ['false', '.false.']: + return Type(None, "false", ".False") + else: + raise TypeError + + +def get_type_dict(): + """ + This function makes the correspondance between the type of value read in + ezfio.cfg into the f90 and Ocaml Type + return fancy_type[fancy_type] = namedtuple('Type', 'ocaml fortran') + For example fancy_type['Ndet'].fortran = interger + .ocaml = int + """ + # ~#~#~#~#~ # + # P i c l e # + # ~#~#~#~#~ # + + import cPickle as pickle + + from os import listdir + + qpackage_root = os.environ['QPACKAGE_ROOT'] + fancy_type_pickle = qpackage_root + "/scripts/ezfio_interface/fancy_type.p" + + if fancy_type_pickle in listdir(os.getcwd()): + fancy_type = pickle.load(open(fancy_type_pickle, "rb")) + return fancy_type + + # ~#~#~#~ # + # I n i t # + # ~#~#~#~ # + + fancy_type = defaultdict(dict) + + # ~#~#~#~#~#~#~#~ # + # R a w _ t y p e # + # ~#~#~#~#~#~#~#~ # + + fancy_type['integer'] = Type(None, "int", "integer") + fancy_type['int'] = Type(None, "int", "integer") + + fancy_type['float'] = Type(None, "float", "double precision") + fancy_type['double precision'] = Type(None, "float", "double precision") + + fancy_type['logical'] = Type(None, "bool", "logical") + fancy_type['bool'] = Type(None, "bool", "logical") + + fancy_type['character*(32)'] = Type(None, "string", "character*(32)") + fancy_type['character*(60)'] = Type(None, "string", "character*(60)") + fancy_type['character*(256)'] = Type(None, "string", "character*(256)") + + # ~#~#~#~#~#~#~#~ # + # q p _ t y p e s # + # ~#~#~#~#~#~#~#~ # + + # Dict to change ocaml LowLevel type into FortranLowLevel type + ocaml_to_fortran = {"int": "integer", + "float": "double precision", + "logical": "logical", + "string": "character*32"} + + # Read and parse qptype generate + src = qpackage_root + "/ocaml/qptypes_generator.ml" + with open(src, "r") as f: + r = f.read() + + # Generate + l_gen = [i for i in r.splitlines() if i.strip().startswith("*")] + + # Untouch + b = r.find('let untouched = "') + e = r.find(';;', b) + + l_un = [ + i for i in r[ + b:e].splitlines() if i.strip().startswith("module")] + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~ # + # q p _ t y p e s _ g e n e r a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~ # + + # Read the fancy_type, the ocaml. and convert the ocaml to the fortran + for i in l_gen + l_un: + str_fancy_type = i.split()[1].strip() + str_ocaml_type = i.split()[3] + + if str_ocaml_type != 'sig': + str_fortran_type = ocaml_to_fortran[str_ocaml_type] + else: + str_fortran_type = 'character*(32)' + str_ocaml_type = 'string' + + fancy_type[str_fancy_type] = Type(str_fancy_type, + str_ocaml_type, + str_fortran_type) + + # ~#~#~#~#~#~#~#~ # + # F i n a l i z e # + # ~#~#~#~#~#~#~#~ # + + pickle.dump(dict(fancy_type), open(fancy_type_pickle, "wb")) + + return dict(fancy_type) + + +type_dict = get_type_dict() + + +def get_dict_config_file(config_file_path, module_lower): + """ + Input: + config_file_path is the config file path + (for example FULL_PATH/EZFIO.cfg) + module_lower is the MODULE name lowered + (Ex fullci) + + Return a dict d[provider_name] = {type, + doc, + ezfio_name, + ezfio_dir, + size, + interface, + default} + + - Type : Is a Type named tuple who containt + fortran and ocaml type + - doc : Is the doc + - ezfio_name : Will be the name of the file + - ezfio_dir : Will be the folder who containt the ezfio_name + * /ezfio_dir/ezfio_name + * equal to MODULE_lower name for the moment. + - interface : The provider is a imput or a output + - default : The default value /!\ stored in a Type named type! + if interface == output + - size : Is the string read in ezfio.cgf who containt the size information + (like 1 or =sum(ao_num)) + """ + # ~#~#~#~ # + # I n i t # + # ~#~#~#~ # + + d = defaultdict(dict) + l_info_required = ["doc", "interface"] + l_info_optional = ["ezfio_name", "size"] + + # ~#~#~#~#~#~#~#~#~#~#~ # + # L o a d _ C o n f i g # + # ~#~#~#~#~#~#~#~#~#~#~ # + + config_file = ConfigParser.ConfigParser() + config_file.readfp(open(config_file_path)) + + # ~#~#~#~#~#~#~#~#~ # + # F i l l _ d i c t # + # ~#~#~#~#~#~#~#~#~ # + + def error(o, p, c): + "o option ; p provider_name ;c config_file_path" + print "You need a {0} for {1} in {2}".format(o, p, c) + + for section in config_file.sections(): + # pvd = provider + pvd = section.lower() + + # Create the dictionary who containt the value per default + d_default = {"ezfio_name": pvd} + + # Set the ezfio_dir + d[pvd]["ezfio_dir"] = module_lower + + # Check if type if avalaible + type_ = config_file.get(section, "type") + if type_ not in type_dict: + print "{0} not avalaible. Choose in:".format(type_) + print ", ".join(sorted([i for i in type_dict])) + sys.exit(1) + else: + d[pvd]["type"] = type_dict[type_] + + # Fill the dict with REQUIRED information + for option in l_info_required: + try: + d[pvd][option] = config_file.get(section, option) + except ConfigParser.NoOptionError: + error(option, pvd, config_file_path) + sys.exit(1) + + # Fill the dict with OPTIONAL information + for option in l_info_optional: + try: + d[pvd][option] = config_file.get(section, option).lower() + except ConfigParser.NoOptionError: + if option in d_default: + d[pvd][option] = d_default[option] + + # If interface is input we need a default value information + if d[pvd]["interface"] == "input": + try: + default_raw = config_file.get(section, "default") + except ConfigParser.NoOptionError: + error("default", pvd, config_file_path) + sys.exit(1) + + try: + d[pvd]["default"] = is_bool(default_raw) + except TypeError: + d[pvd]["default"] = Type(None, default_raw, default_raw) + + return dict(d) + + +def create_ezfio_provider(dict_ezfio_cfg): + """ + From dict d[provider_name] = {type, + doc, + ezfio_name, + ezfio_dir, + interface, + default + size} + create the a list who containt all the code for the provider + return [code, ...] + """ + from ezfio_generate_provider import EZFIO_Provider + dict_code_provider = dict() + + ez_p = EZFIO_Provider() + for provider_name, dict_info in dict_ezfio_cfg.iteritems(): + if "default" in dict_info: + ez_p.set_type(dict_info['type'].fortran) + ez_p.set_name(provider_name) + ez_p.set_doc(dict_info['doc']) + ez_p.set_ezfio_dir(dict_info['ezfio_dir']) + ez_p.set_ezfio_name(dict_info['ezfio_name']) + ez_p.set_output("output_%s" % dict_info['ezfio_dir']) + + dict_code_provider[provider_name] = str(ez_p) + "\n" + + return dict_code_provider + + +def save_ezfio_provider(path_head, dict_code_provider): + """ + Write in path_head/"ezfio_interface.irp.f" the value of dict_code_provider + """ + + path = "{0}/ezfio_interface.irp.f".format(path_head) + + try: + f = open(path, "r") + except IOError: + old_output = "" + else: + old_output = f.read() + f.close() + + l_output = ["! DO NOT MODIFY BY HAND", + "! Created by $QPACKAGE_ROOT/scripts/ezfio_interface.py", + "! from file {0}/EZFIO.cfg".format(path_head), + "\n"] + + l_output += [code for code in dict_code_provider.values()] + + output = "\n".join(l_output) + + if output != old_output: + with open(path, "w+") as f: + f.write(output) + + +def create_ezfio_stuff(dict_ezfio_cfg, config_or_default="config"): + """ + From dict_ezfio_cfg[provider_name] = {type, default, ezfio_name,ezfio_dir,doc} + Return the string ezfio_interface_config + """ + + def size_format_to_ezfio(size_raw): + """ + If size_raw == "=" is a formula -> do nothing; return + If the value are between parenthses -> do nothing; return + Else put it in parenthsesis + """ + + size_raw = str(size_raw) + if any([size_raw.startswith('='), + size_raw.startswith("(") and size_raw.endswith(")")]): + size_convert = size_raw + else: + size_convert = "({0})".format(size_raw) + return size_convert + + def create_format_string(size): + """ + Take a size number and + return the string format for being right align with this offset + """ + return "{{0:<{0}}}".format(size).format + + # ~#~#~#~#~#~#~#~#~#~#~# # + # F o r m a t _ i n f o # + # ~#~#~#~#~#~#~#~#~#~#~# # + + lenmax_name = max([len(i) for i in dict_ezfio_cfg]) + lenmax_type = max([len(i["type"].fortran) + for i in dict_ezfio_cfg.values()]) + + str_name_format = create_format_string(lenmax_name + 2) + str_type_format = create_format_string(lenmax_type + 2) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t h e _ s t r i n g # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + # Checking is many ezfio_dir provided + l_ezfio_dir = [d['ezfio_dir'] for d in dict_ezfio_cfg.values()] + + if not l_ezfio_dir.count(l_ezfio_dir[0]) == len(l_ezfio_dir): + print >> sys.stderr, "You have many ezfio_dir. Not supported yet" + raise TypeError + else: + result = [l_ezfio_dir[0]] + + for provider_name, provider_info in sorted(dict_ezfio_cfg.iteritems()): + + # Get the value from dict + name_raw = provider_info["ezfio_name"].lower() + + fortran_type_raw = provider_info["type"].fortran + + if "size" in provider_info and not provider_info["size"] == "1": + size_raw = provider_info["size"] + else: + size_raw = None + + # It is the last so we don't need to right align it + str_size = size_format_to_ezfio(size_raw) if size_raw else "" + + # Get the string in to good format (left align and co) + str_name = str_name_format(name_raw) + str_fortran_type = str_type_format(fortran_type_raw) + + # Return the string + if config_or_default == "config": + s = " {0} {1} {2}".format(str_name, str_fortran_type, str_size) + elif config_or_default == "default": + try: + str_value = provider_info["default"].ocaml + except KeyError: + continue + else: + s = " {0} {1}".format(str_name, str_value) + else: + raise KeyError + # Append + result.append(s) + + return "\n".join(result) + + +def create_ezfio_config(dict_ezfio_cfg): + return create_ezfio_stuff(dict_ezfio_cfg, + config_or_default="config") + + +def save_ezfio_config(module_lower, str_ezfio_config): + """ + Write the str_ezfio_config in + "$QPACKAGE_ROOT/EZFIO/{0}.ezfio_interface_config".format(module_lower) + """ + + root_ezfio = "{0}/EZFIO".format(os.environ['QPACKAGE_ROOT']) + path = "{0}/config/{1}.ezfio_interface_config".format(root_ezfio, + module_lower) + + try: + f = open(path, "r") + except IOError: + old_output = "" + else: + old_output = f.read() + f.close() + + if str_ezfio_config != old_output: + with open(path, "w+") as f: + f.write(str_ezfio_config) + + +def create_ezfio_default(dict_ezfio_cfg): + return create_ezfio_stuff(dict_ezfio_cfg, + config_or_default="default") + + +def save_ezfio_default(module_lower, str_ezfio_default): + """ + Write the str_ezfio_config in + "$QPACKAGE_ROOT/data/ezfio_defaults/{0}.ezfio_interface_default".format(module_lower) + """ + + root_ezfio_default = "{0}/data/ezfio_defaults/".format( + os.environ['QPACKAGE_ROOT']) + path = "{0}/{1}.ezfio_interface_default".format(root_ezfio_default, + module_lower) + + try: + f = open(path, "r") + except IOError: + old_output = "" + else: + old_output = f.read() + f.close() + + if str_ezfio_default != old_output: + with open(path, "w+") as f: + f.write(str_ezfio_default) + + +def create_ocaml_input(dict_ezfio_cfg, module_lower): + + # ~#~#~#~# # + # I n i t # + # ~#~#~#~# # + + from ezfio_generate_ocaml import EZFIO_ocaml + + l_ezfio_name = [] + l_type = [] + l_doc = [] + + for k, v in dict_ezfio_cfg.iteritems(): + if v['interface'] == "input": + l_ezfio_name.append(v['ezfio_name']) + l_type.append(v["type"]) + l_doc.append(v["doc"]) + + if not l_ezfio_name: + raise ValueError + + e_glob = EZFIO_ocaml(l_ezfio_name=l_ezfio_name, + l_type=l_type, + l_doc=l_doc) + + # ~#~#~#~#~#~#~#~# # + # C r e a t i o n # + # ~#~#~#~#~#~#~#~# # + + template = ['(* =~=~ *)', + '(* Init *)', + '(* =~=~ *)', + ""] + + template += ["open Qptypes;;", + "open Qputils;;", + "open Core.Std;;", + "", + "module {0} : sig".format(module_lower.capitalize())] + + template += [e_glob.create_type()] + + template += [" val read : unit -> t option", + " val write : t-> unit", + " val to_string : t -> string", + " val to_rst : t -> Rst_string.t", + " val of_rst : Rst_string.t -> t option", + "end = struct"] + + template += [e_glob.create_type()] + + template += ['', + ' let get_default = Qpackage.get_ezfio_default "{0}";;'.format(module_lower), + ''] + + template += ['(* =~=~=~=~=~=~==~=~=~=~=~=~ *)', + '(* Generate Special Function *)', + '(* =~=~=~==~=~~=~=~=~=~=~=~=~ *)', + ""] + + for provider_name, d_val in sorted(dict_ezfio_cfg.iteritems()): + + if 'default' not in d_val: + continue + + ezfio_dir = d_val["ezfio_dir"] + ezfio_name = d_val["ezfio_name"] + + e = EZFIO_ocaml(ezfio_dir=ezfio_dir, + ezfio_name=ezfio_name, + type=d_val["type"]) + + template += [e.create_read(), + e.create_write(), + ""] + + template += ['(* =~=~=~=~=~=~=~=~=~=~=~=~ *)', + '(* Generate Global Function *)', + '(* =~=~=~=~=~=~=~=~=~=~=~=~ *)', + ""] + + template += [e_glob.create_read_global(), + e_glob.create_write_global(), + e_glob.create_to_string(), + e_glob.create_to_rst()] + + template += [" include Generic_input_of_rst;;", + " let of_rst = of_rst t_of_sexp;;", + "", + "end"] + + return "\n".join(template) + + +def save_ocaml_input(module_lower, str_ocaml_input): + """ + Write the str_ocaml_input in + $QPACKAGE_ROOT/ocaml/Input_{0}.ml".format(module_lower) + """ + + path = "{0}/ocaml/Input_{1}.ml".format(os.environ['QPACKAGE_ROOT'], + module_lower) + + try: + f = open(path, "r") + except IOError: + old_output = "" + else: + old_output = f.read() + f.close() + + if str_ocaml_input != old_output: + with open(path, "w+") as f: + f.write(str_ocaml_input) + + +def get_l_module_lower(): + """ + Get all module who have EZFIO.cfg with input data + (NB `search` in all the ligne and `match` only in one) + """ + + # ~#~#~#~ # + # I n i t # + # ~#~#~#~ # + + mypath = "{0}/src".format(os.environ['QPACKAGE_ROOT']) + + # ~#~#~#~#~#~#~#~ # + # L _ f o l d e r # + # ~#~#~#~#~#~#~#~ # + + from os import listdir + from os.path import isdir, join, exists + + l_folder = [f for f in listdir(mypath) if isdir(join(mypath, f))] + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~ # + # L _ m o d u l e _ l o w e r # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~ # + + l_module_lower = [] + import re + p = re.compile(ur'interface:\s+input') + + for f in l_folder: + path = "{0}/{1}/EZFIO.cfg".format(mypath, f) + if exists(path): + with open(path, 'r') as file_: + if p.search(file_.read()): + l_module_lower.append(f.lower()) + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + + return l_module_lower + + +def create_ocaml_input_global(): + """ + Check for all the EZFIO.cfg get the module lower + then create incule {module_lower}.ml + """ + + # ~#~#~#~# # + # I n i t # + # ~#~#~#~# # + + l_module_lower = get_l_module_lower() + + # ~#~#~#~#~#~#~#~# # + # C r e a t i o n # + # ~#~#~#~#~#~#~#~# # + + from ezfio_generate_ocaml import EZFIO_ocaml + + qpackage_root = os.environ['QPACKAGE_ROOT'] + path = qpackage_root + "/scripts/ezfio_interface/qp_edit_template" + + with open(path, "r") as f: + template_raw = f.read() + + e = EZFIO_ocaml(l_module_lower=l_module_lower) + + template = template_raw.format(keywords=e.create_qp_keywords(), + keywords_to_string=e.create_qp_keywords_to_string(), + section_to_rst=e.create_qp_section_to_rst(), + write=e.create_qp_write(), + tasks=e.create_qp_tasks()) + + input_auto = e.create_input_auto_generated() + + return (template, input_auto) + + +def save_ocaml_input_auto(str_ocaml_input_global): + """ + Write the str_ocaml_input in + $QPACKAGE_ROOT/ocaml/Input_auto_generated.ml + """ + + path = "{0}/ocaml/Input_auto_generated.ml".format(os.environ['QPACKAGE_ROOT']) + + try: + f = open(path, "r") + except IOError: + old_output = "" + else: + old_output = f.read() + f.close() + + if str_ocaml_input_global != old_output: + with open(path, "w+") as f: + f.write(str_ocaml_input_global) + + +def save_ocaml_qp_edit(str_ocaml_qp_edit): + """ + Write the str_ocaml_qp_edit in + $QPACKAGE_ROOT/ocaml/qp_edit.ml + """ + + path = "{0}/ocaml/qp_edit.ml".format(os.environ['QPACKAGE_ROOT']) + + try: + f = open(path, "r") + except IOError: + old_output = "" + else: + old_output = f.read() + f.close() + + if str_ocaml_qp_edit != old_output: + with open(path, "w+") as f: + f.write(str_ocaml_qp_edit) + + +if __name__ == "__main__": + arguments = docopt(__doc__) + + # ___ + # | ._ o _|_ + # _|_ | | | |_ + # + + if not arguments["--global"]: + if not arguments["--path"]: + config_file_path = "EZFIO.cfg" + if "EZFIO.cfg" not in os.listdir(os.getcwd()): + sys.exit(0) + else: + config_file_path = arguments["path"] + + # Get the full path + config_file_path = os.path.expanduser(config_file_path) + config_file_path = os.path.expandvars(config_file_path) + config_file_path = os.path.abspath(config_file_path) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # G e t _ m o d u l e _ d i r # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + path_dirname = os.path.dirname(config_file_path) + module = [i for i in path_dirname.split("/") if i][-1] + module_lower = module.lower() + + # Because we only authorise this right now! + ezfio_dir = module_lower + dict_ezfio_cfg = get_dict_config_file(config_file_path, ezfio_dir) + + # _ + # / _ _| _ _ _ ._ _ ._ _. _|_ o _ ._ + # \_ (_) (_| (/_ (_| (/_ | | (/_ | (_| |_ | (_) | | + # _| + + # ~#~#~#~#~#~#~#~#~#~ # + # W h a t _ t o _ d o # + # ~#~#~#~#~#~#~#~#~#~ # + if any([arguments[i] for i in ["--irpf90", + "--ezfio_config", + "--ocaml", + "--ezfio_default", + "--global"]]): + # User changer somme argument, do what he want + do_all = False + else: + # Do all the stuff + do_all = True + + # ~#~#~#~#~#~#~ # + # I R P . f 9 0 # + # ~#~#~#~#~#~#~ # + + if do_all or arguments["--irpf90"]: + l_str_code = create_ezfio_provider(dict_ezfio_cfg) + save_ezfio_provider(path_dirname, l_str_code) + + # ~#~#~#~#~#~#~#~#~#~#~#~ # + # e z f i o _ c o n f i g # + # ~#~#~#~#~#~#~#~#~#~#~#~ # + + if do_all or arguments["--ezfio_config"]: + str_ezfio_config = create_ezfio_config(dict_ezfio_cfg) + save_ezfio_config(module_lower, str_ezfio_config) + + # ~#~#~#~#~#~# + # O c a m l # + # ~#~#~#~#~#~# + if do_all or arguments["--ocaml"]: + try: + str_ocaml_input = create_ocaml_input(dict_ezfio_cfg, module_lower) + except ValueError: + pass + else: + save_ocaml_input(module_lower, str_ocaml_input) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + # e z f i o _ d e f a u l t # + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + if do_all or arguments["--ezfio_default"]: + str_ezfio_default = create_ezfio_default(dict_ezfio_cfg) + save_ezfio_default(module_lower, str_ezfio_default) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + # e z f i o _ d e f a u l t # + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + + if do_all or arguments["--global"]: + str_ocaml_qp_edit, str_ocaml_input_auto = create_ocaml_input_global() + save_ocaml_input_auto(str_ocaml_input_auto) + save_ocaml_qp_edit(str_ocaml_qp_edit) diff --git a/scripts/ezfio_interface/ezfio_generate_ocaml.py b/scripts/ezfio_interface/ezfio_generate_ocaml.py new file mode 100755 index 00000000..25b6c55f --- /dev/null +++ b/scripts/ezfio_interface/ezfio_generate_ocaml.py @@ -0,0 +1,483 @@ +#!/usr/bin/env python + +import sys +import os + +# If type in **kwargs +from ei_handler import Type + + +class EZFIO_ocaml(object): + + def __init__(self, **kwargs): + + for k, v in kwargs.iteritems(): + + try: + exec "self.{0} = {1}".format(k, v) + except NameError: + exec "self.{0} = '{1}'".format(k, v) + + @property + def Ocaml_type(self): + return self.type.ocaml.capitalize() + + @property + def ocaml_type(self): + return self.type.ocaml + + @property + def fancy_type(self): + return self.type.fancy + + def check_if_init(self, l_arg, name): + for i in l_arg: + try: + exec "self.{0}".format(i) + except AttributeError: + msg = "You need to provide a '{0}' for creating {1}" + raise KeyError(msg.format(i, name)) + + def create_read(self): + ''' + You need to instantiate the EZFIO_ocaml with this keyword argument + ezfio_dir = str + ezfio_name = str + type = Named_tuple(fancy_type, ocaml_type, fortrant_type) + + Return the read template + ''' + + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["ezfio_dir", "ezfio_name", "type"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = [ + '(* Read snippet for {self.ezfio_name} *)', + 'let read_{self.ezfio_name} () =', + ' if not (Ezfio.has_{self.ezfio_dir}_{self.ezfio_name} ()) then', + ' get_default "{self.ezfio_name}"', + ' |> {self.Ocaml_type}.of_string', + ' |> Ezfio.set_{self.ezfio_dir}_{self.ezfio_name}', + ' ;', + ' Ezfio.get_{self.ezfio_dir}_{self.ezfio_name} ()'] + + if self.fancy_type: + l_template += [" |> {self.fancy_type}.of_{self.ocaml_type}"] + + l_template += [";;"] + + template = "\n ".join(l_template) + + # ~#~#~#~#~#~ # + # R e n d e r # + # ~#~#~#~#~#~ # + + template_rendered = template.format(**locals()) + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + return template_rendered + + def create_write(self): + ''' + You need to instantiate the EZFIO_ocaml with this keyword argument + ezfio_dir = str + ezfio_name = str + type = Named_tuple(fancy_type, ocaml_type, fortrant_type) + + Return the read template + ''' + + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["ezfio_dir", "ezfio_name", "type"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ['(* Write snippet for {self.ezfio_name} *)'] + + if self.fancy_type: + l_template += ['let write_{self.ezfio_name} var = ', + ' {self.fancy_type}.to_{self.ocaml_type} var', + ' |> Ezfio.set_{self.ezfio_dir}_{self.ezfio_name}'] + else: + l_template += ['let write_{self.ezfio_name} =', + ' Ezfio.set_{self.ezfio_dir}_{self.ezfio_name}'] + + l_template += [';;'] + + template = "\n ".join(l_template) + + # ~#~#~#~#~#~ # + # R e n d e r # + # ~#~#~#~#~#~ # + + template_rendered = template.format(**locals()) + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + return template_rendered + + def create_type(self): + ''' + You need to instantiate the EZFIO_ocaml with this keyword argument + l_ezfio_name = [provider_name, ...] + l_type = [Named_tuple(fancy_type, ocaml_type, fortrant_type), ...] + + Return the type template + ''' + + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_ezfio_name", "l_type"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ["(* Generate type *)", + "type t = ", + " {"] + + for p, t in zip(self.l_ezfio_name, self.l_type): + + if t.fancy: + l_template += [" {0:<30} : {1}.t;".format(p, t.fancy)] + else: + l_template += [" {0:<30} : {1};".format(p, t.ocaml)] + + l_template += [" } with sexp", + ";;"] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + return "\n ".join(l_template) + + def create_read_global(self): + ''' + You need to instantiate the EZFIO_ocaml with this keyword argument + l_ezfio_name = [ezfio_name, ...] + + Return the read_global template + ''' + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_ezfio_name"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ["(* Read all *)", + "let read() = ", + " Some", + " {"] + + l_template += [" {0:<30} = read_{0} ();".format(p) + for p in self.l_ezfio_name] + + l_template += [" }", + ";;"] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + return "\n ".join(l_template) + + def create_write_global(self): + ''' + You need to instantiate the EZFIO_ocaml with this keyword argument + l_ezfio_name = [provider_name, ...] + + Return the type template + ''' + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_ezfio_name"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ["(* Write all *)", + "let write{ "] + l_template += [" {0};".format(p) for p in self.l_ezfio_name] + l_template += [" } ="] + l_template += [" write_{0:<30} {0};".format(p) + for p in self.l_ezfio_name] + l_template += [";;"] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + return "\n ".join(l_template) + + def create_to_string(self): + ''' + You need to instantiate the EZFIO_ocaml with this keyword argument + l_ezfio_name = [provider_name, ...] + l_type = [Named_tuple(fancy_type, ocaml_type, fortrant_type), ...] + + Return the type template + ''' + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_ezfio_name", "l_type"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ['(* to_string*)', + 'let to_string b =', + ' Printf.sprintf "'] + + l_template += ["{0} = %s".format(p) for p in self.l_ezfio_name] + l_template += ['"'] + + for p, t in zip(self.l_ezfio_name, self.l_type): + + if t.fancy: + str_ = t.fancy + else: + str_ = t.ocaml.capitalize() + + l_template += [" ({0}.to_string b.{1})".format(str_, p)] + + l_template += [";;"] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + return "\n ".join(l_template) + + def create_to_rst(self): + ''' + You need to instantiate the EZFIO_ocaml with this keyword argument + l_ezfio_name = [provider_name, ...] + l_type = [Named_tuple(fancy_type, ocaml_type, fortrant_type), ...] + + Return the type template + ''' + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_ezfio_name", "l_type", "l_doc"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ['(* to_rst*)', + 'let to_rst b =', + ' Printf.sprintf "'] + + for p, d in zip(self.l_ezfio_name, self.l_doc): + + l_template += ["{0} ::".format(d), + "", + " {0} = %s".format(p), + ""] + l_template += ['"'] + + for p, t in zip(self.l_ezfio_name, self.l_type): + + if t.fancy: + str_ = t.fancy + else: + str_ = t.ocaml.capitalize() + + l_template += [" ({0}.to_string b.{1})".format(str_, p)] + + l_template += ["|> Rst_string.of_string", + ";;"] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + return "\n ".join(l_template) + + def create_input_auto_generated(self): + """ + Generate the include of all the Input_module.lower template + """ + + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_module_lower"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ['open Qputils;;', + 'open Qptypes;;', + 'open Core.Std;;', + ''] + + for m in self.l_module_lower: + l_template += ["include Input_{0}".format(m)] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + + return "\n".join(l_template) + + def create_qp_keywords(self): + """ + Generate keywords template + """ + + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_module_lower"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ["| {0}".format(m.capitalize()) + for m in self.l_module_lower] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + + return "\n".join(l_template) + + def create_qp_keywords_to_string(self): + """ + Generate keywords to string template + """ + + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_module_lower"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = ['| {0} -> "{0}"'.format(m.capitalize()) + for m in self.l_module_lower] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + + return "\n".join(l_template) + + def create_qp_section_to_rst(self): + """ + Generate section to rst + """ + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_module_lower"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = [] + for m in self.l_module_lower: + m_cap = m.capitalize() + l_template += [" | {0} ->".format(m_cap), + " f {0}.(read, to_rst)".format(m_cap)] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + + return "\n".join(l_template) + + def create_qp_write(self): + """ + Generate write + """ + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_module_lower"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + str_ = " | {0} -> write {0}.(of_rst, write) s" + l_template = [str_.format(m.capitalize()) for m in self.l_module_lower] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + + return "\n".join(l_template) + + def create_qp_tasks(self): + """ + Generate taks + """ + # ~#~#~#~#~#~#~#~ # + # C h e c k i n g # + # ~#~#~#~#~#~#~#~ # + + self.check_if_init(["l_module_lower"], + sys._getframe().f_code.co_name) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + # C r e a t e _ t e m pl a t e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~# # + + l_template = [" {0} ; ".format(m.capitalize()) + for m in self.l_module_lower] + + # ~#~#~#~#~#~ # + # R e t u r n # + # ~#~#~#~#~#~ # + + return "\n".join(l_template) diff --git a/scripts/ezfio_interface/ezfio_generate_provider.py b/scripts/ezfio_interface/ezfio_generate_provider.py new file mode 100755 index 00000000..af4fcd6a --- /dev/null +++ b/scripts/ezfio_interface/ezfio_generate_provider.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python + +__author__ = "Applencourt PEP8" +__date__ = "jeudi 26 mars 2015, 12:49:35 (UTC+0100)" + +""" +Creates the provider of a variable that has to be +fetched from the EZFIO file. +""" + +import sys + +class EZFIO_Provider(object): + + data = """ +BEGIN_PROVIDER [ %(type)s, %(name)s ] + implicit none + BEGIN_DOC +! %(doc)s + END_DOC + + logical :: has + PROVIDE ezfio_filename + call ezfio_has_%(ezfio_dir)s_%(ezfio_name)s(has) + if (has) then + call ezfio_get_%(ezfio_dir)s_%(ezfio_name)s(%(name)s) + else + print *, '%(ezfio_dir)s/%(ezfio_name)s not found in EZFIO file' + stop 1 + endif +%(write)s +END_PROVIDER +""".strip() + + write_correspondance = {"integer": "write_int", + "logical": "write_bool", + "double precision": "write_double"} + + def __init__(self): + self.values = "type doc name ezfio_dir ezfio_name write output".split() + for v in self.values: + exec "self.{0} = None".format(v) + + def __repr__(self): + self.set_write() + for v in self.values: + if not v: + msg = "Error : %s is not set in ezfio_with_default.py" % (v) + print >>sys.stderr, msg + sys.exit(1) + return self.data % self.__dict__ + + def set_write(self): + self.write = "" + if self.type in self.write_correspondance: + write = self.write_correspondance[self.type] + output = self.output + name = self.name + + l_write = ["", + " call write_time(%(output)s)", + " call %(write)s(%(output)s, %(name)s, &", + " '%(name)s')", + ""] + + self.write = "\n".join(l_write) % locals() + + def set_type(self, t): + self.type = t.lower() + + def set_doc(self, t): + self.doc = t.strip().replace('\n', '\n! ') + + def set_name(self, t): + self.name = t + + def set_ezfio_dir(self, t): + self.ezfio_dir = t.lower() + + def set_ezfio_name(self, t): + self.ezfio_name = t.lower() + + def set_output(self, t): + self.output = t + + +def test_module(): + T = EZFIO_Provider() + T.set_type("double precision") + T.set_name("thresh_SCF") + T.set_doc("Threshold on the convergence of the Hartree Fock energy") + T.set_ezfio_dir("Hartree_Fock") + T.set_ezfio_name("thresh_SCF") + T.set_output("output_Hartree_Fock") + print T + +if __name__ == '__main__': + test_module() diff --git a/ocaml/qp_edit.ml b/scripts/ezfio_interface/qp_edit_template similarity index 86% rename from ocaml/qp_edit.ml rename to scripts/ezfio_interface/qp_edit_template index 2fc13e8c..8d52acfd 100644 --- a/ocaml/qp_edit.ml +++ b/scripts/ezfio_interface/qp_edit_template @@ -11,27 +11,21 @@ open Core.Std;; (** Keywords used to define input sections *) type keyword = | Ao_basis -| Bielec_integrals -| Cisd_sc2 | Determinants | Electrons -| Full_ci -| Hartree_fock | Mo_basis | Nuclei +{keywords} ;; let keyword_to_string = function -| Ao_basis -> "AO basis" -| Bielec_integrals -> "Two electron integrals" -| Cisd_sc2 -> "CISD (SC)^2" -| Determinants -> "Determinants" -| Electrons -> "Electrons" -| Full_ci -> "Selected Full-CI" -| Hartree_fock -> "Hartree-Fock" -| Mo_basis -> "MO basis" -| Nuclei -> "Molecule" +| Ao_basis -> "AO basis" +| Determinants -> "Determinants" +| Electrons -> "Electrons" +| Mo_basis -> "MO basis" +| Nuclei -> "Molecule" +{keywords_to_string} ;; @@ -70,24 +64,17 @@ let get s = begin let open Input in match s with - | Full_ci -> - f Full_ci.(read, to_rst) - | Hartree_fock -> - f Hartree_fock.(read, to_rst) | Mo_basis -> f Mo_basis.(read, to_rst) | Electrons -> f Electrons.(read, to_rst) - | Cisd_sc2 -> - f Cisd_sc2.(read, to_rst) | Nuclei -> f Nuclei.(read, to_rst) | Ao_basis -> f Ao_basis.(read, to_rst) - | Bielec_integrals -> - f Bielec_integrals.(read, to_rst) | Determinants -> f Determinants.(read, to_rst) +{section_to_rst} end with | Sys_error msg -> (Printf.eprintf "Info: %s\n%!" msg ; "") @@ -125,11 +112,8 @@ let set str s = in let open Input in match s with - | Hartree_fock -> write Hartree_fock.(of_rst, write) s - | Full_ci -> write Full_ci.(of_rst, write) s +{write} | Electrons -> write Electrons.(of_rst, write) s - | Cisd_sc2 -> write Cisd_sc2.(of_rst, write) s - | Bielec_integrals -> write Bielec_integrals.(of_rst, write) s | Determinants -> write Determinants.(of_rst, write) s | Nuclei -> write Nuclei.(of_rst, write) s | Ao_basis -> () (* TODO *) @@ -176,10 +160,7 @@ let run check_only ezfio_filename = Nuclei ; Ao_basis; Electrons ; - Bielec_integrals ; - Hartree_fock ; - Cisd_sc2 ; - Full_ci ; +{tasks} Mo_basis; Determinants ; ] diff --git a/scripts/ezfio_with_default.py b/scripts/ezfio_with_default.py index 75fef0b6..1b5f01a8 100755 --- a/scripts/ezfio_with_default.py +++ b/scripts/ezfio_with_default.py @@ -90,7 +90,10 @@ END_PROVIDER self.default = t def get_default(self): - filename = '/'.join( [os.environ['QPACKAGE_ROOT'], 'data', 'ezfio_defaults'] ) + filename = '/'.join( [os.environ['QPACKAGE_ROOT'], 'data', + 'ezfio_defaults', + 'WILL_BE_DELETED.ezfio_default'] ) + file = open(filename,'r') lines = file.readlines() file.close() @@ -115,6 +118,8 @@ END_PROVIDER true = True false= False try: + true = True + false = False v_eval = eval(v) except: v = "call ezfio_get_%(v)s(%(name)s)"%locals() diff --git a/scripts/prepare_ezfio.sh b/scripts/prepare_ezfio.sh index c01bacd3..96ba3cdc 100755 --- a/scripts/prepare_ezfio.sh +++ b/scripts/prepare_ezfio.sh @@ -9,7 +9,7 @@ echo "=-=-=-=-=-=-=-=-=-=-=-" for dir in ${QPACKAGE_ROOT}/src/*/ do cd $dir || exit -1 - ${QPACKAGE_ROOT}/scripts/ezfio_interface.py + ${QPACKAGE_ROOT}/scripts/ezfio_interface/ei_handler.py done # For old-style directories. Will be removed some day... diff --git a/scripts/run_Makefile_common.sh b/scripts/run_Makefile_common.sh index 0a579a94..82e898ac 100755 --- a/scripts/run_Makefile_common.sh +++ b/scripts/run_Makefile_common.sh @@ -65,5 +65,4 @@ fi ${QPACKAGE_ROOT}/scripts/create_Makefile_depend.sh # Update EZFIO interface -${QPACKAGE_ROOT}/scripts/ezfio_interface.py - + ${QPACKAGE_ROOT}/scripts/ezfio_interface/ei_handler.py diff --git a/setup_environment.sh b/setup_environment.sh index a35746bc..be4bae64 100755 --- a/setup_environment.sh +++ b/setup_environment.sh @@ -17,8 +17,8 @@ export QPACKAGE_ROOT=\$( cd \$(dirname "\${BASH_SOURCE}") ; pwd -P ) export LD_LIBRARY_PATH="\${QPACKAGE_ROOT}"/lib:\${LD_LIBRARY_PATH} export LIBRARY_PATH="\${QPACKAGE_ROOT}"/lib:\${LIBRARY_PATH} export C_INCLUDE_PATH="\${QPACKAGE_ROOT}"/include:\${C_INCLUDE_PATH} -export PYTHONPATH=\${PYTHONPATH}:"\${QPACKAGE_ROOT}"/scripts -export PATH=\${PATH}:"\${QPACKAGE_ROOT}"/scripts +export PYTHONPATH=\${PYTHONPATH}:"\${QPACKAGE_ROOT}"/scripts:"\${QPACKAGE_ROOT}"/scripts/ezfio_interface +export PATH=\${PATH}:"\${QPACKAGE_ROOT}"/scripts:"\${QPACKAGE_ROOT}"/scripts/ezfio_interface export PATH=\${PATH}:"\${QPACKAGE_ROOT}"/bin export PATH=\${PATH}:"\${QPACKAGE_ROOT}"/ocaml source "\${QPACKAGE_ROOT}"/bin/irpman &> /dev/null @@ -48,16 +48,6 @@ then fi -echo "${BLUE}===== Installing EZFIO ===== ${BLACK}" -${QPACKAGE_ROOT}/scripts/install_ezfio.sh | tee install_ezfio.log - -if [[ ! -d ${QPACKAGE_ROOT}/EZFIO ]] -then - echo $RED "Error in EZFIO installation" $BLACK - exit 1 -fi - - echo "${BLUE}===== Installing Zlib ===== ${BLACK}" ${QPACKAGE_ROOT}/scripts/install_zlib.sh | tee install_zlib.log diff --git a/src/BiInts/bi_integrals.ezfio_config b/src/BiInts/bi_integrals.ezfio_config deleted file mode 100644 index e780dce8..00000000 --- a/src/BiInts/bi_integrals.ezfio_config +++ /dev/null @@ -1,9 +0,0 @@ -bielec_integrals - read_ao_integrals logical - read_mo_integrals logical - write_ao_integrals logical - write_mo_integrals logical - threshold_ao double precision - threshold_mo double precision - direct logical - diff --git a/src/BiInts/options.irp.f b/src/BiInts/options.irp.f deleted file mode 100644 index 3a54fd19..00000000 --- a/src/BiInts/options.irp.f +++ /dev/null @@ -1,46 +0,0 @@ -BEGIN_SHELL [ /usr/bin/python ] -from ezfio_with_default import EZFIO_Provider -T = EZFIO_Provider() -T.set_type ( "logical" ) -T.set_name ( "do_direct_integrals" ) -T.set_doc ( "If true, compute integrals on the fly" ) -T.set_ezfio_dir ( "bielec_integrals" ) -T.set_ezfio_name( "direct" ) -T.set_output ( "output_biints" ) -print T - -T.set_type ( "logical" ) -T.set_name ( "write_mo_integrals" ) -T.set_doc ( "If true, write MO integrals in EZFIO" ) -T.set_ezfio_name( "write_mo_integrals" ) -print T - -T.set_name ( "write_ao_integrals" ) -T.set_doc ( "If true, write AO integrals in EZFIO" ) -T.set_ezfio_name( "write_ao_integrals" ) -print T - -T.set_name ( "read_mo_integrals" ) -T.set_doc ( "If true, read MO integrals in EZFIO" ) -T.set_ezfio_name( "read_mo_integrals" ) -print T - -T.set_name ( "read_ao_integrals" ) -T.set_doc ( "If true, read AO integrals in EZFIO" ) -T.set_ezfio_name( "read_ao_integrals" ) -print T - -T.set_type ( "double precision" ) -T.set_name ( "ao_integrals_threshold" ) -T.set_doc ( "If < ao_integrals_threshold, = 0" ) -T.set_ezfio_name( "threshold_ao" ) -print T - -T.set_name ( "mo_integrals_threshold" ) -T.set_doc ( "If < mo_integrals_threshold, = 0" ) -T.set_ezfio_name( "threshold_mo" ) -print T - -END_SHELL - - diff --git a/src/Bielec_integrals/ASSUMPTIONS.rst b/src/Bielec_integrals/ASSUMPTIONS.rst new file mode 100644 index 00000000..e69de29b diff --git a/src/Bielec_integrals/EZFIO.cfg b/src/Bielec_integrals/EZFIO.cfg new file mode 100644 index 00000000..eaada232 --- /dev/null +++ b/src/Bielec_integrals/EZFIO.cfg @@ -0,0 +1,32 @@ +[do_direct_integrals] +type: logical +doc: Compute integrals on the fly +interface: input +default: False +ezfio_name: direct + +[disk_access_mo_integrals] +type: Disk_access +doc: Read/Write MO integrals from/to disk [ Write | Read | None ] +interface: input +default: None + +[disk_access_ao_integrals] +type: Disk_access +doc: Read/Write AO integrals from/to disk [ Write | Read | None ] +interface: input +default: None + +[ao_integrals_threshold] +type: Threshold +doc: If || < ao_integrals_threshold then is zero +interface: input +default: 1.e-15 +ezfio_name: threshold_ao + +[mo_integrals_threshold] +type: Threshold +doc: If || < ao_integrals_threshold then is zero +interface: input +default: 1.e-15 +ezfio_name: threshold_mo diff --git a/src/BiInts/Makefile b/src/Bielec_integrals/Makefile similarity index 100% rename from src/BiInts/Makefile rename to src/Bielec_integrals/Makefile diff --git a/src/BiInts/NEEDED_MODULES b/src/Bielec_integrals/NEEDED_MODULES similarity index 100% rename from src/BiInts/NEEDED_MODULES rename to src/Bielec_integrals/NEEDED_MODULES diff --git a/src/BiInts/README.rst b/src/Bielec_integrals/README.rst similarity index 100% rename from src/BiInts/README.rst rename to src/Bielec_integrals/README.rst diff --git a/src/BiInts/ao_bi_integrals.irp.f b/src/Bielec_integrals/ao_bi_integrals.irp.f similarity index 97% rename from src/BiInts/ao_bi_integrals.irp.f rename to src/Bielec_integrals/ao_bi_integrals.irp.f index 67fc0a1b..0da76021 100644 --- a/src/BiInts/ao_bi_integrals.irp.f +++ b/src/Bielec_integrals/ao_bi_integrals.irp.f @@ -319,13 +319,6 @@ subroutine compute_ao_bielec_integrals(j,k,l,sze,buffer_value) end - - - - - - - BEGIN_PROVIDER [ logical, ao_bielec_integrals_in_map ] implicit none use map_module @@ -356,7 +349,7 @@ BEGIN_PROVIDER [ logical, ao_bielec_integrals_in_map ] integer :: load_ao_integrals print*,'Reading the AO integrals' if (load_ao_integrals(trim(ezfio_filename)//'/work/ao_integrals.bin') == 0) then - write(output_BiInts,*) 'AO integrals provided' + write(output_bielec_integrals,*) 'AO integrals provided' ao_bielec_integrals_in_map = .True. return endif @@ -374,7 +367,7 @@ BEGIN_PROVIDER [ logical, ao_bielec_integrals_in_map ] PROVIDE progress_bar call omp_init_lock(lock) lmax = ao_num*(ao_num+1)/2 - write(output_BiInts,*) 'Providing the AO integrals' + write(output_bielec_integrals,*) 'Providing the AO integrals' call wall_time(wall_0) call wall_time(wall_1) call cpu_time(cpu_1) @@ -385,7 +378,7 @@ BEGIN_PROVIDER [ logical, ao_bielec_integrals_in_map ] !$OMP DEFAULT(NONE) & !$OMP SHARED (ao_num, jl_pairs, ao_integrals_map,thresh, & !$OMP cpu_1,wall_1,lock, lmax,n_centers,ao_nucl, & - !$OMP ao_overlap_abs,ao_overlap,output_BiInts,abort_here, & + !$OMP ao_overlap_abs,ao_overlap,output_bielec_integrals,abort_here, & !$OMP wall_0,progress_bar,progress_value) allocate(buffer_i(size_buffer)) @@ -452,7 +445,7 @@ IRP_ENDIF if (thread_num == 0) then if (wall_2 - wall_0 > 1.d0) then wall_0 = wall_2 - write(output_BiInts,*) 100.*float(kk)/float(lmax), '% in ', & + write(output_bielec_integrals,*) 100.*float(kk)/float(lmax), '% in ', & wall_2-wall_1, 's', map_mb(ao_integrals_map) ,'MB' progress_value = dble(map_mb(ao_integrals_map)) endif @@ -469,21 +462,21 @@ IRP_ENDIF stop 'Aborting in AO integrals calculation' endif IRP_IF COARRAY - write(output_BiInts,*) 'Communicating the map' + write(output_bielec_integrals,*) 'Communicating the map' call communicate_ao_integrals() IRP_ENDIF COARRAY - write(output_BiInts,*) 'Sorting the map' + write(output_bielec_integrals,*) 'Sorting the map' call map_sort(ao_integrals_map) call cpu_time(cpu_2) call wall_time(wall_2) integer(map_size_kind) :: get_ao_map_size, ao_map_size ao_map_size = get_ao_map_size() - write(output_BiInts,*) 'AO integrals provided:' - write(output_BiInts,*) ' Size of AO map : ', map_mb(ao_integrals_map) ,'MB' - write(output_BiInts,*) ' Number of AO integrals :', ao_map_size - write(output_BiInts,*) ' cpu time :',cpu_2 - cpu_1, 's' - write(output_BiInts,*) ' wall time :',wall_2 - wall_1, 's ( x ', (cpu_2-cpu_1)/(wall_2-wall_1+tiny(1.d0)), ' )' + write(output_bielec_integrals,*) 'AO integrals provided:' + write(output_bielec_integrals,*) ' Size of AO map : ', map_mb(ao_integrals_map) ,'MB' + write(output_bielec_integrals,*) ' Number of AO integrals :', ao_map_size + write(output_bielec_integrals,*) ' cpu time :',cpu_2 - cpu_1, 's' + write(output_bielec_integrals,*) ' wall time :',wall_2 - wall_1, 's ( x ', (cpu_2-cpu_1)/(wall_2-wall_1+tiny(1.d0)), ' )' ao_bielec_integrals_in_map = .True. if (write_ao_integrals) then diff --git a/src/BiInts/gauss_legendre.irp.f b/src/Bielec_integrals/gauss_legendre.irp.f similarity index 100% rename from src/BiInts/gauss_legendre.irp.f rename to src/Bielec_integrals/gauss_legendre.irp.f diff --git a/src/BiInts/map_integrals.irp.f b/src/Bielec_integrals/map_integrals.irp.f similarity index 99% rename from src/BiInts/map_integrals.irp.f rename to src/Bielec_integrals/map_integrals.irp.f index 3ebbf6fe..8fdff799 100644 --- a/src/BiInts/map_integrals.irp.f +++ b/src/Bielec_integrals/map_integrals.irp.f @@ -13,7 +13,7 @@ BEGIN_PROVIDER [ type(map_type), ao_integrals_map ] call bielec_integrals_index(ao_num,ao_num,ao_num,ao_num,key_max) sze = key_max call map_init(ao_integrals_map,sze) - write(output_BiInts,*) 'AO map initialized' + write(output_bielec_integrals,*) 'AO map initialized' END_PROVIDER subroutine bielec_integrals_index(i,j,k,l,i1) @@ -244,7 +244,7 @@ BEGIN_PROVIDER [ type(map_type), mo_integrals_map ] call bielec_integrals_index(mo_tot_num,mo_tot_num,mo_tot_num,mo_tot_num,key_max) sze = key_max call map_init(mo_integrals_map,sze) - write(output_BiInts,*) 'MO map initialized' + write(output_bielec_integrals,*) 'MO map initialized' END_PROVIDER subroutine insert_into_ao_integrals_map(n_integrals, & diff --git a/src/BiInts/mo_bi_integrals.irp.f b/src/Bielec_integrals/mo_bi_integrals.irp.f similarity index 94% rename from src/BiInts/mo_bi_integrals.irp.f rename to src/Bielec_integrals/mo_bi_integrals.irp.f index 54d274c7..5adc980b 100644 --- a/src/BiInts/mo_bi_integrals.irp.f +++ b/src/Bielec_integrals/mo_bi_integrals.irp.f @@ -31,7 +31,7 @@ BEGIN_PROVIDER [ logical, mo_bielec_integrals_in_map ] integer :: load_mo_integrals print*,'Reading the MO integrals' if (load_mo_integrals(trim(ezfio_filename)//'/work/mo_integrals.bin') == 0) then - write(output_BiInts,*) 'MO integrals provided' + write(output_bielec_integrals,*) 'MO integrals provided' return endif endif @@ -84,8 +84,8 @@ subroutine add_integrals_to_map(mask_ijkl) call bitstring_to_list( mask_ijkl(1,4), list_ijkl(1,4), n_l, N_int ) size_buffer = min(ao_num*ao_num*ao_num,16000000) - write(output_BiInts,*) 'Providing the molecular integrals ' - write(output_BiInts,*) 'Buffers : ', 8.*(mo_tot_num_align*(n_j)*(n_k+1) + mo_tot_num_align +& + write(output_bielec_integrals,*) 'Providing the molecular integrals ' + write(output_bielec_integrals,*) 'Buffers : ', 8.*(mo_tot_num_align*(n_j)*(n_k+1) + mo_tot_num_align +& ao_num+ao_num*ao_num+ size_buffer*3)/(1024*1024), 'MB / core' call wall_time(wall_1) @@ -99,7 +99,7 @@ subroutine add_integrals_to_map(mask_ijkl) !$OMP wall_0,thread_num) & !$OMP DEFAULT(NONE) & !$OMP SHARED(size_buffer,ao_num,mo_tot_num,n_i,n_j,n_k,n_l,mo_tot_num_align,& - !$OMP mo_coef_transp,output_BiInts, & + !$OMP mo_coef_transp,output_bielec_integrals, & !$OMP mo_coef_transp_is_built, list_ijkl, & !$OMP mo_coef_is_built, wall_1, abort_here, & !$OMP mo_coef,mo_integrals_threshold,ao_integrals_map,mo_integrals_map,progress_bar,progress_value) @@ -272,7 +272,7 @@ IRP_ENDIF if (thread_num == 0) then if (wall_2 - wall_0 > 1.d0) then wall_0 = wall_2 - write(output_BiInts,*) 100.*float(l1)/float(ao_num), '% in ', & + write(output_bielec_integrals,*) 100.*float(l1)/float(ao_num), '% in ', & wall_2-wall_1, 's', map_mb(mo_integrals_map) ,'MB' progress_value = dble(map_mb(mo_integrals_map)) @@ -291,7 +291,7 @@ IRP_ENDIF stop 'Aborting in MO integrals calculation' endif IRP_IF COARRAY - write(output_BiInts,*) 'Communicating the map' + write(output_bielec_integrals,*) 'Communicating the map' call communicate_mo_integrals() IRP_ENDIF call map_unique(mo_integrals_map) @@ -304,11 +304,11 @@ IRP_ENDIF deallocate(list_ijkl) - write(output_BiInts,*)'Molecular integrals provided:' - write(output_BiInts,*)' Size of MO map ', map_mb(mo_integrals_map) ,'MB' - write(output_BiInts,*)' Number of MO integrals: ', mo_map_size - write(output_BiInts,*)' cpu time :',cpu_2 - cpu_1, 's' - write(output_BiInts,*)' wall time :',wall_2 - wall_1, 's ( x ', (cpu_2-cpu_1)/(wall_2-wall_1), ')' + write(output_bielec_integrals,*)'Molecular integrals provided:' + write(output_bielec_integrals,*)' Size of MO map ', map_mb(mo_integrals_map) ,'MB' + write(output_bielec_integrals,*)' Number of MO integrals: ', mo_map_size + write(output_bielec_integrals,*)' cpu time :',cpu_2 - cpu_1, 's' + write(output_bielec_integrals,*)' wall time :',wall_2 - wall_1, 's ( x ', (cpu_2-cpu_1)/(wall_2-wall_1), ')' if (write_mo_integrals) then call dump_mo_integrals(trim(ezfio_filename)//'/work/mo_integrals.bin') diff --git a/src/Bielec_integrals/read_write.irp.f b/src/Bielec_integrals/read_write.irp.f new file mode 100644 index 00000000..6319641b --- /dev/null +++ b/src/Bielec_integrals/read_write.irp.f @@ -0,0 +1,41 @@ +BEGIN_PROVIDER [ logical, read_ao_integrals ] +&BEGIN_PROVIDER [ logical, read_mo_integrals ] +&BEGIN_PROVIDER [ logical, write_ao_integrals ] +&BEGIN_PROVIDER [ logical, write_mo_integrals ] + + BEGIN_DOC +! One level of abstraction for disk_access_ao_integrals and disk_access_mo_integrals + END_DOC +implicit none + + if (disk_access_ao_integrals.EQ.'Read') then + read_ao_integrals = .True. + write_ao_integrals = .False. + + else if (disk_access_ao_integrals.EQ.'Write') then + read_ao_integrals = .False. + write_ao_integrals = .True. + + else if (disk_access_ao_integrals.EQ.'None') then + read_ao_integrals = .False. + write_ao_integrals = .False. + + else if (disk_access_mo_integrals.EQ.'Read') then + read_mo_integrals = .True. + write_mo_integrals = .False. + + else if (disk_access_mo_integrals.EQ.'Write') then + read_mo_integrals = .False. + write_mo_integrals = .True. + + else if (disk_access_mo_integrals.EQ.'None') then + read_mo_integrals = .False. + write_mo_integrals = .False. + + else + print *, 'bielec_integrals/disk_acces not of a the good type' + stop "1" + + endif + +END_PROVIDER diff --git a/src/CAS_SD/NEEDED_MODULES b/src/CAS_SD/NEEDED_MODULES index 7d7c112f..cbf44be7 100644 --- a/src/CAS_SD/NEEDED_MODULES +++ b/src/CAS_SD/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Generators_CAS Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Generators_CAS Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils diff --git a/src/CID/NEEDED_MODULES b/src/CID/NEEDED_MODULES index 3832d4c1..ac8e21ab 100644 --- a/src/CID/NEEDED_MODULES +++ b/src/CID/NEEDED_MODULES @@ -1,3 +1,3 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Selectors_full SingleRefMethod Utils diff --git a/src/CID_SC2_selected/NEEDED_MODULES b/src/CID_SC2_selected/NEEDED_MODULES index d7bca283..42d83610 100644 --- a/src/CID_SC2_selected/NEEDED_MODULES +++ b/src/CID_SC2_selected/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask CISD CISD_selected Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask CISD CISD_selected Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils diff --git a/src/CID_selected/NEEDED_MODULES b/src/CID_selected/NEEDED_MODULES index 56946f0e..b27ab85e 100644 --- a/src/CID_selected/NEEDED_MODULES +++ b/src/CID_selected/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask CISD Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask CISD Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils diff --git a/src/CIS/NEEDED_MODULES b/src/CIS/NEEDED_MODULES index 847ba574..010e60f5 100644 --- a/src/CIS/NEEDED_MODULES +++ b/src/CIS/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Selectors_full SingleRefMethod Utils diff --git a/src/CISD/NEEDED_MODULES b/src/CISD/NEEDED_MODULES index 847ba574..010e60f5 100644 --- a/src/CISD/NEEDED_MODULES +++ b/src/CISD/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Selectors_full SingleRefMethod Utils diff --git a/src/CISD_SC2_selected/EZFIO.cfg b/src/CISD_SC2_selected/EZFIO.cfg new file mode 100644 index 00000000..a97e2d76 --- /dev/null +++ b/src/CISD_SC2_selected/EZFIO.cfg @@ -0,0 +1,29 @@ +[N_det_max_cisd_sc2] +type: Det_number_max +doc: Max number of determinants +interface: input +default: 10000 + +[do_pt2_end] +type: logical +doc: If true, compute the PT2 at the end of the selection +interface: input +default: true + +[PT2_max] +type: PT2_energy +doc: The selection process stops when the largest PT2 (for all the states) is lower + than abs(pt2_max) +interface: input +default: 0.0001 + +[energy] +type: double precision +doc: Calculated CISD_SC2 energy of ground_state +interface: output + +[energy_pt2] +type: double precision +doc: Calculated CISD_SC2 energy+pt2 of ground_state +interface: output + diff --git a/src/CISD_SC2_selected/NEEDED_MODULES b/src/CISD_SC2_selected/NEEDED_MODULES index d7bca283..42d83610 100644 --- a/src/CISD_SC2_selected/NEEDED_MODULES +++ b/src/CISD_SC2_selected/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask CISD CISD_selected Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask CISD CISD_selected Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils diff --git a/src/CISD_SC2_selected/cisd_sc2.ezfio_config b/src/CISD_SC2_selected/cisd_sc2.ezfio_config deleted file mode 100644 index 35008968..00000000 --- a/src/CISD_SC2_selected/cisd_sc2.ezfio_config +++ /dev/null @@ -1,4 +0,0 @@ -cisd_sc2_selected - n_det_max_cisd_sc2 integer - pt2_max double precision - do_pt2_end logical diff --git a/src/CISD_SC2_selected/cisd_sc2_selection.irp.f b/src/CISD_SC2_selected/cisd_sc2_selection.irp.f index fb7de4cf..55234fcb 100644 --- a/src/CISD_SC2_selected/cisd_sc2_selection.irp.f +++ b/src/CISD_SC2_selected/cisd_sc2_selection.irp.f @@ -62,12 +62,20 @@ program cisd_sc2_selected if (abort_all) then exit endif + + ! =~=~=~=~=~=~=~=~=~=~=~=~=~! + ! W r i t e _ o n _ d i s k ! + ! =~=~=~=~=~=~=~=~=~=~=~=~=~! + + call ezfio_set_full_ci_energy(CI_SC2_energy(1)) + enddo N_det = min(n_det_max_cisd_sc2,N_det) davidson_threshold = 1.d-10 touch N_det psi_det psi_coef davidson_threshold davidson_criterion call diagonalize_CI_SC2 pt2 = 0.d0 + if(do_pt2_end)then threshold_selectors = 1.d0 call H_apply_PT2(pt2, norm_pert, H_pert_diag, N_st) @@ -97,6 +105,12 @@ program cisd_sc2_selected print*,'Degree of excitation of this determinant : ',degree enddo + + ! =~=~=~=~=~=~=~=~=~=~=~=~=~! + ! W r i t e _ o n _ d i s k ! + ! =~=~=~=~=~=~=~=~=~=~=~=~=~! + + call ezfio_set_full_ci_energy_pt2(CI_SC2_energy(i)+pt2(i)* (1.d0 + norm_pert) - H_pert_diag(i)) endif call save_wavefunction deallocate(pt2,norm_pert,H_pert_diag) diff --git a/src/CISD_SC2_selected/options.irp.f b/src/CISD_SC2_selected/options.irp.f deleted file mode 100644 index 1fe3e158..00000000 --- a/src/CISD_SC2_selected/options.irp.f +++ /dev/null @@ -1,51 +0,0 @@ - BEGIN_PROVIDER [ integer, n_det_max_cisd_sc2 ] - implicit none - BEGIN_DOC - ! Get n_det_max_cisd_sc2 from EZFIO file - END_DOC - logical :: has_n_det_max_cisd_sc2 - PROVIDE ezfio_filename - call ezfio_has_cisd_sc2_selected_n_det_max_cisd_sc2(has_n_det_max_cisd_sc2) - if (has_n_det_max_cisd_sc2) then - call ezfio_get_cisd_sc2_selected_n_det_max_cisd_sc2(n_det_max_cisd_sc2) - else - n_det_max_cisd_sc2 = 1000 - call ezfio_set_cisd_sc2_selected_n_det_max_cisd_sc2(n_det_max_cisd_sc2) - endif - print*,'n_det_max_cisd_sc2 = ',n_det_max_cisd_sc2 - END_PROVIDER - - BEGIN_PROVIDER [ double precision , pt2_max ] - implicit none - BEGIN_DOC - ! Get pt2_max from EZFIO file - END_DOC - logical :: has_pt2_max - PROVIDE ezfio_filename - call ezfio_has_cisd_sc2_selected_pt2_max(has_pt2_max) - if (has_pt2_max) then - call ezfio_get_cisd_sc2_selected_pt2_max(pt2_max) - else - pt2_max = 1.d-3 - call ezfio_set_cisd_sc2_selected_pt2_max(pt2_max) - endif - print*,'pt2_max = ',pt2_max - END_PROVIDER - - BEGIN_PROVIDER [ logical, do_pt2_end ] - implicit none - BEGIN_DOC - ! Get do_pt2_end from EZFIO file - END_DOC - logical :: has_do_pt2_end - PROVIDE ezfio_filename - call ezfio_has_cisd_sc2_selected_do_pt2_end(has_do_pt2_end) - if (has_do_pt2_end) then - call ezfio_get_cisd_sc2_selected_do_pt2_end(do_pt2_end) - else - do_pt2_end = .True. - call ezfio_set_cisd_sc2_selected_do_pt2_end(do_pt2_end) - endif - print*,'do_pt2_end = ',do_pt2_end - END_PROVIDER - diff --git a/src/CISD_selected/NEEDED_MODULES b/src/CISD_selected/NEEDED_MODULES index 56946f0e..b27ab85e 100644 --- a/src/CISD_selected/NEEDED_MODULES +++ b/src/CISD_selected/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask CISD Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask CISD Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils diff --git a/src/DDCI_selected/NEEDED_MODULES b/src/DDCI_selected/NEEDED_MODULES index 7d7c112f..cbf44be7 100644 --- a/src/DDCI_selected/NEEDED_MODULES +++ b/src/DDCI_selected/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Generators_CAS Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Generators_CAS Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils diff --git a/src/Dets/NEEDED_MODULES b/src/Dets/NEEDED_MODULES index 163bdf10..824c75ed 100644 --- a/src/Dets/NEEDED_MODULES +++ b/src/Dets/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask Electrons Ezfio_files MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Electrons Ezfio_files MonoInts MOs Nuclei Output Utils diff --git a/src/Dets/det_svd.irp.f b/src/Dets/det_svd.irp.f index 8365b42c..0a57acf3 100644 --- a/src/Dets/det_svd.irp.f +++ b/src/Dets/det_svd.irp.f @@ -3,7 +3,7 @@ program det_svd BEGIN_DOC ! Computes the SVD of the Alpha x Beta determinant coefficient matrix END_DOC - integer :: i,j + integer :: i,j,k read_wf = .True. TOUCH read_wf @@ -40,17 +40,22 @@ program det_svd print *, 'N_det_alpha = ', N_det_alpha_unique print *, 'N_det_beta = ', N_det_beta_unique print *, '' - -! do i=1,N_det_alpha_unique -! do j=1,N_det_beta_unique -! print *, i,j,psi_svd_matrix(i,j,:) -! enddo -! enddo - print *, '' + call diagonalize_ci print *, 'Energy = ', ci_energy + + do i=1,N_det_alpha_unique + do j=1,N_det_beta_unique + do k=1,N_states + if (dabs(psi_svd_matrix(i,j,k)) < 1.d-15) then + psi_svd_matrix(i,j,k) = 0.d0 + endif + enddo + enddo + enddo + print *, '' print *, psi_svd_coefs(1:20,1) -! call save_wavefunction + call save_wavefunction end diff --git a/src/Dets/save_for_qmcchem.irp.f b/src/Dets/save_for_qmcchem.irp.f index 363e0ba2..7dea70c6 100644 --- a/src/Dets/save_for_qmcchem.irp.f +++ b/src/Dets/save_for_qmcchem.irp.f @@ -42,8 +42,10 @@ subroutine save_dets_qmcchem enddo close(31) call system('gzip -f '//trim(ezfio_filename)//'/mo_basis/mo_classif') + end program save_for_qmc call save_dets_qmcchem + call write_spindeterminants end diff --git a/src/Dets/spindeterminants.ezfio_config b/src/Dets/spindeterminants.ezfio_config index e6a0ed9a..1c7d81e3 100644 --- a/src/Dets/spindeterminants.ezfio_config +++ b/src/Dets/spindeterminants.ezfio_config @@ -7,4 +7,8 @@ spindeterminants psi_det_alpha integer*8 (spindeterminants_n_int*spindeterminants_bit_kind/8,spindeterminants_n_det_alpha) psi_det_beta integer*8 (spindeterminants_n_int*spindeterminants_bit_kind/8,spindeterminants_n_det_beta) psi_coef_matrix double precision (spindeterminants_n_det_alpha,spindeterminants_n_det_beta,spindeterminants_n_states) + n_svd_coefs integer + psi_svd_alpha double precision (spindeterminants_n_det_alpha,spindeterminants_n_svd_coefs,spindeterminants_n_states) + psi_svd_beta double precision (spindeterminants_n_det_beta,spindeterminants_n_svd_coefs,spindeterminants_n_states) + psi_svd_coefs double precision (spindeterminants_n_svd_coefs,spindeterminants_n_states) diff --git a/src/Dets/spindeterminants.irp.f b/src/Dets/spindeterminants.irp.f index 236dc1fc..4b426faa 100644 --- a/src/Dets/spindeterminants.irp.f +++ b/src/Dets/spindeterminants.irp.f @@ -26,7 +26,7 @@ subroutine write_spindeterminants enddo call ezfio_set_spindeterminants_psi_det_alpha(psi_det_alpha_unique) deallocate(tmpdet) - + allocate(tmpdet(N_int2,N_det_beta_unique)) do i=1,N_det_beta_unique do k=1,N_int @@ -38,7 +38,54 @@ subroutine write_spindeterminants enddo call ezfio_set_spindeterminants_psi_det_beta(psi_det_beta_unique) deallocate(tmpdet) - + call ezfio_set_spindeterminants_psi_coef_matrix(psi_svd_matrix) + + integer :: n_svd_coefs + double precision :: norm, f + f = 1.d0/dble(N_states) + norm = 1.d0 + do n_svd_coefs=1,N_det_alpha_unique + do k=1,N_states + norm -= psi_svd_coefs(n_svd_coefs,k)*psi_svd_coefs(n_svd_coefs,k) + enddo + if (norm < 1.d-6) then + exit + endif + enddo + n_svd_coefs -= 1 + call ezfio_set_spindeterminants_n_svd_coefs(n_svd_coefs) + + double precision, allocatable :: dtmp(:,:,:) + allocate(dtmp(N_det_alpha_unique,n_svd_coefs,N_states)) + do k=1,N_states + do j=1,n_svd_coefs + do i=1,N_det_alpha_unique + dtmp(i,j,k) = psi_svd_alpha(i,j,k) + enddo + enddo + enddo + call ezfio_set_spindeterminants_psi_svd_alpha(dtmp) + deallocate(dtmp) + + allocate(dtmp(N_det_beta_unique,n_svd_coefs,N_states)) + do k=1,N_states + do j=1,n_svd_coefs + do i=1,N_det_beta_unique + dtmp(i,j,k) = psi_svd_beta(i,j,k) + enddo + enddo + enddo + call ezfio_set_spindeterminants_psi_svd_beta(dtmp) + deallocate(dtmp) + + allocate(dtmp(n_svd_coefs,N_states,1)) + do k=1,N_states + do j=1,n_svd_coefs + dtmp(j,k,1) = psi_svd_coefs(j,k) + enddo + enddo + call ezfio_set_spindeterminants_psi_svd_coefs(dtmp) + deallocate(dtmp) end diff --git a/src/FCIdump/NEEDED_MODULES b/src/FCIdump/NEEDED_MODULES index 26097b8b..7f2f0ca8 100644 --- a/src/FCIdump/NEEDED_MODULES +++ b/src/FCIdump/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils diff --git a/src/Full_CI/EZFIO.cfg b/src/Full_CI/EZFIO.cfg index f660a386..f59e094f 100644 --- a/src/Full_CI/EZFIO.cfg +++ b/src/Full_CI/EZFIO.cfg @@ -18,7 +18,7 @@ default: true [PT2_max] type: PT2_energy -doc: The selection process stops when the largest PT2 (for all the state is lower +doc: The selection process stops when the largest PT2 (for all the state) is lower than pt2_max in absolute value interface: input default: 0.0001 @@ -32,11 +32,11 @@ default: 0.75 [energy] type: double precision -doc: "Calculated Full CI energy" +doc: Calculated Selected FCI energy interface: output [energy_pt2] type: double precision -doc: "Calculated Full CI energy" +doc: Calculated FCI energy + PT2 interface: output diff --git a/src/Full_CI/NEEDED_MODULES b/src/Full_CI/NEEDED_MODULES index f2bb9ba7..5e074d3c 100644 --- a/src/Full_CI/NEEDED_MODULES +++ b/src/Full_CI/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Generators_full Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Generators_full Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils diff --git a/src/Generators_CAS/NEEDED_MODULES b/src/Generators_CAS/NEEDED_MODULES index 26097b8b..7f2f0ca8 100644 --- a/src/Generators_CAS/NEEDED_MODULES +++ b/src/Generators_CAS/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils diff --git a/src/Generators_full/NEEDED_MODULES b/src/Generators_full/NEEDED_MODULES index 3f5f6001..7d973bce 100644 --- a/src/Generators_full/NEEDED_MODULES +++ b/src/Generators_full/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Utils diff --git a/src/Generators_restart/NEEDED_MODULES b/src/Generators_restart/NEEDED_MODULES index 26097b8b..7f2f0ca8 100644 --- a/src/Generators_restart/NEEDED_MODULES +++ b/src/Generators_restart/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils diff --git a/src/Hartree_Fock/EZFIO.cfg b/src/Hartree_Fock/EZFIO.cfg new file mode 100644 index 00000000..e2b0ea5a --- /dev/null +++ b/src/Hartree_Fock/EZFIO.cfg @@ -0,0 +1,22 @@ +[thresh_scf] +type: Threshold +doc: Threshold on the convergence of the Hartree Fock energy +interface: input +default: 1.e-10 + +[n_it_scf_max] +type: Strictly_positive_int +doc: Maximum number of SCF iterations +interface: input +default: 200 + +[mo_guess_type] +type: MO_guess +doc: Initial MO guess. Can be [ Huckel | HCore ] +interface: input +default: Huckel + +[energy] +type: double precision +doc: Calculated HF energy +interface: output diff --git a/src/Hartree_Fock/NEEDED_MODULES b/src/Hartree_Fock/NEEDED_MODULES index 4ebba314..8f7f21c6 100644 --- a/src/Hartree_Fock/NEEDED_MODULES +++ b/src/Hartree_Fock/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask Electrons Ezfio_files MonoInts MOGuess MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Electrons Ezfio_files MonoInts MOGuess MOs Nuclei Output Utils diff --git a/src/Hartree_Fock/hartree_fock.ezfio_config b/src/Hartree_Fock/hartree_fock.ezfio_config deleted file mode 100644 index 3909f652..00000000 --- a/src/Hartree_Fock/hartree_fock.ezfio_config +++ /dev/null @@ -1,6 +0,0 @@ -hartree_fock - thresh_scf double precision - n_it_scf_max integer - energy double precision - guess character*(32) - diff --git a/src/Hartree_Fock/options.irp.f b/src/Hartree_Fock/options.irp.f deleted file mode 100644 index 22f86d6c..00000000 --- a/src/Hartree_Fock/options.irp.f +++ /dev/null @@ -1,35 +0,0 @@ -BEGIN_SHELL [ /usr/bin/python ] -from ezfio_with_default import EZFIO_Provider -T = EZFIO_Provider() -T.set_type ( "double precision" ) -T.set_name ( "thresh_SCF" ) -T.set_doc ( "Threshold on the convergence of the Hartree Fock energy" ) -T.set_ezfio_dir ( "Hartree_Fock" ) -T.set_ezfio_name( "thresh_SCF" ) -T.set_output ( "output_Hartree_Fock" ) -print T - -T = EZFIO_Provider() -T.set_type ( "integer" ) -T.set_name ( "n_it_scf_max" ) -T.set_doc ( "Maximum number of SCF iterations" ) -T.set_ezfio_dir ( "Hartree_Fock" ) -T.set_ezfio_name( "n_it_scf_max" ) -T.set_output ( "output_Hartree_Fock" ) -print T - -T = EZFIO_Provider() -T.set_type ( "character*(32)" ) -T.set_name ( "mo_guess_type" ) -T.set_doc ( "Initial MO guess. Can be [ Huckel | HCore ]" ) -T.set_ezfio_dir ( "Hartree_Fock" ) -T.set_ezfio_name( "guess" ) -T.set_output ( "output_Hartree_Fock" ) -print T - - -END_SHELL - - - - diff --git a/src/MP2/NEEDED_MODULES b/src/MP2/NEEDED_MODULES index 98fbcc58..076746d1 100644 --- a/src/MP2/NEEDED_MODULES +++ b/src/MP2/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full SingleRefMethod Utils diff --git a/src/MRCC/EZFIO.cfg b/src/MRCC/EZFIO.cfg index d596b785..ff586985 100644 --- a/src/MRCC/EZFIO.cfg +++ b/src/MRCC/EZFIO.cfg @@ -1,5 +1,4 @@ [energy] type: double precision -doc: "Calculated MRCC energy" -interface: output - +doc: Calculated MRCC energy +interface: output \ No newline at end of file diff --git a/src/MRCC/NEEDED_MODULES b/src/MRCC/NEEDED_MODULES index f2bb9ba7..5e074d3c 100644 --- a/src/MRCC/NEEDED_MODULES +++ b/src/MRCC/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Generators_full Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Generators_full Hartree_Fock MOGuess MonoInts MOs Nuclei Output Perturbation Properties Selectors_full Utils diff --git a/src/MRCC/README.rst b/src/MRCC/README.rst index 3720884a..73518f88 100644 --- a/src/MRCC/README.rst +++ b/src/MRCC/README.rst @@ -1,82 +1,9 @@ -E(CAS+SD) = -3.93510180989509 - - -0.726935163332 - ++++---- - ++++---- - - 0.685482292841 - +++-+--- - +++-+--- - - 0.0409791961003 - ++-+-+-- - ++-+-+-- - -c2*c3/c1 = -0.038642391672 - - - -0.996413146877 - ++++---- - ++++---- - - -0.0598366139154 - ++-+-+-- - +++-+--- - - -0.0598366139154 - +++-+--- - ++-+-+-- - - -======= - - 0.706616635698 - +++-+--- - +++-+--- - - -0.692594178414 - ++++---- - ++++---- - - -0.0915716740265 - ++-+-+-- - +++-+--- - - -0.0915716740265 - +++-+--- - ++-+-+-- - - 0.0461418323107 - ++-+-+-- - ++-+-+-- - - -0.0458957789452 - ++--++-- - ++--++-- - - ----- - - 0.713102867186 - ++++---- - ++++---- - - -0.688067688244 - +++-+--- - +++-+--- - - 0.089262694488 - +++-+--- - ++-+-+-- - - 0.089262694488 - ++-+-+-- - +++-+--- - - -0.0459510603899 - ++-+-+-- - ++-+-+-- - - +=========== +MRCC Module +=========== +Needed Modules +============== +Documentation +============= diff --git a/src/NEEDED_MODULES b/src/NEEDED_MODULES index 8f2f7a20..efe8b8f8 100644 --- a/src/NEEDED_MODULES +++ b/src/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask CID CID_SC2_selected CID_selected CIS CISD CISD_selected CISD_SC2_selected Dets Electrons Ezfio_files Full_CI Generators_full Hartree_Fock MOGuess MonoInts MOs MP2 Nuclei Output Selectors_full Utils Molden FCIdump Generators_CAS CAS_SD DDCI_selected MRCC +AOs Bielec_integrals Bitmask CID CID_SC2_selected CID_selected CIS CISD CISD_selected CISD_SC2_selected Dets Electrons Ezfio_files Full_CI Generators_full Hartree_Fock MOGuess MonoInts MOs MP2 Nuclei Output Selectors_full Utils Molden FCIdump Generators_CAS CAS_SD DDCI_selected MRCC diff --git a/src/Perturbation/NEEDED_MODULES b/src/Perturbation/NEEDED_MODULES index 4f7ab529..4fa6ff4b 100644 --- a/src/Perturbation/NEEDED_MODULES +++ b/src/Perturbation/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Properties Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Properties Utils diff --git a/src/Properties/NEEDED_MODULES b/src/Properties/NEEDED_MODULES index 8cf33c90..9095dbdf 100644 --- a/src/Properties/NEEDED_MODULES +++ b/src/Properties/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils diff --git a/src/Selectors_full/NEEDED_MODULES b/src/Selectors_full/NEEDED_MODULES index 3f5f6001..7d973bce 100644 --- a/src/Selectors_full/NEEDED_MODULES +++ b/src/Selectors_full/NEEDED_MODULES @@ -1,2 +1,2 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files Hartree_Fock MOGuess MonoInts MOs Nuclei Output Utils diff --git a/src/Selectors_no_sorted/NEEDED_MODULES b/src/Selectors_no_sorted/NEEDED_MODULES index 26097b8b..7f2f0ca8 100644 --- a/src/Selectors_no_sorted/NEEDED_MODULES +++ b/src/Selectors_no_sorted/NEEDED_MODULES @@ -1 +1 @@ -AOs BiInts Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils +AOs Bielec_integrals Bitmask Dets Electrons Ezfio_files MonoInts MOs Nuclei Output Utils diff --git a/tests/unit_test/unit_test.py b/tests/unit_test/unit_test.py new file mode 100755 index 00000000..eb9b1e79 --- /dev/null +++ b/tests/unit_test/unit_test.py @@ -0,0 +1,309 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import unittest +import subprocess +import os +import sys + +qpackage_root = os.environ['QPACKAGE_ROOT'] + +EZFIO = "{0}/EZFIO".format(qpackage_root) +sys.path = [EZFIO + "/Python"] + sys.path + +from ezfio import ezfio +from collections import defaultdict + +# ~#~#~ # +# O p t # +# ~#~#~ # + +precision = 5.e-8 + +# A test get a geo file and a basis file. +# A global dict containt the result for this test +# A test return True or Raise a error ! +# More ezfio condition you set, beter it is + + +# You cannot order the test flow. +# So if you dont whant to remarque on test (for example the HF), set +# a global variable and check for it +global has_hf_alredy +has_hf_alredy = False + +global filename_check + + +def init_folder(geo, basis, mult=1, ezfio_name=None): + ''' + Take a geo in arg (aka a existing geo.xyz in test/) + And create the geo.ezfio with the adeguate basis and multipliciti + DO NOT CHECK IS THE EZFIO FOLDER ALREADY EXIST + ''' + + cmd = "cp {0}/tests/{1}.xyz .".format(qpackage_root, geo) + subprocess.check_call([cmd], shell=True) + + if not ezfio_name: + ezfio_name = geo + + cmd = "qp_create_ezfio_from_xyz -b {0} -m {1} {2}.xyz -o {3}.ezfio" + subprocess.check_call([cmd.format(basis, mult, geo, ezfio_name)], + shell=True) + + +def get_error_message(l_exepected, l_cur): + l_msg = ["Need {0} get {1} error is {2}".format(i, j, abs(i - j)) + for i, j in zip(l_exepected, l_cur)] + return "\n".join(l_msg) + + +# _ +# / |_ _ _ | o ._ ._ _|_ +# \_ | | (/_ (_ |< | | | |_) |_| |_ +# | + +def check_disk_acess(geo, basis, mult=1): + + import uuid + filename = str(uuid.uuid4()) + + # ~#~#~#~ # + # I n i t # + # ~#~#~#~ # + + init_folder(geo, basis, mult, ezfio_name=filename) + ezfio.set_file("{0}.ezfio".format(filename)) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + # S e t _ p a r a m e t e r # + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + + # Test 1 + ezfio.bielec_integrals_disk_access_ao_integrals = "Write" + cmd = "qp_edit -c {0}.ezfio".format(filename) + subprocess.check_call([cmd], shell=True) + + # Test 2 + ezfio.bielec_integrals_disk_access_ao_integrals = "IculeAcess" + cmd = "qp_edit -c {0}.ezfio".format(filename) + + try: + subprocess.check_call([cmd], shell=True) + return_code = False + except subprocess.CalledProcessError: + return_code = True + + # ~#~#~#~#~#~#~#~ # + # F i n a l i z e # + # ~#~#~#~#~#~#~#~ # + + if return_code: + subprocess.call(["rm -R {0}.ezfio".format(filename)], shell=True) + return return_code + + +def check_mo_guess(geo, basis, mult=1): + + import uuid + filename = str(uuid.uuid4()) + + # ~#~#~#~ # + # I n i t # + # ~#~#~#~ # + + init_folder(geo, basis, mult, ezfio_name=filename) + ezfio.set_file("{0}.ezfio".format(filename)) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + # S e t _ p a r a m e t e r # + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + + # Test 1 + ezfio.hartree_fock_mo_guess_type = "Huckel" + cmd = "qp_edit -c {0}.ezfio".format(filename) + subprocess.check_call([cmd], shell=True) + + # Test 2 + ezfio.hartree_fock_mo_guess_type = "IculeGuess" + cmd = "qp_edit -c {0}.ezfio".format(filename) + + try: + subprocess.check_call([cmd], shell=True) + return_code = False + except subprocess.CalledProcessError: + return_code = True + + # ~#~#~#~#~#~#~#~ # + # F i n a l i z e # + # ~#~#~#~#~#~#~#~ # + + if return_code: + subprocess.call(["rm -R {0}.ezfio".format(filename)], shell=True) + return return_code + + +# _ +# / |_ _ _ | _. | _ _ +# \_ | | (/_ (_ |< \/ (_| | |_| (/_ _> +# + + +def run_hf(geo, basis, mult=1): + """ + Run a simle by default hf + EZFIO path = geo.ezfio + """ + # ~#~#~#~#~#~#~#~#~#~ # + # R e f _ e n e r g y # + # ~#~#~#~#~#~#~#~#~#~ # + + ref_energy = defaultdict(dict) + + ref_energy["sto-3g"]["methane"] = -39.7267433402 + + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~#~ # + # G l o b a l _ v a r i a b l e # + # ~#~#~#~#~#~#~#~#~#~#~#~#~#~#~ # + + global has_hf_alredy + has_hf_alredy = True + + # ~#~#~#~ # + # I n i t # + # ~#~#~#~ # + + init_folder(geo, basis, mult) + ezfio.set_file("{0}.ezfio".format(geo)) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + # S e t _ p a r a m e t e r # + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + ezfio.bielec_integrals_direct = False + ezfio.bielec_integrals_threshold_ao = 1.e-15 + ezfio.bielec_integrals_disk_access_ao_integrals = "None" + + ezfio.bielec_integrals_threshold_mo = 1.e-15 + ezfio.bielec_integrals_disk_access_mo_integrals = "None" + + ezfio.hartree_fock_mo_guess_type = "Huckel" + ezfio.hartree_fock_thresh_scf = 1.e-10 + ezfio.hartree_fock_n_it_scf_max = 100 + + # ~#~#~ # + # R u n # + # ~#~#~ # + + cmd = "qp_run SCF {0}.ezfio/".format(geo) + subprocess.check_call([cmd], shell=True) + + # ~#~#~#~#~ # + # C h e c k # + # ~#~#~#~#~ # + + cur_e = ezfio.get_hartree_fock_energy() + ref_e = ref_energy[basis][geo] + + if abs(cur_e - ref_e) <= precision: + return True + else: + raise ValueError(get_error_message([ref_e], [cur_e])) + + +def run_full_ci_10k_pt2_end(geo, basis): + """ + Run a Full_ci with 10k with the TruePT2 + EZFIO path = geo.ezfio + """ + + # ~#~#~#~#~#~#~#~#~#~ # + # R e f _ e n e r g y # + # ~#~#~#~#~#~#~#~#~#~ # + + ref_energy_var = defaultdict(dict) + ref_energy_pt2 = defaultdict(dict) + + ref_energy_var["sto-3g"]["methane"] = -0.398058753535695E+02 + ref_energy_pt2["sto-3g"]["methane"] = -0.398059182483741E+02 + + # ~#~#~#~ # + # I n i t # + # ~#~#~#~ # + + ezfio.set_file("{0}.ezfio".format(geo)) + + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + # S e t _ p a r a m e t e r # + # ~#~#~#~#~#~#~#~#~#~#~#~#~ # + + ezfio.full_ci_do_pt2_end = True + ezfio.full_ci_n_det_max_fci = 10000 + ezfio.full_ci_pt2_max = 1.e-8 + + # ~#~#~ # + # R u n # + # ~#~#~ # + + cmd = "qp_run full_ci {0}.ezfio/".format(geo) + subprocess.check_call([cmd], shell=True) + + # ~#~#~#~#~ # + # C h e c k # + # ~#~#~#~#~ # + + cur_var = ezfio.get_full_ci_energy() + cur_pt2 = ezfio.get_full_ci_energy_pt2() + + ref_var = ref_energy_var[basis][geo] + ref_pt2 = ref_energy_pt2[basis][geo] + + t = [abs(cur_var - ref_var) <= precision, + abs(cur_pt2 - ref_pt2) <= precision] + + if all(t): + return True + else: + raise ValueError(get_error_message([ref_var, ref_pt2], + [cur_var, cur_pt2])) + + +def hf_then_10k_test(geo, basis): + if not has_hf_alredy: + run_hf(geo, basis) + + try: + run_full_ci_10k_pt2_end(geo, basis) + return_code = True + except: + return_code = False + + # ~#~#~#~#~#~#~#~ # + # F i n a l i z e # + # ~#~#~#~#~#~#~#~ # + + if return_code: + subprocess.call(["rm -R {0}.ezfio".format(geo)], shell=True) + return return_code + + +# ___ +# | _ _ _|_ +# | (/_ _> |_ +# +class ValueTest(unittest.TestCase): + + def test_full_ci_10k_pt2_end(self): + self.assertTrue(hf_then_10k_test("methane", "sto-3g")) + + +class InputTest(unittest.TestCase): + + def test_check_disk_acess(self): + self.assertTrue(check_disk_acess("methane", "un-ccemd-ref")) + + def test_check_mo_guess(self): + self.assertTrue(check_mo_guess("methane", "maug-cc-pVDZ")) + + +if __name__ == '__main__': + unittest.main()