LCPQ
/
qmcchem
mirror of https://gitlab.com/scemama/qmcchem.git
10
1
Fork 1
Code Releases Activity

Merge branch 'master' of github.com:scemama/qmcchem

This commit is contained in:
Anthony Scemama 2015-12-22 22:19:03 +01:00
parent 517ddf99d0 099ba69a13
commit ca07066e06
12 changed files with 128 additions and 881 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
README.md
View File

@ -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:

9
build.ninja
View File

@ -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
# -----

2
install/build.ninja
View File

@ -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

22
make.config Normal file
View File

@ -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

830
ocaml/Qptypes.ml
View File

@ -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")
;;

6
ocaml/_tags
View File

@ -1,6 +0,0 @@
true: package(core,sexplib.syntax,cryptokit,str,ZMQ)
true: thread
true:rpath
#true: static

84
ocaml/build.ninja Normal file
View File

@ -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

2
scripts/compile_irpf90.sh
View File

@ -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

4
scripts/create_properties_python.py
View File

@ -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]]

14
src/AO/ao.irp.f
View File

@ -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

5
src/ZMQ/qmc.irp.f
View File

@ -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

8
src/det.irp.f
View File

@ -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)