45#include "../base/base_uses.f90"
64 SUBROUTINE cp_eval_at(gopt_env, x, f, gradient, master, &
65 final_evaluation, para_env)
71 TYPE(gopt_f_type),
POINTER :: gopt_env
72 REAL(KIND=
dp),
DIMENSION(:),
POINTER :: x
73 REAL(KIND=
dp),
INTENT(out),
OPTIONAL :: f
74 REAL(KIND=
dp),
DIMENSION(:),
OPTIONAL, &
76 INTEGER,
INTENT(IN) :: master
77 LOGICAL,
INTENT(IN),
OPTIONAL :: final_evaluation
78 TYPE(mp_para_env_type),
POINTER :: para_env
84 LOGICAL,
PRIVATE,
PARAMETER :: debug_this_module = .true.
85 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'cp_lbfgs_optimizer_gopt'
164 CHARACTER(len=60) :: task =
""
165 CHARACTER(len=60) :: csave =
""
166 LOGICAL :: lsave(4) = .false.
167 INTEGER :: m = 0, print_every = 0, master = 0, max_f_per_iter = 0, status = 0, n_iter = 0
168 INTEGER,
DIMENSION(:),
POINTER :: kind_of_bound => null(), i_work_array => null(), isave => null()
169 REAL(kind=dp) :: f = 0.0_dp, wanted_relative_f_delta = 0.0_dp, wanted_projected_gradient = 0.0_dp, &
170 last_f = 0.0_dp, projected_gradient = 0.0_dp, eold = 0.0_dp, emin = 0.0_dp, trust_radius = 0.0_dp
171 REAL(kind=dp),
DIMENSION(:),
POINTER :: x => null(), lower_bound => null(), upper_bound => null(), &
172 gradient => null(), dsave => null(), work_array => null()
173 TYPE(mp_para_env_type),
POINTER :: para_env => null()
174 TYPE(gopt_f_type),
POINTER :: obj_funct => null()
203 wanted_relative_f_delta, wanted_projected_gradient, lower_bound, upper_bound, &
204 kind_of_bound, master, max_f_per_iter, trust_radius)
206 TYPE(mp_para_env_type),
POINTER :: para_env
207 TYPE(gopt_f_type),
POINTER :: obj_funct
208 REAL(kind=dp),
DIMENSION(:),
INTENT(in) :: x0
209 INTEGER,
INTENT(in),
OPTIONAL :: m, print_every
210 REAL(kind=dp),
INTENT(in),
OPTIONAL :: wanted_relative_f_delta, &
211 wanted_projected_gradient
212 REAL(kind=dp),
DIMENSION(SIZE(x0)),
INTENT(in), &
213 OPTIONAL :: lower_bound, upper_bound
214 INTEGER,
DIMENSION(SIZE(x0)),
INTENT(in),
OPTIONAL :: kind_of_bound
215 INTEGER,
INTENT(in),
OPTIONAL :: master, max_f_per_iter
216 REAL(kind=dp),
INTENT(in),
OPTIONAL :: trust_radius
218 CHARACTER(len=*),
PARAMETER :: routinen =
'cp_opt_gopt_create'
220 INTEGER :: handle, lenwa, n
222 CALL timeset(routinen, handle)
224 NULLIFY (optimizer%kind_of_bound, &
225 optimizer%i_work_array, &
228 optimizer%lower_bound, &
229 optimizer%upper_bound, &
230 optimizer%gradient, &
232 optimizer%work_array, &
233 optimizer%para_env, &
237 IF (
PRESENT(m)) optimizer%m = m
238 optimizer%master = para_env%source
239 optimizer%para_env => para_env
240 CALL para_env%retain()
241 optimizer%obj_funct => obj_funct
242 CALL gopt_f_retain(obj_funct)
243 optimizer%max_f_per_iter = 20
244 IF (
PRESENT(max_f_per_iter)) optimizer%max_f_per_iter = max_f_per_iter
245 optimizer%print_every = -1
247 optimizer%f = -1.0_dp
248 optimizer%last_f = -1.0_dp
249 optimizer%projected_gradient = -1.0_dp
250 IF (
PRESENT(print_every)) optimizer%print_every = print_every
251 IF (
PRESENT(master)) optimizer%master = master
252 IF (optimizer%master == optimizer%para_env%mepos)
THEN
254 lenwa = 2*optimizer%m*n + 5*n + 11*optimizer%m*optimizer%m + 8*optimizer%m
255 ALLOCATE (optimizer%kind_of_bound(n), optimizer%i_work_array(3*n), &
257 ALLOCATE (optimizer%x(n), optimizer%lower_bound(n), &
258 optimizer%upper_bound(n), optimizer%gradient(n), &
259 optimizer%dsave(29), optimizer%work_array(lenwa))
261 optimizer%task =
'START'
262 optimizer%wanted_relative_f_delta = wanted_relative_f_delta
263 optimizer%wanted_projected_gradient = wanted_projected_gradient
264 optimizer%kind_of_bound = 0
265 IF (
PRESENT(kind_of_bound)) optimizer%kind_of_bound = kind_of_bound
266 IF (
PRESENT(lower_bound)) optimizer%lower_bound = lower_bound
267 IF (
PRESENT(upper_bound)) optimizer%upper_bound = upper_bound
268 IF (
PRESENT(trust_radius)) optimizer%trust_radius = trust_radius
270 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
271 optimizer%lower_bound, optimizer%upper_bound, &
272 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
273 optimizer%wanted_relative_f_delta, &
274 optimizer%wanted_projected_gradient, optimizer%work_array, &
275 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
276 optimizer%csave, optimizer%lsave, optimizer%isave, &
277 optimizer%dsave, optimizer%trust_radius)
280 optimizer%kind_of_bound, optimizer%i_work_array, optimizer%isave, &
281 optimizer%lower_bound, optimizer%upper_bound, optimizer%gradient, &
282 optimizer%dsave, optimizer%work_array)
283 ALLOCATE (optimizer%x(n))
284 optimizer%x(:) = 0.0_dp
285 ALLOCATE (optimizer%gradient(n))
286 optimizer%gradient(:) = 0.0_dp
288 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
291 CALL timestop(handle)
306 CHARACTER(len=*),
PARAMETER :: routinen =
'cp_opt_gopt_release'
310 CALL timeset(routinen, handle)
312 IF (
ASSOCIATED(optimizer%kind_of_bound))
THEN
313 DEALLOCATE (optimizer%kind_of_bound)
315 IF (
ASSOCIATED(optimizer%i_work_array))
THEN
316 DEALLOCATE (optimizer%i_work_array)
318 IF (
ASSOCIATED(optimizer%isave))
THEN
319 DEALLOCATE (optimizer%isave)
321 IF (
ASSOCIATED(optimizer%x))
THEN
322 DEALLOCATE (optimizer%x)
324 IF (
ASSOCIATED(optimizer%lower_bound))
THEN
325 DEALLOCATE (optimizer%lower_bound)
327 IF (
ASSOCIATED(optimizer%upper_bound))
THEN
328 DEALLOCATE (optimizer%upper_bound)
330 IF (
ASSOCIATED(optimizer%gradient))
THEN
331 DEALLOCATE (optimizer%gradient)
333 IF (
ASSOCIATED(optimizer%dsave))
THEN
334 DEALLOCATE (optimizer%dsave)
336 IF (
ASSOCIATED(optimizer%work_array))
THEN
337 DEALLOCATE (optimizer%work_array)
339 CALL mp_para_env_release(optimizer%para_env)
340 CALL gopt_f_release(optimizer%obj_funct)
342 CALL timestop(handle)
373 SUBROUTINE cp_opt_gopt_get(optimizer, para_env, &
374 obj_funct, m, print_every, &
375 wanted_relative_f_delta, wanted_projected_gradient, &
376 x, lower_bound, upper_bound, kind_of_bound, master, &
377 actual_projected_gradient, &
378 n_var, n_iter, status, max_f_per_iter, at_end, &
379 is_master, last_f, f)
381 TYPE(mp_para_env_type),
OPTIONAL,
POINTER :: para_env
382 TYPE(gopt_f_type),
OPTIONAL,
POINTER :: obj_funct
383 INTEGER,
INTENT(out),
OPTIONAL :: m, print_every
384 REAL(kind=dp),
INTENT(out),
OPTIONAL :: wanted_relative_f_delta, &
385 wanted_projected_gradient
386 REAL(kind=dp),
DIMENSION(:),
OPTIONAL,
POINTER :: x, lower_bound, upper_bound
387 INTEGER,
DIMENSION(:),
OPTIONAL,
POINTER :: kind_of_bound
388 INTEGER,
INTENT(out),
OPTIONAL :: master
389 REAL(kind=dp),
INTENT(out),
OPTIONAL :: actual_projected_gradient
390 INTEGER,
INTENT(out),
OPTIONAL :: n_var, n_iter, status, max_f_per_iter
391 LOGICAL,
INTENT(out),
OPTIONAL :: at_end, is_master
392 REAL(kind=dp),
INTENT(out),
OPTIONAL :: last_f, f
394 IF (
PRESENT(is_master)) is_master = optimizer%master == optimizer%para_env%mepos
395 IF (
PRESENT(master)) master = optimizer%master
396 IF (
PRESENT(status)) status = optimizer%status
397 IF (
PRESENT(para_env)) para_env => optimizer%para_env
398 IF (
PRESENT(obj_funct)) obj_funct = optimizer%obj_funct
399 IF (
PRESENT(m)) m = optimizer%m
400 IF (
PRESENT(max_f_per_iter)) max_f_per_iter = optimizer%max_f_per_iter
401 IF (
PRESENT(wanted_projected_gradient)) &
402 wanted_projected_gradient = optimizer%wanted_projected_gradient
403 IF (
PRESENT(wanted_relative_f_delta)) &
404 wanted_relative_f_delta = optimizer%wanted_relative_f_delta
405 IF (
PRESENT(print_every)) print_every = optimizer%print_every
406 IF (
PRESENT(x)) x => optimizer%x
407 IF (
PRESENT(n_var)) n_var =
SIZE(x)
408 IF (
PRESENT(lower_bound)) lower_bound => optimizer%lower_bound
409 IF (
PRESENT(upper_bound)) upper_bound => optimizer%upper_bound
410 IF (
PRESENT(kind_of_bound)) kind_of_bound => optimizer%kind_of_bound
411 IF (
PRESENT(n_iter)) n_iter = optimizer%n_iter
412 IF (
PRESENT(last_f)) last_f = optimizer%last_f
413 IF (
PRESENT(f)) f = optimizer%f
414 IF (
PRESENT(at_end)) at_end = optimizer%status > 3
415 IF (
PRESENT(actual_projected_gradient)) &
416 actual_projected_gradient = optimizer%projected_gradient
417 IF (optimizer%master == optimizer%para_env%mepos)
THEN
418 IF (optimizer%isave(30) > 1 .AND. (optimizer%task(1:5) ==
"NEW_X" .OR. &
419 optimizer%task(1:4) ==
"STOP" .AND. optimizer%task(7:9) ==
"CPU"))
THEN
421 IF (
PRESENT(last_f)) last_f = optimizer%dsave(2)
422 IF (
PRESENT(actual_projected_gradient)) &
423 actual_projected_gradient = optimizer%dsave(13)
425 cpassert(.NOT.
PRESENT(last_f))
426 cpassert(.NOT.
PRESENT(actual_projected_gradient))
429 IF (
PRESENT(lower_bound) .OR.
PRESENT(upper_bound) .OR.
PRESENT(kind_of_bound)) &
430 cpwarn(
"asked undefined types")
433 END SUBROUTINE cp_opt_gopt_get
454 SUBROUTINE cp_opt_gopt_step(optimizer, n_iter, f, last_f, &
455 projected_gradient, converged, geo_section, force_env, &
458 INTEGER,
INTENT(out),
OPTIONAL :: n_iter
459 REAL(kind=dp),
INTENT(out),
OPTIONAL :: f, last_f, projected_gradient
460 LOGICAL,
INTENT(out),
OPTIONAL :: converged
464 TYPE(
spgr_type),
OPTIONAL,
POINTER :: spgr
466 CHARACTER(len=*),
PARAMETER :: routinen =
'cp_opt_gopt_step'
468 CHARACTER(LEN=5) :: wildcard
469 INTEGER :: dataunit, handle, its
470 LOGICAL :: conv, is_master, justentred, &
472 REAL(kind=dp) :: t_diff, t_now, t_old
473 REAL(kind=dp),
DIMENSION(:),
POINTER :: xold
477 NULLIFY (logger, xold)
479 CALL timeset(routinen, handle)
481 is_master = optimizer%master == optimizer%para_env%mepos
482 IF (
PRESENT(converged)) converged = optimizer%status == 4
483 ALLOCATE (xold(
SIZE(optimizer%x)))
488 keep_space_group = .false.
489 IF (
PRESENT(spgr))
THEN
490 IF (
ASSOCIATED(spgr)) keep_space_group = spgr%keep_space_group
494 IF (keep_space_group)
THEN
501 IF (optimizer%status >= 4)
THEN
502 cpwarn(
"status>=4, trying to restart")
505 optimizer%task =
'START'
506 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
507 optimizer%lower_bound, optimizer%upper_bound, &
508 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
509 optimizer%wanted_relative_f_delta, &
510 optimizer%wanted_projected_gradient, optimizer%work_array, &
511 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
512 optimizer%csave, optimizer%lsave, optimizer%isave, &
513 optimizer%dsave, optimizer%trust_radius, spgr=spgr)
518 ifmaster:
IF (is_master)
THEN
519 IF (optimizer%task(1:7) ==
'RESTART')
THEN
522 optimizer%task =
'START'
524 IF (keep_space_group)
THEN
528 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
529 optimizer%lower_bound, optimizer%upper_bound, &
530 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
531 optimizer%wanted_relative_f_delta, &
532 optimizer%wanted_projected_gradient, optimizer%work_array, &
533 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
534 optimizer%csave, optimizer%lsave, optimizer%isave, &
535 optimizer%dsave, optimizer%trust_radius, spgr=spgr)
536 IF (keep_space_group)
THEN
541 IF (optimizer%task(1:2) ==
'FG')
THEN
542 IF (optimizer%isave(36) > optimizer%max_f_per_iter)
THEN
543 optimizer%task =
'STOP: CPU, hit max f eval in iter'
545 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
546 optimizer%lower_bound, optimizer%upper_bound, &
547 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
548 optimizer%wanted_relative_f_delta, &
549 optimizer%wanted_projected_gradient, optimizer%work_array, &
550 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
551 optimizer%csave, optimizer%lsave, optimizer%isave, &
552 optimizer%dsave, optimizer%trust_radius, spgr=spgr)
556 ELSE IF (optimizer%task(1:5) ==
'NEW_X')
THEN
560 IF (keep_space_group)
THEN
564 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
565 optimizer%lower_bound, optimizer%upper_bound, &
566 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
567 optimizer%wanted_relative_f_delta, &
568 optimizer%wanted_projected_gradient, optimizer%work_array, &
569 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
570 optimizer%csave, optimizer%lsave, optimizer%isave, &
571 optimizer%dsave, optimizer%trust_radius, spgr=spgr)
572 IF (keep_space_group)
THEN
578 IF (keep_space_group)
THEN
584 ELSE IF (optimizer%task(1:4) ==
'CONV')
THEN
586 ELSE IF (optimizer%task(1:4) ==
'STOP')
THEN
588 cpwarn(
"task became stop in an unknown way")
589 ELSE IF (optimizer%task(1:5) ==
'ERROR')
THEN
592 cpwarn(
"unknown task '"//optimizer%task//
"'")
595 CALL optimizer%para_env%bcast(optimizer%status, optimizer%master)
597 IF (optimizer%status == 3)
THEN
601 its = optimizer%isave(30)
605 SELECT CASE (optimizer%status)
608 CALL cp_eval_at(optimizer%obj_funct, x=optimizer%x, &
610 gradient=optimizer%gradient, &
611 final_evaluation=.false., &
612 master=optimizer%master, para_env=optimizer%para_env)
616 IF (keep_space_group)
THEN
620 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
621 optimizer%lower_bound, optimizer%upper_bound, &
622 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
623 optimizer%wanted_relative_f_delta, &
624 optimizer%wanted_projected_gradient, optimizer%work_array, &
625 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
626 optimizer%csave, optimizer%lsave, optimizer%isave, &
627 optimizer%dsave, optimizer%trust_radius, spgr=spgr)
628 IF (keep_space_group)
THEN
633 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
636 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
642 "PRINT%PROGRAM_RUN_INFO", extension=
".geoLog")
643 IF (is_master) its = optimizer%isave(30)
644 CALL optimizer%para_env%bcast(its, optimizer%master)
648 t_diff = t_now - t_old
650 CALL gopt_f_io(optimizer%obj_funct, force_env, force_env%root_section, &
651 its, optimizer%f, dataunit, optimizer%eold, optimizer%emin, wildcard, gopt_param, &
652 SIZE(optimizer%x), optimizer%x - xold, optimizer%gradient, conv, used_time=t_diff)
653 CALL optimizer%para_env%bcast(conv, optimizer%master)
655 "PRINT%PROGRAM_RUN_INFO")
656 optimizer%eold = optimizer%f
657 optimizer%emin = min(optimizer%emin, optimizer%eold)
659 IF (
PRESENT(converged)) converged = conv
666 "PRINT%PROGRAM_RUN_INFO", extension=
".geoLog")
667 IF (dataunit > 0)
THEN
668 WRITE (dataunit,
'(T2,A)')
""
669 WRITE (dataunit,
'(T2,A)')
"***********************************************"
670 WRITE (dataunit,
'(T2,A)')
"* Specific L-BFGS convergence criteria "
671 WRITE (dataunit,
'(T2,A)')
"* WANTED_PROJ_GRADIENT and WANTED_REL_F_ERROR "
672 WRITE (dataunit,
'(T2,A)')
"* satisfied .... run CONVERGED! "
673 WRITE (dataunit,
'(T2,A)')
"***********************************************"
674 WRITE (dataunit,
'(T2,A)')
""
677 "PRINT%PROGRAM_RUN_INFO")
678 IF (
PRESENT(converged)) converged = .true.
682 CALL optimizer%para_env%bcast(optimizer%task, optimizer%master)
685 cpabort(
"step on a deallocated opt structure ")
687 CALL cp_abort(__location__, &
692 IF (optimizer%status == 1 .AND. justentred)
THEN
693 optimizer%eold = optimizer%f
694 optimizer%emin = optimizer%eold
699 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
700 CALL cp_opt_gopt_bcast_res(optimizer, &
701 n_iter=optimizer%n_iter, &
702 f=optimizer%f, last_f=optimizer%last_f, &
703 projected_gradient=optimizer%projected_gradient)
706 IF (
PRESENT(f)) f = optimizer%f
707 IF (
PRESENT(last_f)) last_f = optimizer%last_f
708 IF (
PRESENT(projected_gradient)) &
709 projected_gradient = optimizer%projected_gradient
710 IF (
PRESENT(n_iter)) n_iter = optimizer%n_iter
711 CALL timestop(handle)
713 END SUBROUTINE cp_opt_gopt_step
729 SUBROUTINE cp_opt_gopt_bcast_res(optimizer, n_iter, f, last_f, &
732 INTEGER,
INTENT(out),
OPTIONAL :: n_iter
733 REAL(kind=dp),
INTENT(inout),
OPTIONAL :: f, last_f, projected_gradient
735 REAL(kind=dp),
DIMENSION(4) :: results
737 IF (optimizer%master == optimizer%para_env%mepos)
THEN
738 results = (/real(optimizer%isave(30), kind=dp), &
739 optimizer%f, optimizer%dsave(2), optimizer%dsave(13)/)
741 CALL optimizer%para_env%bcast(results, optimizer%master)
742 IF (
PRESENT(n_iter)) n_iter = nint(results(1))
743 IF (
PRESENT(f)) f = results(2)
744 IF (
PRESENT(last_f)) last_f = results(3)
745 IF (
PRESENT(projected_gradient)) &
746 projected_gradient = results(4)
748 END SUBROUTINE cp_opt_gopt_bcast_res
772 projected_gradient, converged, geo_section, force_env, &
773 gopt_param, spgr)
RESULT(res)
775 INTEGER,
INTENT(out),
OPTIONAL :: n_iter
776 REAL(kind=dp),
INTENT(out),
OPTIONAL :: f, last_f, projected_gradient
777 LOGICAL,
INTENT(out) :: converged
781 TYPE(
spgr_type),
OPTIONAL,
POINTER :: spgr
785 CALL cp_opt_gopt_step(optimizer, n_iter=n_iter, f=f, &
786 last_f=last_f, projected_gradient=projected_gradient, &
787 converged=converged, geo_section=geo_section, &
788 force_env=force_env, gopt_param=gopt_param, spgr=spgr)
789 res = (optimizer%status < 40) .AND. .NOT. converged
804 optimizer%task =
'STOPPED on user request'
806 IF (optimizer%master == optimizer%para_env%mepos)
THEN
807 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
808 optimizer%lower_bound, optimizer%upper_bound, &
809 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
810 optimizer%wanted_relative_f_delta, &
811 optimizer%wanted_projected_gradient, optimizer%work_array, &
812 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
813 optimizer%csave, optimizer%lsave, optimizer%isave, &
814 optimizer%dsave, optimizer%trust_radius)
subroutine cp_eval_at(gopt_env, x, f, gradient, master, final_evaluation, para_env)
evaluete the potential energy and its gradients using an array with same dimension as the particle_se...
routines that optimize a functional using the limited memory bfgs quasi-newton method....
subroutine, public cp_opt_gopt_create(optimizer, para_env, obj_funct, x0, m, print_every, wanted_relative_f_delta, wanted_projected_gradient, lower_bound, upper_bound, kind_of_bound, master, max_f_per_iter, trust_radius)
initializes the optimizer
logical function, public cp_opt_gopt_next(optimizer, n_iter, f, last_f, projected_gradient, converged, geo_section, force_env, gopt_param, spgr)
goes to the next optimal point (after an optimizer iteration) returns true if converged
subroutine, public cp_opt_gopt_stop(optimizer)
stops the optimization
subroutine, public cp_opt_gopt_release(optimizer)
releases the optimizer (see doc/ReferenceCounting.html)
LBFGS-B routine (version 3.0, April 25, 2011)
subroutine, public setulb(n, m, x, lower_bound, upper_bound, nbd, f, g, factr, pgtol, wa, iwa, task, iprint, csave, lsave, isave, dsave, trust_radius, spgr)
This subroutine partitions the working arrays wa and iwa, and then uses the limited memory BFGS metho...
various routines to log and control the output. The idea is that decisions about where to log should ...
type(cp_logger_type) function, pointer, public cp_get_default_logger()
returns the default logger
routines to handle the output, The idea is to remove the decision of wheter to output and what to out...
integer function, public cp_print_key_unit_nr(logger, basis_section, print_key_path, extension, middle_name, local, log_filename, ignore_should_output, file_form, file_position, file_action, file_status, do_backup, on_file, is_new_file, mpi_io, fout)
...
subroutine, public cp_print_key_finished_output(unit_nr, logger, basis_section, print_key_path, local, ignore_should_output, on_file, mpi_io)
should be called after you finish working with a unit obtained with cp_print_key_unit_nr,...
types that represent a subsys, i.e. a part of the system
Interface for the force calculations.
recursive subroutine, public force_env_get(force_env, in_use, fist_env, qs_env, meta_env, fp_env, subsys, para_env, potential_energy, additional_potential, kinetic_energy, harmonic_shell, kinetic_shell, cell, sub_force_env, qmmm_env, qmmmx_env, eip_env, pwdft_env, globenv, input, force_env_section, method_name_id, root_section, mixed_env, nnp_env, embed_env, ipi_env)
returns various attributes about the force environment
contains a functional that calculates the energy and its derivatives for the geometry optimizer
subroutine, public gopt_f_io(gopt_env, force_env, root_section, its, opt_energy, output_unit, eold, emin, wildcard, gopt_param, ndf, dx, xi, conv, pred, rat, step, rad, used_time)
Handles the Output during an optimization run.
contains a functional that calculates the energy and its derivatives for the geometry optimizer
subroutine, public gopt_f_retain(gopt_env)
...
recursive subroutine, public gopt_f_release(gopt_env)
...
contains typo and related routines to handle parameters controlling the GEO_OPT module
Defines the basic variable types.
integer, parameter, public dp
Machine interface based on Fortran 2003 and POSIX.
real(kind=dp) function, public m_walltime()
returns time from a real-time clock, protected against rolling early/easily
Interface to the message passing library MPI.
subroutine, public mp_para_env_release(para_env)
releases the para object (to be called when you don't want anymore the shared copy of this object)
Space Group Symmetry Type Module (version 1.0, Ferbruary 12, 2021)
Space Group Symmetry Module (version 1.0, January 16, 2020)
subroutine, public spgr_apply_rotations_coord(spgr, coord)
routine applies the rotation matrices to the coordinates.
subroutine, public spgr_apply_rotations_force(spgr, force)
routine applies the rotation matrices to the forces.
info for the optimizer (see the description of this module)
type of a logger, at the moment it contains just a print level starting at which level it should be l...
represents a system: atoms, molecules, their pos,vel,...
wrapper to abstract the force evaluation of the various methods
calculates the potential energy of a system, and its derivatives
stores all the informations relevant to an mpi environment