diff --git a/README.md b/README.md index 5eb562e..1b3f91a 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,10 @@ QMC=Chem : Quantum Monte Carlo for Chemistry ============================================ -**This repository is under migration to GitHub. Please be patient...** +**This repository is under migration to GitHub. This version may not be fully working. Please be patient...** QMC=Chem is the quantum Monte Carlo program of the -[Toulouse group](http://qmcchem.ups-tlse.fr). +[Toulouse (France) group](http://qmcchem.ups-tlse.fr). It is meant to be used in the *post-Full-CI* context : a quasi-Full-CI calculation is done with the [quantum package](https://github.com/LCPQ/quantum_package), @@ -57,14 +57,17 @@ library need to be installed manually by the user. Installation ------------ -This script will first download the [Ninja](http://github.com/martine/ninja) -build tool, and will then run Ninja using the ``install/build.ninja`` file. -The configuration script will work in the ``install`` directory. It will first -download into the ``install/Downloads`` directory everything that needs to be -installed. The building of the dependencies takes place in the ``install/_build`` -directory, and the packages that are being installed can be followed by looking -at the log files in this directory. When a package was successfully installed, -a ``*.ok`` file is created and the log file is deleted. +The ``make.config`` file contains compiler specific parameters. + +The ``configure.sh`` script will first download the +[Ninja](http://github.com/martine/ninja) build tool, and will then run Ninja +using the ``install/build.ninja`` file. The configuration script will work in +the ``install`` directory. It will first download into the +``install/Downloads`` directory everything that needs to be installed. The +building of the dependencies takes place in the ``install/_build`` directory, +and the packages that are being installed can be followed by looking at the log +files in this directory. When a package was successfully installed, a ``*.ok`` +file is created and the log file is deleted. Before using or compiling QMC=Chem, environment variables need to be loaded. The environment variables are located in the ``qmcchemrc`` file: diff --git a/build.ninja b/build.ninja index ec8597b..cd2a4ca 100644 --- a/build.ninja +++ b/build.ninja @@ -44,7 +44,7 @@ rule clean # put all files of PROPERTIES here # -------------------------------- -build ezfio_config/properties.config: build_properties_config | src/PROPERTIES/density.irp.f src/PROPERTIES/properties.irp.f src/PROPERTIES/properties_energy.irp.f src/PROPERTIES/voronoi.irp.f src/PROPERTIES/properties_general.irp.f scripts/create_properties_python.py || src/IRPF90_temp/build.ninja +build ezfio_config/properties.config: build_properties_config | scripts/create_properties_python.py src/PROPERTIES/properties.irp.f src/PROPERTIES/properties_energy.irp.f src/PROPERTIES/properties_general.irp.f || src/IRPF90_temp/build.ninja # EZFIO # ----- @@ -58,7 +58,7 @@ build always: phony build src/tags src/irpf90_entities src/irpf90.make src/IRPF90_temp/build.ninja: compile_irpf90 | make.config always -build src/MAIN/qmc src/MAIN/qmc_nozmq src/MAIN/qmc_create_walkers src/MAIN/qmcchem_info: compile_src | lib/libezfio.a lib/libezfio_irp.a src/tags || src/irpf90_entities src/irpf90.make src/IRPF90_temp/build.ninja +build src/MAIN/qmc src/MAIN/qmc_create_walkers src/MAIN/qmcchem_info: compile_src | lib/libezfio.a lib/libezfio_irp.a src/tags || src/irpf90_entities src/irpf90.make src/IRPF90_temp/build.ninja # Archive # ------- @@ -68,7 +68,7 @@ build qmcchem.tar.gz: create_archive # Ocaml # ----- -build ocaml/generated.ninja : compile_ocaml_dep | always +build ocaml/generated.ninja : compile_ocaml_dep | EZFIO/Ocaml/ezfio.ml always build ocaml/qmcchem : compile_ocaml | ocaml/generated.ninja EZFIO/Ocaml/ezfio.ml target = qmcchem @@ -79,10 +79,9 @@ build ocaml/qmcchem : compile_ocaml | ocaml/generated.ninja EZFIO/Ocaml/ezfio.ml build bin/qmc: copy_to_bin src/MAIN/qmc build bin/qmcchem_info: copy_to_bin src/MAIN/qmcchem_info build bin/qmc_create_walkers: copy_to_bin src/MAIN/qmc_create_walkers -build bin/qmc_nozmq: copy_to_bin src/MAIN/qmc_nozmq build bin/qmcchem: copy_to_bin ocaml/qmcchem -default bin/qmc bin/qmcchem_info bin/qmc_create_walkers bin/qmc_nozmq bin/qmcchem +default bin/qmc bin/qmcchem_info bin/qmc_create_walkers bin/qmcchem # Clean # ----- diff --git a/install/build.ninja b/install/build.ninja index 9d6a811..b2310a4 100644 --- a/install/build.ninja +++ b/install/build.ninja @@ -20,7 +20,7 @@ rule download rule install command = ./scripts/install_${target}.sh > _build/${target}.log 2>&1 && touch _build/${target}.ok || cat _build/${target}.log - description = Installing ${descr} \t| tail -f install/_build/${target}.log + description = Installing ${descr} | tail -f install/_build/${target}.log # Builds diff --git a/make.config b/make.config new file mode 100644 index 0000000..504ffba --- /dev/null +++ b/make.config @@ -0,0 +1,22 @@ +# CPU type + +## ALIGNMENT + +#CPU_TYPE="-xCORE-AVX2" # [ Host | CORE-AVX2 | CORE-AVX-I | AVX | SSE4.2 ] +CPU_TYPE="-xHost" + +# Array alignment (Bytes) +ALIGN="32" + +## FORTRAN compiler +FC="ifort" +NINJA="ninja" +FCFLAGS="-O2 -g -ip -ftz -finline ${CPU_TYPE}" #-traceback +LIB="-mkl=sequential" + +## IRPF90 +IRPF90="${QMCCHEM_PATH}/bin/irpf90" +IRPF90_FLAGS="--align=${ALIGN} ${IRPF90_FLAGS}" + +export FC NINJA FCFLAGS LIB IRPF90 IRPF90_FLAGS + diff --git a/ocaml/Qptypes.ml b/ocaml/Qptypes.ml deleted file mode 100644 index 091df99..0000000 --- a/ocaml/Qptypes.ml +++ /dev/null @@ -1,830 +0,0 @@ -open Core.Std -let warning = print_string - - - -module Positive_float : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x >= 0.) ; x ) - let to_string x = Float.to_string x -end - - -module Strictly_positive_float : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x > 0.) ; x ) - let to_string x = Float.to_string x -end - - -module Negative_float : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x <= 0.) ; x ) - let to_string x = Float.to_string x -end - - -module Strictly_negative_float : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x < 0.) ; x ) - let to_string x = Float.to_string x -end - - -module Positive_int : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x >= 0) ; x ) - let to_string x = Int.to_string x -end - - -module Strictly_positive_int : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x > 0) ; x ) - let to_string x = Int.to_string x -end - - -module Negative_int : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x <= 0) ; x ) - let to_string x = Int.to_string x -end - - -module Det_coef : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x >= -1.) ; - assert (x <= 1.) ; x ) - let to_string x = Float.to_string x -end - - -module Normalized_float : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x <= 1.) ; - assert (x >= 0.) ; x ) - let to_string x = Float.to_string x -end - - -module Strictly_negative_int : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x < 0) ; x ) - let to_string x = Int.to_string x -end - - -module Non_empty_string : sig - type t with sexp - val to_string : t -> string - val of_string : string -> t - val to_string : t -> string -end = struct - type t = string with sexp - let to_string x = x - let of_string x = ( assert (x <> "") ; x ) - let to_string x = String.to_string x -end - - -module Det_number_max : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x > 0) ; - if (x > 100000000) then - warning "More than 100 million determinants"; x ) - let to_string x = Int.to_string x -end - - -module MO_coef : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( x ) - let to_string x = Float.to_string x -end - - -module MO_occ : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x >= 0.); x ) - let to_string x = Float.to_string x -end - - -module AO_coef : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( x ) - let to_string x = Float.to_string x -end - - -module AO_expo : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x >= 0.) ; x ) - let to_string x = Float.to_string x -end - - -module AO_prim_number : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x > 0) ; x ) - let to_string x = Int.to_string x -end - - -module Threshold : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x >= 0.) ; - assert (x <= 1.) ; x ) - let to_string x = Float.to_string x -end - - -module PT2_energy : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x >=0.) ; x ) - let to_string x = Float.to_string x -end - - -module Elec_alpha_number : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x > 0) ; x ) - let to_string x = Int.to_string x -end - - -module Elec_beta_number : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x >= 0) ; x ) - let to_string x = Int.to_string x -end - - -module Elec_number : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x > 0) ; x ) - let to_string x = Int.to_string x -end - - -module MD5 : sig - type t with sexp - val to_string : t -> string - val of_string : string -> t - val to_string : t -> string -end = struct - type t = string with sexp - let to_string x = x - let of_string x = ( assert ((String.length x) = 32); x ) - let to_string x = String.to_string x -end - - -module Rst_string : sig - type t with sexp - val to_string : t -> string - val of_string : string -> t - val to_string : t -> string -end = struct - type t = string with sexp - let to_string x = x - let of_string x = ( x ) - let to_string x = String.to_string x -end - - -module Weight : sig - type t with sexp - val to_float : t -> float - val of_float : float -> t - val to_string : t -> string -end = struct - type t = float with sexp - let to_float x = x - let of_float x = ( assert (x >= 0.) ; x ) - let to_string x = Float.to_string x -end - - -module Block_id : sig - type t with sexp - val to_int : t -> int - val of_int : int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_int x = x - let of_int x = ( assert (x > 0) ; x ) - let to_string x = Int.to_string x -end - - -module Compute_node : sig - type t with sexp - val to_string : t -> string - val of_string : string -> t - val to_string : t -> string -end = struct - type t = string with sexp - let to_string x = x - let of_string x = ( assert (x <> "") ; x ) - let to_string x = String.to_string x -end - - - -module MO_number : sig - type t with sexp - val to_int : t -> int - val get_max : unit -> int - val of_int : ?min:int -> ?max:int -> int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_string x = Int.to_string x - let get_max () = - if (Ezfio.has_mo_basis_mo_tot_num ()) then - Ezfio.get_mo_basis_mo_tot_num () - else - 10000 - let get_min () = - 1 - let to_int x = x - let of_int ?(min=get_min ()) ?(max=get_max ()) x = - begin - assert (x >= min) ; - if (x > 10000) then - warning "More than 10000 MOs"; - begin - match max with - | 1 -> () - | i -> assert ( x <= i ) - end ; - x - end -end - -module AO_number : sig - type t with sexp - val to_int : t -> int - val get_max : unit -> int - val of_int : ?min:int -> ?max:int -> int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_string x = Int.to_string x - let get_max () = - if (Ezfio.has_ao_basis_ao_num ()) then - Ezfio.get_ao_basis_ao_num () - else - 10000 - let get_min () = - 1 - let to_int x = x - let of_int ?(min=get_min ()) ?(max=get_max ()) x = - begin - assert (x >= min) ; - if (x > 10000) then - warning "More than 10000 AOs"; - begin - match max with - | 1 -> () - | i -> assert ( x <= i ) - end ; - x - end -end - -module Nucl_number : sig - type t with sexp - val to_int : t -> int - val get_max : unit -> int - val of_int : ?min:int -> ?max:int -> int -> t - val to_string : t -> string -end = struct - type t = int with sexp - let to_string x = Int.to_string x - let get_max () = - if (Ezfio.has_nuclei_nucl_num ()) then - Ezfio.get_nuclei_nucl_num () - else - 10000 - let get_min () = - 1 - let to_int x = x - let of_int ?(min=get_min ()) ?(max=get_max ()) x = - begin - assert (x >= min) ; - if (x > 10000) then - warning "More than 10000 nuclei"; - begin - match max with - | 1 -> () - | i -> assert ( x <= i ) - end ; - x - end -end - -let decode_ezfio_message msg = -match msg with - | "get_blocks_empty" -> Ezfio.read_string "blocks" "empty" - | "get_mo_basis_mo_tot_num" -> Ezfio.read_string "mo_basis" "mo_tot_num" - | "get_mo_basis_mo_coef" -> - Ezfio.read_string_array "mo_basis" "mo_coef" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_mo_basis_mo_classif" -> - Ezfio.read_string_array "mo_basis" "mo_classif" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_mo_basis_mo_energy" -> - Ezfio.read_string_array "mo_basis" "mo_energy" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_mo_basis_mo_occ" -> - Ezfio.read_string_array "mo_basis" "mo_occ" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_mo_basis_mo_symmetry" -> - Ezfio.read_string_array "mo_basis" "mo_symmetry" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_ao_pseudo_grid" -> - Ezfio.read_string_array "pseudo" "ao_pseudo_grid" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_do_pseudo" -> Ezfio.read_string "pseudo" "do_pseudo" - | "get_pseudo_mo_pseudo_grid" -> - Ezfio.read_string_array "pseudo" "mo_pseudo_grid" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_pseudo_dz_k" -> - Ezfio.read_string_array "pseudo" "pseudo_dz_k" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_pseudo_dz_kl" -> - Ezfio.read_string_array "pseudo" "pseudo_dz_kl" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_pseudo_grid_rmax" -> Ezfio.read_string "pseudo" "pseudo_grid_rmax" - | "get_pseudo_pseudo_grid_size" -> Ezfio.read_string "pseudo" "pseudo_grid_size" - | "get_pseudo_pseudo_klocmax" -> Ezfio.read_string "pseudo" "pseudo_klocmax" - | "get_pseudo_pseudo_kmax" -> Ezfio.read_string "pseudo" "pseudo_kmax" - | "get_pseudo_pseudo_lmax" -> Ezfio.read_string "pseudo" "pseudo_lmax" - | "get_pseudo_pseudo_n_k" -> - Ezfio.read_string_array "pseudo" "pseudo_n_k" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_pseudo_n_kl" -> - Ezfio.read_string_array "pseudo" "pseudo_n_kl" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_pseudo_v_k" -> - Ezfio.read_string_array "pseudo" "pseudo_v_k" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_pseudo_pseudo_v_kl" -> - Ezfio.read_string_array "pseudo" "pseudo_v_kl" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_ezfio_creation" -> Ezfio.read_string "ezfio" "creation" - | "get_ezfio_user" -> Ezfio.read_string "ezfio" "user" - | "get_ezfio_library" -> Ezfio.read_string "ezfio" "library" - | "get_ezfio_last_library" -> Ezfio.read_string "ezfio" "last_library" - | "get_simulation_do_run" -> Ezfio.read_string "simulation" "do_run" - | "get_simulation_stop_time" -> Ezfio.read_string "simulation" "stop_time" - | "get_simulation_equilibration" -> Ezfio.read_string "simulation" "equilibration" - | "get_simulation_title" -> Ezfio.read_string "simulation" "title" - | "get_simulation_http_server" -> Ezfio.read_string "simulation" "http_server" - | "get_simulation_do_jast" -> Ezfio.read_string "simulation" "do_jast" - | "get_simulation_do_nucl_fitcusp" -> Ezfio.read_string "simulation" "do_nucl_fitcusp" - | "get_simulation_method" -> Ezfio.read_string "simulation" "method" - | "get_simulation_block_time" -> Ezfio.read_string "simulation" "block_time" - | "get_simulation_sampling" -> Ezfio.read_string "simulation" "sampling" - | "get_simulation_save_data" -> Ezfio.read_string "simulation" "save_data" - | "get_simulation_time_step" -> Ezfio.read_string "simulation" "time_step" - | "get_simulation_print_level" -> Ezfio.read_string "simulation" "print_level" - | "get_simulation_ci_threshold" -> Ezfio.read_string "simulation" "ci_threshold" - | "get_simulation_md5_key" -> Ezfio.read_string "simulation" "md5_key" - | "get_simulation_orig_time" -> Ezfio.read_string "simulation" "orig_time" - | "get_simulation_e_ref" -> Ezfio.read_string "simulation" "e_ref" - | "get_spindeterminants_n_det_alpha" -> Ezfio.read_string "spindeterminants" "n_det_alpha" - | "get_spindeterminants_n_det_beta" -> Ezfio.read_string "spindeterminants" "n_det_beta" - | "get_spindeterminants_n_det" -> Ezfio.read_string "spindeterminants" "n_det" - | "get_spindeterminants_n_int" -> Ezfio.read_string "spindeterminants" "n_int" - | "get_spindeterminants_bit_kind" -> Ezfio.read_string "spindeterminants" "bit_kind" - | "get_spindeterminants_n_states" -> Ezfio.read_string "spindeterminants" "n_states" - | "get_spindeterminants_psi_det_alpha" -> - Ezfio.read_string_array "spindeterminants" "psi_det_alpha" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_spindeterminants_psi_det_beta" -> - Ezfio.read_string_array "spindeterminants" "psi_det_beta" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_spindeterminants_psi_coef_matrix_rows" -> - Ezfio.read_string_array "spindeterminants" "psi_coef_matrix_rows" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_spindeterminants_psi_coef_matrix_columns" -> - Ezfio.read_string_array "spindeterminants" "psi_coef_matrix_columns" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_spindeterminants_psi_coef_matrix_values" -> - Ezfio.read_string_array "spindeterminants" "psi_coef_matrix_values" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_ao_basis_ao_num" -> Ezfio.read_string "ao_basis" "ao_num" - | "get_ao_basis_ao_prim_num" -> - Ezfio.read_string_array "ao_basis" "ao_prim_num" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_ao_basis_ao_nucl" -> - Ezfio.read_string_array "ao_basis" "ao_nucl" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_ao_basis_ao_power" -> - Ezfio.read_string_array "ao_basis" "ao_power" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_ao_basis_ao_coef" -> - Ezfio.read_string_array "ao_basis" "ao_coef" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_ao_basis_ao_expo" -> - Ezfio.read_string_array "ao_basis" "ao_expo" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_electrons_elec_alpha_num" -> Ezfio.read_string "electrons" "elec_alpha_num" - | "get_electrons_elec_beta_num" -> Ezfio.read_string "electrons" "elec_beta_num" - | "get_electrons_elec_walk_num_tot" -> Ezfio.read_string "electrons" "elec_walk_num_tot" - | "get_electrons_elec_walk_num" -> Ezfio.read_string "electrons" "elec_walk_num" - | "get_electrons_elec_coord_pool" -> - Ezfio.read_string_array "electrons" "elec_coord_pool" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_electrons_elec_coord_pool_size" -> Ezfio.read_string "electrons" "elec_coord_pool_size" - | "get_electrons_elec_fitcusp_radius" -> Ezfio.read_string "electrons" "elec_fitcusp_radius" - | "get_jastrow_jast_type" -> Ezfio.read_string "jastrow" "jast_type" - | "get_jastrow_jast_a_up_up" -> Ezfio.read_string "jastrow" "jast_a_up_up" - | "get_jastrow_jast_a_up_dn" -> Ezfio.read_string "jastrow" "jast_a_up_dn" - | "get_jastrow_jast_b_up_up" -> Ezfio.read_string "jastrow" "jast_b_up_up" - | "get_jastrow_jast_b_up_dn" -> Ezfio.read_string "jastrow" "jast_b_up_dn" - | "get_jastrow_jast_pen" -> - Ezfio.read_string_array "jastrow" "jast_pen" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_jastrow_jast_een_e_a" -> - Ezfio.read_string_array "jastrow" "jast_een_e_a" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_jastrow_jast_een_e_b" -> - Ezfio.read_string_array "jastrow" "jast_een_e_b" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_jastrow_jast_een_n" -> - Ezfio.read_string_array "jastrow" "jast_een_n" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_jastrow_jast_core_a1" -> - Ezfio.read_string_array "jastrow" "jast_core_a1" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_jastrow_jast_core_a2" -> - Ezfio.read_string_array "jastrow" "jast_core_a2" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_jastrow_jast_core_b1" -> - Ezfio.read_string_array "jastrow" "jast_core_b1" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_jastrow_jast_core_b2" -> - Ezfio.read_string_array "jastrow" "jast_core_b2" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_nuclei_nucl_num" -> Ezfio.read_string "nuclei" "nucl_num" - | "get_nuclei_nucl_label" -> - Ezfio.read_string_array "nuclei" "nucl_label" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_nuclei_nucl_charge" -> - Ezfio.read_string_array "nuclei" "nucl_charge" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_nuclei_nucl_coord" -> - Ezfio.read_string_array "nuclei" "nucl_coord" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_nuclei_nucl_fitcusp_radius" -> - Ezfio.read_string_array "nuclei" "nucl_fitcusp_radius" - |> Ezfio.flattened_ezfio - |> Array.to_list - |> String.concat ~sep:" " - | "get_properties_d_var_jast_a_up_dn" -> Ezfio.read_string "properties" "d_var_jast_a_up_dn" - | "get_properties_d_var_jast_a_up_up" -> Ezfio.read_string "properties" "d_var_jast_a_up_up" - | "get_properties_d_var_jast_b_up_dn" -> Ezfio.read_string "properties" "d_var_jast_b_up_dn" - | "get_properties_d_var_jast_b_up_up" -> Ezfio.read_string "properties" "d_var_jast_b_up_up" - | "get_properties_d_var_jast_core_a1" -> Ezfio.read_string "properties" "d_var_jast_core_a1" - | "get_properties_d_var_jast_core_b1" -> Ezfio.read_string "properties" "d_var_jast_core_b1" - | "get_properties_d_var_jast_een_e_a" -> Ezfio.read_string "properties" "d_var_jast_een_e_a" - | "get_properties_d_var_jast_een_e_b" -> Ezfio.read_string "properties" "d_var_jast_een_e_b" - | "get_properties_d_var_jast_een_n" -> Ezfio.read_string "properties" "d_var_jast_een_n" - | "get_properties_d_var_jast_pen" -> Ezfio.read_string "properties" "d_var_jast_pen" - | "get_properties_density1d" -> Ezfio.read_string "properties" "density1d" - | "get_properties_dipole" -> Ezfio.read_string "properties" "dipole" - | "get_properties_drift_mod" -> Ezfio.read_string "properties" "drift_mod" - | "get_properties_e_kin" -> Ezfio.read_string "properties" "e_kin" - | "get_properties_e_loc" -> Ezfio.read_string "properties" "e_loc" - | "get_properties_e_loc_one" -> Ezfio.read_string "properties" "e_loc_one" - | "get_properties_e_loc_per_electron" -> Ezfio.read_string "properties" "e_loc_per_electron" - | "get_properties_e_loc_split_core" -> Ezfio.read_string "properties" "e_loc_split_core" - | "get_properties_e_loc_two" -> Ezfio.read_string "properties" "e_loc_two" - | "get_properties_e_nucl" -> Ezfio.read_string "properties" "e_nucl" - | "get_properties_e_pot" -> Ezfio.read_string "properties" "e_pot" - | "get_properties_e_pot_one" -> Ezfio.read_string "properties" "e_pot_one" - | "get_properties_n_s_inverted" -> Ezfio.read_string "properties" "n_s_inverted" - | "get_properties_n_s_updated" -> Ezfio.read_string "properties" "n_s_updated" - | "get_properties_n_s_updates" -> Ezfio.read_string "properties" "n_s_updates" - | "get_properties_voronoi_charges" -> Ezfio.read_string "properties" "voronoi_charges" - | "get_properties_voronoi_charges_covariance" -> Ezfio.read_string "properties" "voronoi_charges_covariance" - | "get_properties_voronoi_dipoles" -> Ezfio.read_string "properties" "voronoi_dipoles" - | "get_properties_wf_extension" -> Ezfio.read_string "properties" "wf_extension" - | "has_blocks_empty" -> if (Ezfio.has_blocks_empty ()) then "T" else "F" - | "has_mo_basis_mo_tot_num" -> if (Ezfio.has_mo_basis_mo_tot_num ()) then "T" else "F" - | "has_mo_basis_mo_coef" -> if (Ezfio.has_mo_basis_mo_coef ()) then "T" else "F" - | "has_mo_basis_mo_classif" -> if (Ezfio.has_mo_basis_mo_classif ()) then "T" else "F" - | "has_mo_basis_mo_energy" -> if (Ezfio.has_mo_basis_mo_energy ()) then "T" else "F" - | "has_mo_basis_mo_occ" -> if (Ezfio.has_mo_basis_mo_occ ()) then "T" else "F" - | "has_mo_basis_mo_symmetry" -> if (Ezfio.has_mo_basis_mo_symmetry ()) then "T" else "F" - | "has_pseudo_ao_pseudo_grid" -> if (Ezfio.has_pseudo_ao_pseudo_grid ()) then "T" else "F" - | "has_pseudo_do_pseudo" -> if (Ezfio.has_pseudo_do_pseudo ()) then "T" else "F" - | "has_pseudo_mo_pseudo_grid" -> if (Ezfio.has_pseudo_mo_pseudo_grid ()) then "T" else "F" - | "has_pseudo_pseudo_dz_k" -> if (Ezfio.has_pseudo_pseudo_dz_k ()) then "T" else "F" - | "has_pseudo_pseudo_dz_kl" -> if (Ezfio.has_pseudo_pseudo_dz_kl ()) then "T" else "F" - | "has_pseudo_pseudo_grid_rmax" -> if (Ezfio.has_pseudo_pseudo_grid_rmax ()) then "T" else "F" - | "has_pseudo_pseudo_grid_size" -> if (Ezfio.has_pseudo_pseudo_grid_size ()) then "T" else "F" - | "has_pseudo_pseudo_klocmax" -> if (Ezfio.has_pseudo_pseudo_klocmax ()) then "T" else "F" - | "has_pseudo_pseudo_kmax" -> if (Ezfio.has_pseudo_pseudo_kmax ()) then "T" else "F" - | "has_pseudo_pseudo_lmax" -> if (Ezfio.has_pseudo_pseudo_lmax ()) then "T" else "F" - | "has_pseudo_pseudo_n_k" -> if (Ezfio.has_pseudo_pseudo_n_k ()) then "T" else "F" - | "has_pseudo_pseudo_n_kl" -> if (Ezfio.has_pseudo_pseudo_n_kl ()) then "T" else "F" - | "has_pseudo_pseudo_v_k" -> if (Ezfio.has_pseudo_pseudo_v_k ()) then "T" else "F" - | "has_pseudo_pseudo_v_kl" -> if (Ezfio.has_pseudo_pseudo_v_kl ()) then "T" else "F" - | "has_ezfio_creation" -> if (Ezfio.has_ezfio_creation ()) then "T" else "F" - | "has_ezfio_user" -> if (Ezfio.has_ezfio_user ()) then "T" else "F" - | "has_ezfio_library" -> if (Ezfio.has_ezfio_library ()) then "T" else "F" - | "has_ezfio_last_library" -> if (Ezfio.has_ezfio_last_library ()) then "T" else "F" - | "has_simulation_do_run" -> if (Ezfio.has_simulation_do_run ()) then "T" else "F" - | "has_simulation_stop_time" -> if (Ezfio.has_simulation_stop_time ()) then "T" else "F" - | "has_simulation_equilibration" -> if (Ezfio.has_simulation_equilibration ()) then "T" else "F" - | "has_simulation_title" -> if (Ezfio.has_simulation_title ()) then "T" else "F" - | "has_simulation_http_server" -> if (Ezfio.has_simulation_http_server ()) then "T" else "F" - | "has_simulation_do_jast" -> if (Ezfio.has_simulation_do_jast ()) then "T" else "F" - | "has_simulation_do_nucl_fitcusp" -> if (Ezfio.has_simulation_do_nucl_fitcusp ()) then "T" else "F" - | "has_simulation_method" -> if (Ezfio.has_simulation_method ()) then "T" else "F" - | "has_simulation_block_time" -> if (Ezfio.has_simulation_block_time ()) then "T" else "F" - | "has_simulation_sampling" -> if (Ezfio.has_simulation_sampling ()) then "T" else "F" - | "has_simulation_save_data" -> if (Ezfio.has_simulation_save_data ()) then "T" else "F" - | "has_simulation_time_step" -> if (Ezfio.has_simulation_time_step ()) then "T" else "F" - | "has_simulation_print_level" -> if (Ezfio.has_simulation_print_level ()) then "T" else "F" - | "has_simulation_ci_threshold" -> if (Ezfio.has_simulation_ci_threshold ()) then "T" else "F" - | "has_simulation_md5_key" -> if (Ezfio.has_simulation_md5_key ()) then "T" else "F" - | "has_simulation_orig_time" -> if (Ezfio.has_simulation_orig_time ()) then "T" else "F" - | "has_simulation_e_ref" -> if (Ezfio.has_simulation_e_ref ()) then "T" else "F" - | "has_spindeterminants_n_det_alpha" -> if (Ezfio.has_spindeterminants_n_det_alpha ()) then "T" else "F" - | "has_spindeterminants_n_det_beta" -> if (Ezfio.has_spindeterminants_n_det_beta ()) then "T" else "F" - | "has_spindeterminants_n_det" -> if (Ezfio.has_spindeterminants_n_det ()) then "T" else "F" - | "has_spindeterminants_n_int" -> if (Ezfio.has_spindeterminants_n_int ()) then "T" else "F" - | "has_spindeterminants_bit_kind" -> if (Ezfio.has_spindeterminants_bit_kind ()) then "T" else "F" - | "has_spindeterminants_n_states" -> if (Ezfio.has_spindeterminants_n_states ()) then "T" else "F" - | "has_spindeterminants_psi_det_alpha" -> if (Ezfio.has_spindeterminants_psi_det_alpha ()) then "T" else "F" - | "has_spindeterminants_psi_det_beta" -> if (Ezfio.has_spindeterminants_psi_det_beta ()) then "T" else "F" - | "has_spindeterminants_psi_coef_matrix_rows" -> if (Ezfio.has_spindeterminants_psi_coef_matrix_rows ()) then "T" else "F" - | "has_spindeterminants_psi_coef_matrix_columns" -> if (Ezfio.has_spindeterminants_psi_coef_matrix_columns ()) then "T" else "F" - | "has_spindeterminants_psi_coef_matrix_values" -> if (Ezfio.has_spindeterminants_psi_coef_matrix_values ()) then "T" else "F" - | "has_ao_basis_ao_num" -> if (Ezfio.has_ao_basis_ao_num ()) then "T" else "F" - | "has_ao_basis_ao_prim_num" -> if (Ezfio.has_ao_basis_ao_prim_num ()) then "T" else "F" - | "has_ao_basis_ao_nucl" -> if (Ezfio.has_ao_basis_ao_nucl ()) then "T" else "F" - | "has_ao_basis_ao_power" -> if (Ezfio.has_ao_basis_ao_power ()) then "T" else "F" - | "has_ao_basis_ao_coef" -> if (Ezfio.has_ao_basis_ao_coef ()) then "T" else "F" - | "has_ao_basis_ao_expo" -> if (Ezfio.has_ao_basis_ao_expo ()) then "T" else "F" - | "has_electrons_elec_alpha_num" -> if (Ezfio.has_electrons_elec_alpha_num ()) then "T" else "F" - | "has_electrons_elec_beta_num" -> if (Ezfio.has_electrons_elec_beta_num ()) then "T" else "F" - | "has_electrons_elec_walk_num_tot" -> if (Ezfio.has_electrons_elec_walk_num_tot ()) then "T" else "F" - | "has_electrons_elec_walk_num" -> if (Ezfio.has_electrons_elec_walk_num ()) then "T" else "F" - | "has_electrons_elec_coord_pool" -> if (Ezfio.has_electrons_elec_coord_pool ()) then "T" else "F" - | "has_electrons_elec_coord_pool_size" -> if (Ezfio.has_electrons_elec_coord_pool_size ()) then "T" else "F" - | "has_electrons_elec_fitcusp_radius" -> if (Ezfio.has_electrons_elec_fitcusp_radius ()) then "T" else "F" - | "has_jastrow_jast_type" -> if (Ezfio.has_jastrow_jast_type ()) then "T" else "F" - | "has_jastrow_jast_a_up_up" -> if (Ezfio.has_jastrow_jast_a_up_up ()) then "T" else "F" - | "has_jastrow_jast_a_up_dn" -> if (Ezfio.has_jastrow_jast_a_up_dn ()) then "T" else "F" - | "has_jastrow_jast_b_up_up" -> if (Ezfio.has_jastrow_jast_b_up_up ()) then "T" else "F" - | "has_jastrow_jast_b_up_dn" -> if (Ezfio.has_jastrow_jast_b_up_dn ()) then "T" else "F" - | "has_jastrow_jast_pen" -> if (Ezfio.has_jastrow_jast_pen ()) then "T" else "F" - | "has_jastrow_jast_een_e_a" -> if (Ezfio.has_jastrow_jast_een_e_a ()) then "T" else "F" - | "has_jastrow_jast_een_e_b" -> if (Ezfio.has_jastrow_jast_een_e_b ()) then "T" else "F" - | "has_jastrow_jast_een_n" -> if (Ezfio.has_jastrow_jast_een_n ()) then "T" else "F" - | "has_jastrow_jast_core_a1" -> if (Ezfio.has_jastrow_jast_core_a1 ()) then "T" else "F" - | "has_jastrow_jast_core_a2" -> if (Ezfio.has_jastrow_jast_core_a2 ()) then "T" else "F" - | "has_jastrow_jast_core_b1" -> if (Ezfio.has_jastrow_jast_core_b1 ()) then "T" else "F" - | "has_jastrow_jast_core_b2" -> if (Ezfio.has_jastrow_jast_core_b2 ()) then "T" else "F" - | "has_nuclei_nucl_num" -> if (Ezfio.has_nuclei_nucl_num ()) then "T" else "F" - | "has_nuclei_nucl_label" -> if (Ezfio.has_nuclei_nucl_label ()) then "T" else "F" - | "has_nuclei_nucl_charge" -> if (Ezfio.has_nuclei_nucl_charge ()) then "T" else "F" - | "has_nuclei_nucl_coord" -> if (Ezfio.has_nuclei_nucl_coord ()) then "T" else "F" - | "has_nuclei_nucl_fitcusp_radius" -> if (Ezfio.has_nuclei_nucl_fitcusp_radius ()) then "T" else "F" - | "has_properties_d_var_jast_a_up_dn" -> if (Ezfio.has_properties_d_var_jast_a_up_dn ()) then "T" else "F" - | "has_properties_d_var_jast_a_up_up" -> if (Ezfio.has_properties_d_var_jast_a_up_up ()) then "T" else "F" - | "has_properties_d_var_jast_b_up_dn" -> if (Ezfio.has_properties_d_var_jast_b_up_dn ()) then "T" else "F" - | "has_properties_d_var_jast_b_up_up" -> if (Ezfio.has_properties_d_var_jast_b_up_up ()) then "T" else "F" - | "has_properties_d_var_jast_core_a1" -> if (Ezfio.has_properties_d_var_jast_core_a1 ()) then "T" else "F" - | "has_properties_d_var_jast_core_b1" -> if (Ezfio.has_properties_d_var_jast_core_b1 ()) then "T" else "F" - | "has_properties_d_var_jast_een_e_a" -> if (Ezfio.has_properties_d_var_jast_een_e_a ()) then "T" else "F" - | "has_properties_d_var_jast_een_e_b" -> if (Ezfio.has_properties_d_var_jast_een_e_b ()) then "T" else "F" - | "has_properties_d_var_jast_een_n" -> if (Ezfio.has_properties_d_var_jast_een_n ()) then "T" else "F" - | "has_properties_d_var_jast_pen" -> if (Ezfio.has_properties_d_var_jast_pen ()) then "T" else "F" - | "has_properties_density1d" -> if (Ezfio.has_properties_density1d ()) then "T" else "F" - | "has_properties_dipole" -> if (Ezfio.has_properties_dipole ()) then "T" else "F" - | "has_properties_drift_mod" -> if (Ezfio.has_properties_drift_mod ()) then "T" else "F" - | "has_properties_e_kin" -> if (Ezfio.has_properties_e_kin ()) then "T" else "F" - | "has_properties_e_loc" -> if (Ezfio.has_properties_e_loc ()) then "T" else "F" - | "has_properties_e_loc_one" -> if (Ezfio.has_properties_e_loc_one ()) then "T" else "F" - | "has_properties_e_loc_per_electron" -> if (Ezfio.has_properties_e_loc_per_electron ()) then "T" else "F" - | "has_properties_e_loc_split_core" -> if (Ezfio.has_properties_e_loc_split_core ()) then "T" else "F" - | "has_properties_e_loc_two" -> if (Ezfio.has_properties_e_loc_two ()) then "T" else "F" - | "has_properties_e_nucl" -> if (Ezfio.has_properties_e_nucl ()) then "T" else "F" - | "has_properties_e_pot" -> if (Ezfio.has_properties_e_pot ()) then "T" else "F" - | "has_properties_e_pot_one" -> if (Ezfio.has_properties_e_pot_one ()) then "T" else "F" - | "has_properties_n_s_inverted" -> if (Ezfio.has_properties_n_s_inverted ()) then "T" else "F" - | "has_properties_n_s_updated" -> if (Ezfio.has_properties_n_s_updated ()) then "T" else "F" - | "has_properties_n_s_updates" -> if (Ezfio.has_properties_n_s_updates ()) then "T" else "F" - | "has_properties_voronoi_charges" -> if (Ezfio.has_properties_voronoi_charges ()) then "T" else "F" - | "has_properties_voronoi_charges_covariance" -> if (Ezfio.has_properties_voronoi_charges_covariance ()) then "T" else "F" - | "has_properties_voronoi_dipoles" -> if (Ezfio.has_properties_voronoi_dipoles ()) then "T" else "F" - | "has_properties_wf_extension" -> if (Ezfio.has_properties_wf_extension ()) then "T" else "F" - | x -> failwith (x^" : Unknown EZFIO function") -;; - diff --git a/ocaml/_tags b/ocaml/_tags deleted file mode 100644 index b8a5216..0000000 --- a/ocaml/_tags +++ /dev/null @@ -1,6 +0,0 @@ -true: package(core,sexplib.syntax,cryptokit,str,ZMQ) -true: thread -true:rpath -#true: static - - diff --git a/ocaml/build.ninja b/ocaml/build.ninja new file mode 100644 index 0000000..438d4ac --- /dev/null +++ b/ocaml/build.ninja @@ -0,0 +1,84 @@ + +MAIN=qmcchem +# Main program to build + +PACKAGES=-package core,sexplib.syntax,cryptokit,str,ZMQ +# Required opam packages, for example: +# PACKAGES=-package core,sexplib.syntax + +THREAD=-thread +# If you need threding support, use: +# THREAD=-thread + +SYNTAX=-syntax camlp4o +# If you need pre-processing, use: +# SYNTAX=-syntax camlp4o + +OCAMLC_FLAGS=-g -warn-error A +# Flags to give to ocamlc, for example: +# OCAMLC_FLAGS=-g -warn-error A + +LINK_FLAGS=-cclib '-Wl,-rpath=../lib,--enable-new-dtags' +# Flags to give to the linker, for example: +# LINK_FLAGS=-cclib '-Wl,-rpath=../lib,--enable-new-dtags' + +GENERATED_NINJA=generated.ninja +# Name of the auto-generated ninja file + +rule run_ninja + command = ../scripts/compile_ocaml.sh $target + description = Compiling OCaml executables + pool = console + +rule run_ninja_ocaml + command = ../scripts/compile_ocaml_dep.sh + description = Finding dependencies in OCaml files + +rule run_clean + command = ninja -f $GENERATED_NINJA -t clean ; rm -f $GENERATED_NINJA rm -f *.cmx *.cmi *.o .ls_md5 + pool = console + description = Cleaning directory + +rule ocamlc + command = ocamlfind ocamlc -c $OCAMLC_FLAGS $THREAD $PACKAGES $SYNTAX -o $out $in + description = Compiling $in (bytecode) + +rule ocamlopt + command = ocamlfind ocamlopt -c $OCAMLC_FLAGS $THREAD $PACKAGES $SYNTAX -o $out $in + description = Compiling $in (native) + +rule ocamlc_link + command = ocamlfind ocamlc $OCAMLC_FLAGS $THREAD $LINK_FLAGS $PACKAGES $SYNTAX -o $out $in + description = Compiling $out (bytecode) + +rule ocamlopt_link + command = ocamlfind ocamlopt $OCAMLC_FLAGS $THREAD $LINK_FLAGS $PACKAGES $SYNTAX -o $out $in + description = Compiling $out (native) + +rule create_qptypes + command = ./$in + description = Creating $out + +rule copy + command = cp $in $out + description = Copying $in to $out + +build always: phony | ezfio.ml +build $GENERATED_NINJA: run_ninja_ocaml | always +build ezfio.ml: copy ../EZFIO/Ocaml/ezfio.ml +build Qptypes.ml: create_qptypes qptypes_generator +build qptypes_generator: run_ninja | $GENERATED_NINJA + target = qptypes_generator + +build clean: run_clean + +build $MAIN: run_ninja | $GENERATED_NINJA ezfio.ml Qptypes.ml + target = $MAIN + +build all: run_ninja | ezfio.ml $GENERATED_NINJA Qptypes.ml + target = + +default $MAIN + + + diff --git a/scripts/compile_irpf90.sh b/scripts/compile_irpf90.sh index e61583f..2b790d5 100755 --- a/scripts/compile_irpf90.sh +++ b/scripts/compile_irpf90.sh @@ -29,7 +29,7 @@ then LIB="${LIB} ${QMCCHEM_PATH}/lib/libezfio_irp.a ${QMCCHEM_PATH}/lib/libf77zmq.a ${QMCCHEM_PATH}/lib/libzmq.a -lstdc++ -lrt" SRC="${SRC} ZMQ/f77_zmq_module.f90" OBJ="${OBJ} IRPF90_temp/ZMQ/f77_zmq_module.o" - INCLUDES="${INCLUDES} -I AO -I SAMPLING -I TOOLS -I JASTROW -I TESTING -I MAIN -I PROPERTIES -I ZMQ" + INCLUDES="${INCLUDES} -I AO -I SAMPLING -I TOOLS -I JASTROW -I MAIN -I PROPERTIES -I ZMQ" IRPF90_FLAGS="${IRPF90_FLAGS} --ninja" # Check IRPF90 version diff --git a/scripts/create_properties_python.py b/scripts/create_properties_python.py index 94207f1..f763920 100755 --- a/scripts/create_properties_python.py +++ b/scripts/create_properties_python.py @@ -51,10 +51,6 @@ for filename in files: dims[current_prop] = line.split(':')[1].strip() -import numerical_derivatives as deriv -properties += map(lambda x: ["double precision", "d_var_"+x.lower(), "(size_d_var_"+x.lower()+")"], deriv.vectors) -properties += map(lambda x: ["double precision", "d_var_"+x.lower(), "(7)"], deriv.scalars) - def sq(item): return [item[0], item[1]+"_2", item[2]] diff --git a/src/AO/ao.irp.f b/src/AO/ao.irp.f index c522439..d389c6c 100644 --- a/src/AO/ao.irp.f +++ b/src/AO/ao.irp.f @@ -124,20 +124,6 @@ BEGIN_PROVIDER [ integer, ao_power_transp, (4,ao_num) ] END_PROVIDER -BEGIN_PROVIDER [ integer , ao_class, (ao_num_8) ] - implicit none - include '../types.F' - BEGIN_DOC -! t_Slater or t_Gaussian - END_DOC - - integer :: i - do i=1,ao_num - ao_class(i) = t_Gaussian - enddo - -END_PROVIDER - BEGIN_PROVIDER [ integer , ao_power_max ] implicit none diff --git a/src/ZMQ/qmc.irp.f b/src/ZMQ/qmc.irp.f index d3f1712..d2190cd 100644 --- a/src/ZMQ/qmc.irp.f +++ b/src/ZMQ/qmc.irp.f @@ -60,8 +60,6 @@ subroutine run_qmc(cpu0) use f77_zmq implicit none include '../types.F' - include '../deriv_var.F' - include '../deriv_ene.F' integer*8 :: cpu0 integer :: isize, i, j, ierr @@ -106,8 +104,7 @@ subroutine run_qmc(cpu0) BEGIN_SHELL [ /usr/bin/python ] from properties import * -derivlist = map(lambda x: x[1], properties) -derivlist = filter(lambda x: x.startswith("d_var_"), derivlist) +derivlist = [] td = """ do j=0,size($X_block_walk,1)-1,7 diff --git a/src/det.irp.f b/src/det.irp.f index 4d5de55..ef2db3d 100644 --- a/src/det.irp.f +++ b/src/det.irp.f @@ -829,7 +829,6 @@ END_PROVIDER slater_matrix_alpha_inv_det, & ddet) if (ddet /= 0.d0) then - n_updates_det += 1.d0 det_alpha_value_curr = ddet else n_to_do += 1 @@ -853,9 +852,8 @@ END_PROVIDER ! Avoid NaN if (ddet /= 0.d0) then - n_updated_det += 1.d0 + continue else - n_inverted_det += 1.d0 do j=1,mo_closed_num !DIR$ VECTOR ALIGNED !DIR$ LOOP COUNT(100) @@ -940,7 +938,6 @@ END_PROVIDER slater_matrix_beta_inv_det, & ddet) if (ddet /= 0.d0) then - n_updates_det += 1.d0 det_beta_value_curr = ddet else n_to_do += 1 @@ -964,9 +961,8 @@ END_PROVIDER ! Avoid NaN if (ddet /= 0.d0) then - n_updated_det += 1.d0 + continue else - n_inverted_det += 1.d0 do j=1,mo_closed_num !DIR$ VECTOR UNALIGNED !DIR$ LOOP COUNT (100)