LCPQ/quantum_package
10
0
Fork 0
mirror of https://github.com/LCPQ/quantum_package synced 2024-06-26 15:12:14 +02:00
Code Issues Releases Wiki Activity

Merge pull request #153 from scemama/master

Browse Source 
Fixed #152 and corrected qp_edit bug
This commit is contained in:
Thomas Applencourt 2016-03-04 13:57:19 +01:00
commit 7c0c3e0391
4 changed files with 148 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

302
ocaml/Input_determinants_by_hand.ml
View File

@ -16,6 +16,7 @@ module Determinants_by_hand : sig
val to_string : t -> string
val to_rst : t -> Rst_string.t
val of_rst : Rst_string.t -> t option
val read_n_int : unit -> N_int_number.t
end = struct
type t =
{ n_int : N_int_number.t;
@ -157,58 +158,44 @@ end = struct
let read_psi_det () =
let n_int =
read_n_int ()
and alpha =
Ezfio.get_electrons_elec_alpha_num ()
let n_int = read_n_int ()
and n_alpha = Ezfio.get_electrons_elec_alpha_num ()
|> Elec_alpha_number.of_int
and beta =
Ezfio.get_electrons_elec_beta_num ()
and n_beta = Ezfio.get_electrons_elec_beta_num ()
|> Elec_beta_number.of_int
in
if not (Ezfio.has_determinants_psi_det ()) then
begin
let mo_tot_num =
MO_number.get_max ()
in
let rec build_data accu = function
| 0 -> accu
| n -> build_data ((MO_number.of_int ~max:mo_tot_num n)::accu) (n-1)
in
let det_a =
build_data [] (Elec_alpha_number.to_int alpha)
|> Bitlist.of_mo_number_list n_int
and det_b =
build_data [] (Elec_beta_number.to_int beta)
|> Bitlist.of_mo_number_list n_int
in
let data =
( (Bitlist.to_int64_list det_a) @
(Bitlist.to_int64_list det_b) )
in
Ezfio.ezfio_array_of_list ~rank:3 ~dim:[| N_int_number.to_int n_int ; 2 ; 1 |] ~data:data
|> Ezfio.set_determinants_psi_det ;
end ;
let n_int_i =
N_int_number.to_int n_int in
let psi_det_array =
Ezfio.get_determinants_psi_det ()
in
let dim =
psi_det_array.Ezfio.dim
and data =
Ezfio.flattened_ezfio psi_det_array
in
assert (n_int_i = dim.(0));
assert (dim.(1) = 2);
assert (dim.(2) = (Det_number.to_int (read_n_det ())));
let len =
2 * n_int_i
in
Array.init dim.(2) ~f:(fun i ->
Array.sub ~pos:(len * i) ~len data
|> Determinant.of_int64_array ~n_int ~alpha ~beta
)
in
if not (Ezfio.has_determinants_psi_det ()) then
begin
let mo_tot_num = MO_number.get_max () in
let rec build_data accu = function
| 0 -> accu
| n -> build_data ((MO_number.of_int ~max:mo_tot_num n)::accu) (n-1)
in
let det_a = build_data [] (Elec_alpha_number.to_int n_alpha)
|> Bitlist.of_mo_number_list n_int
and det_b = build_data [] (Elec_beta_number.to_int n_beta)
|> Bitlist.of_mo_number_list n_int
in
let data = ( (Bitlist.to_int64_list det_a) @
(Bitlist.to_int64_list det_b) )
in
Ezfio.ezfio_array_of_list ~rank:3 ~dim:[| N_int_number.to_int n_int ; 2 ; 1 |] ~data:data
|> Ezfio.set_determinants_psi_det ;
end ;
let n_int = N_int_number.to_int n_int in
let psi_det_array = Ezfio.get_determinants_psi_det () in
let dim = psi_det_array.Ezfio.dim
and data = Ezfio.flattened_ezfio psi_det_array
in
assert (n_int = dim.(0));
assert (dim.(1) = 2);
assert (dim.(2) = (Det_number.to_int (read_n_det ())));
List.init dim.(2) ~f:(fun i ->
Array.sub ~pos:(2*n_int*i) ~len:(2*n_int) data)
|> List.map ~f:(Determinant.of_int64_array
~n_int:(N_int_number.of_int n_int)
~alpha:n_alpha ~beta:n_beta )
|> Array.of_list
;;
let write_psi_det ~n_int ~n_det d =
@ -286,9 +273,13 @@ end = struct
|> String.concat_array ~sep:"\t"
in
Array.init ndet ~f:(fun i ->
String.concat [ " " ;
(coefs_string i) ; "\n" ;
(Determinant.to_string ~mo_tot_num b.psi_det.(i)) ; "\n" ]
Printf.sprintf " %s\n%s\n"
(coefs_string i)
(Determinant.to_string ~mo_tot_num:mo_tot_num b.psi_det.(i)
|> String.split ~on:'\n'
|> List.map ~f:(fun x -> " "^x)
|> String.concat ~sep:"\n"
)
)
|> String.concat_array ~sep:"\n"
in
@ -334,18 +325,18 @@ psi_det = %s
;;
let of_rst r =
let dets = Rst_string.to_string r
let r = Rst_string.to_string r
in
(* Split into header and determinants data *)
let idx = String.substr_index_exn dets ~pos:0 ~pattern:"\nDeterminants"
let idx = String.substr_index_exn r ~pos:0 ~pattern:"\nDeterminants"
in
let header =
String.prefix dets idx
let (header, dets) =
(String.prefix r idx, String.suffix r ((String.length r)-idx) )
in
(* Handle header *)
let header = header
let header = r
|> String.split ~on:'\n'
|> List.filter ~f:(fun line ->
if (line = "") then
@ -361,117 +352,91 @@ psi_det = %s
|> String.concat
in
(* Handle determinants and coefs *)
let dets_stream =
let ipos, jmax =
ref idx, String.length dets
in
let next_line =
Stream.from (fun _ ->
let rec loop line =
let j =
!ipos + 1
in
ipos := j;
if (j < jmax) then
match dets.[j] with
| '\n' -> Some (String.of_char_list @@ List.rev line )
| ' ' -> loop line
| c -> loop (c :: line)
else
None
in loop []
)
in
ignore @@ Stream.next next_line; (* Determinants :: *)
ignore @@ Stream.next next_line; (* *)
Stream.from (fun _ ->
try
begin
let result =
let coefs =
let line =
Stream.next next_line
in
String.split ~on:'\t' line
|> Array.of_list
|> Array.map ~f:(fun x -> Det_coef.of_float @@ Float.of_string x)
in
Some (coefs,
Stream.next next_line |> String.rev,
Stream.next next_line |> String.rev )
in
ignore @@ Stream.next next_line;
result
end
with
| Stream.Failure -> None
)
(* Handle determinant coefs *)
let dets = match ( dets
|> String.split ~on:'\n'
|> List.map ~f:(String.strip)
) with
| _::lines -> lines
| _ -> failwith "Error in determinants"
in
let psi_coef, psi_det =
let alpha =
Ezfio.get_electrons_elec_alpha_num ()
|> Elec_alpha_number.of_int
and beta =
Ezfio.get_electrons_elec_beta_num ()
|> Elec_beta_number.of_int
and n_int =
N_int_number.get_max ()
|> N_int_number.of_int
in
let rec read coefs dets_bit = function
| None -> (List.rev coefs), (List.rev dets_bit)
| Some (c, alpha_str, beta_str) ->
begin
ignore @@ Stream.next dets_stream;
let new_coefs =
c :: coefs
and new_dets =
let newdet =
(Bitlist.of_string_mp alpha_str, Bitlist.of_string_mp beta_str)
|> Determinant.of_bitlist_couple ~n_int ~alpha ~beta
in
newdet :: dets_bit
in
read new_coefs new_dets (Stream.peek dets_stream)
end
in
let coefs, dets_bit =
read [] [] (Stream.peek dets_stream)
in
let nstates =
List.hd_exn coefs |> Array.length
let psi_coef =
let rec read_coefs accu = function
| [] -> List.rev accu
| ""::""::tail -> read_coefs accu tail
| ""::c::tail ->
let c =
String.split ~on:'\t' c
|> List.map ~f:(fun x -> Det_coef.of_float (Float.of_string x))
|> Array.of_list
in
read_coefs (c::accu) tail
| _::tail -> read_coefs accu tail
in
let a =
let extract_state i =
let i =
i-1
let buffer =
read_coefs [] dets
in
let nstates =
List.hd_exn buffer
|> Array.length
in
let extract_state i =
let i =
i-1
in
List.map ~f:(fun x -> Det_coef.to_string x.(i)) buffer
|> String.concat ~sep:" "
in
let rec build_result = function
| 1 -> extract_state 1
| i -> (build_result (i-1))^" "^(extract_state i)
in
build_result nstates
in
"(psi_coef ("^a^"))"
in
(* Handle determinants *)
let psi_det =
let n_alpha = Ezfio.get_electrons_elec_alpha_num ()
|> Elec_alpha_number.of_int
and n_beta = Ezfio.get_electrons_elec_beta_num ()
|> Elec_beta_number.of_int
in
let rec read_dets accu = function
| [] -> List.rev accu
| ""::_::alpha::beta::tail ->
begin
let newdet =
(Bitlist.of_string ~zero:'-' ~one:'+' alpha ,
Bitlist.of_string ~zero:'-' ~one:'+' beta)
|> Determinant.of_bitlist_couple ~alpha:n_alpha ~beta:n_beta
|> Determinant.sexp_of_t
|> Sexplib.Sexp.to_string
in
List.map ~f:(fun x -> x.(i)) coefs
in
let rec build_result accu = function
| 0 -> accu
| i ->
let new_accu =
(extract_state i) :: accu
in
build_result new_accu (i-1)
in
build_result [] nstates
read_dets (newdet::accu) tail
end
| _::tail -> read_dets accu tail
in
let new_coefs =
List.concat a |> Array.of_list
and new_dets =
Array.of_list dets_bit
let dets =
List.map ~f:String.rev dets
in
new_coefs, new_dets
let sze =
List.fold ~init:0 ~f:(fun accu x -> accu + (String.length x)) dets
in
let control =
Gc.get ()
in
Gc.tune ~minor_heap_size:(sze) ~space_overhead:(sze/10)
~max_overhead:100000 ~major_heap_increment:(sze/10) ();
let a =
read_dets [] dets
|> String.concat
in
Gc.set control;
"(psi_det ("^a^"))"
in
@ -481,16 +446,11 @@ psi_det = %s
and n_int =
Printf.sprintf "(n_int %d)" (N_int_number.get_max ())
in
let s =
[ header ; bitkind ; n_int ; "(psi_coef ())" ; "(psi_det ())"]
|> String.concat
let s =
String.concat [ header ; bitkind ; n_int ; psi_coef ; psi_det]
in
let result =
Generic_input_of_rst.evaluate_sexp t_of_sexp s
in
match result with
| Some x -> Some { x with psi_coef ; psi_det }
| None -> None
Generic_input_of_rst.evaluate_sexp t_of_sexp s
;;
end

21
ocaml/TaskServer.ml
View File

@ -32,14 +32,19 @@ let zmq_context =
let bind_socket ~socket_type ~socket ~address =
try
ZMQ.Socket.bind socket address
with
| Unix.Unix_error (_, message, f) ->
failwith @@ Printf.sprintf
"\n%s\nUnable to bind the %s socket :\n %s\n%s"
f socket_type address message
| other_exception -> raise other_exception
let rec loop = function
| 0 -> failwith @@ Printf.sprintf
"Unable to bind the %s socket : %s "
socket_type address
| -1 -> ();
| i ->
try
ZMQ.Socket.bind socket address;
loop (-1)
with
| Unix.Unix_error _ -> (Time.pause @@ Time.Span.of_float 1. ; loop (i-1) )
| other_exception -> raise other_exception
in loop 10
let hostname = lazy (

4
ocaml/qp_run.ml
View File

@ -32,12 +32,12 @@ let run ~master exe ezfio_file =
let address =
Printf.sprintf "tcp://%s:%d" (Lazy.force TaskServer.ip_address) (port_number+i)
in
TaskServer.bind_socket "REP" dummy_socket address ;
ZMQ.Socket.bind dummy_socket address;
ZMQ.Socket.unbind dummy_socket address;
);
port_number
with
| Failure _ -> try_new_port (port_number+100)
| Unix.Unix_error _ -> try_new_port (port_number+100)
in
let result =
try_new_port 41279

3
scripts/module/qp_module.py
View File

@ -59,7 +59,8 @@ def save_new_module(path, l_child):
with open(os.path.join(path, "%s.main.irp.f"%(module_name) ), "w") as f:
f.write("program {0}".format(module_name) )
f.write(""" implicit none
f.write("""
implicit none
BEGIN_DOC
! TODO
END_DOC