46#include "../base/base_uses.f90"
51 LOGICAL,
PRIVATE,
PARAMETER :: debug_this_module = .true.
52 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'cp_lbfgs_optimizer_gopt'
131 CHARACTER(len=60) :: task =
""
132 CHARACTER(len=60) :: csave =
""
133 LOGICAL :: lsave(4) = .false.
134 INTEGER :: m = 0, print_every = 0, master = 0, max_f_per_iter = 0, status = 0, n_iter = 0
135 INTEGER,
DIMENSION(:),
POINTER :: kind_of_bound => null(), i_work_array => null(), isave => null()
136 REAL(kind=
dp) :: f = 0.0_dp, wanted_relative_f_delta = 0.0_dp, wanted_projected_gradient = 0.0_dp, &
137 last_f = 0.0_dp, projected_gradient = 0.0_dp, eold = 0.0_dp, emin = 0.0_dp, trust_radius = 0.0_dp
138 REAL(kind=
dp),
DIMENSION(:),
POINTER :: x => null(), lower_bound => null(), upper_bound => null(), &
139 gradient => null(), dsave => null(), work_array => null()
154 TYPE(
spgr_type),
OPTIONAL,
POINTER :: spgr
155 INTEGER,
OPTIONAL :: iwunit
157 CALL setulb(
SIZE(optimizer%x), optimizer%m, optimizer%x, &
158 optimizer%lower_bound, optimizer%upper_bound, &
159 optimizer%kind_of_bound, optimizer%f, optimizer%gradient, &
160 optimizer%wanted_relative_f_delta, &
161 optimizer%wanted_projected_gradient, optimizer%work_array, &
162 optimizer%i_work_array, optimizer%task, optimizer%print_every, &
163 optimizer%csave, optimizer%lsave, optimizer%isave, &
164 optimizer%dsave, optimizer%trust_radius, spgr=spgr, iwunit=iwunit)
192 wanted_relative_f_delta, wanted_projected_gradient, lower_bound, upper_bound, &
193 kind_of_bound, master, max_f_per_iter, trust_radius)
197 REAL(kind=
dp),
DIMENSION(:),
INTENT(in) :: x0
198 INTEGER,
INTENT(in),
OPTIONAL :: m, print_every
199 REAL(kind=
dp),
INTENT(in),
OPTIONAL :: wanted_relative_f_delta, &
200 wanted_projected_gradient
201 REAL(kind=
dp),
DIMENSION(SIZE(x0)),
INTENT(in), &
202 OPTIONAL :: lower_bound, upper_bound
203 INTEGER,
DIMENSION(SIZE(x0)),
INTENT(in),
OPTIONAL :: kind_of_bound
204 INTEGER,
INTENT(in),
OPTIONAL :: master, max_f_per_iter
205 REAL(kind=
dp),
INTENT(in),
OPTIONAL :: trust_radius
207 CHARACTER(len=*),
PARAMETER :: routinen =
'cp_opt_gopt_create'
209 INTEGER :: handle, lenwa, n
211 CALL timeset(routinen, handle)
213 NULLIFY (optimizer%kind_of_bound, &
214 optimizer%i_work_array, &
217 optimizer%lower_bound, &
218 optimizer%upper_bound, &
219 optimizer%gradient, &
221 optimizer%work_array, &
222 optimizer%para_env, &
226 IF (
PRESENT(m)) optimizer%m = m
227 optimizer%master = para_env%source
228 optimizer%para_env => para_env
229 CALL para_env%retain()
230 optimizer%obj_funct => obj_funct
232 optimizer%max_f_per_iter = 20
233 IF (
PRESENT(max_f_per_iter)) optimizer%max_f_per_iter = max_f_per_iter
234 optimizer%print_every = -1
236 optimizer%f = -1.0_dp
237 optimizer%last_f = -1.0_dp
238 optimizer%projected_gradient = -1.0_dp
239 IF (
PRESENT(print_every)) optimizer%print_every = print_every
240 IF (
PRESENT(master)) optimizer%master = master
241 IF (optimizer%master == optimizer%para_env%mepos)
THEN
243 lenwa = 2*optimizer%m*n + 5*n + 11*optimizer%m*optimizer%m + 8*optimizer%m
244 ALLOCATE (optimizer%kind_of_bound(n), optimizer%i_work_array(3*n), &
246 ALLOCATE (optimizer%x(n), optimizer%lower_bound(n), &
247 optimizer%upper_bound(n), optimizer%gradient(n), &
248 optimizer%dsave(29), optimizer%work_array(lenwa))
250 optimizer%task =
'START'
251 optimizer%i_work_array = 0
253 optimizer%lower_bound = 0.0_dp
254 optimizer%upper_bound = 0.0_dp
255 optimizer%gradient = 0.0_dp
256 optimizer%dsave = 0.0_dp
257 optimizer%work_array = 0.0_dp
258 IF (
PRESENT(wanted_relative_f_delta))
THEN
259 optimizer%wanted_relative_f_delta = wanted_relative_f_delta
261 IF (
PRESENT(wanted_projected_gradient))
THEN
262 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
273 optimizer%kind_of_bound, optimizer%i_work_array, optimizer%isave, &
274 optimizer%lower_bound, optimizer%upper_bound, optimizer%gradient, &
275 optimizer%dsave, optimizer%work_array)
276 ALLOCATE (optimizer%x(n))
277 optimizer%x(:) = 0.0_dp
278 ALLOCATE (optimizer%gradient(n))
279 optimizer%gradient(:) = 0.0_dp
281 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
284 CALL timestop(handle)
299 CHARACTER(len=*),
PARAMETER :: routinen =
'cp_opt_gopt_release'
303 CALL timeset(routinen, handle)
305 IF (
ASSOCIATED(optimizer%kind_of_bound))
THEN
306 DEALLOCATE (optimizer%kind_of_bound)
308 IF (
ASSOCIATED(optimizer%i_work_array))
THEN
309 DEALLOCATE (optimizer%i_work_array)
311 IF (
ASSOCIATED(optimizer%isave))
THEN
312 DEALLOCATE (optimizer%isave)
314 IF (
ASSOCIATED(optimizer%x))
THEN
315 DEALLOCATE (optimizer%x)
317 IF (
ASSOCIATED(optimizer%lower_bound))
THEN
318 DEALLOCATE (optimizer%lower_bound)
320 IF (
ASSOCIATED(optimizer%upper_bound))
THEN
321 DEALLOCATE (optimizer%upper_bound)
323 IF (
ASSOCIATED(optimizer%gradient))
THEN
324 DEALLOCATE (optimizer%gradient)
326 IF (
ASSOCIATED(optimizer%dsave))
THEN
327 DEALLOCATE (optimizer%dsave)
329 IF (
ASSOCIATED(optimizer%work_array))
THEN
330 DEALLOCATE (optimizer%work_array)
335 CALL timestop(handle)
356 SUBROUTINE cp_opt_gopt_step(optimizer, n_iter, f, last_f, &
357 projected_gradient, converged, geo_section, force_env, &
360 INTEGER,
INTENT(out),
OPTIONAL :: n_iter
361 REAL(kind=
dp),
INTENT(out),
OPTIONAL :: f, last_f, projected_gradient
362 LOGICAL,
INTENT(out),
OPTIONAL :: converged
367 CHARACTER(len=*),
PARAMETER :: routinen =
'cp_opt_gopt_step'
369 CHARACTER(LEN=5) :: wildcard
370 INTEGER :: dataunit, handle, its
371 LOGICAL :: conv, is_master, just_entered
372 REAL(kind=
dp) :: t_diff, t_now, t_old
373 REAL(kind=
dp),
DIMENSION(:),
POINTER :: xold
377 NULLIFY (logger, xold)
379 CALL timeset(routinen, handle)
380 just_entered = .true.
381 is_master = optimizer%master == optimizer%para_env%mepos
382 IF (
PRESENT(converged)) converged = optimizer%status == 4
383 ALLOCATE (xold(
SIZE(optimizer%x)))
394 IF (optimizer%status >= 4)
THEN
395 cpwarn(
"status>=4, trying to restart")
398 "PRINT%PROGRAM_RUN_INFO", extension=
".geoLog")
400 optimizer%task =
'START'
404 "PRINT%PROGRAM_RUN_INFO")
409 "PRINT%PROGRAM_RUN_INFO", extension=
".geoLog")
410 ifmaster:
IF (is_master)
THEN
411 IF (optimizer%task(1:7) ==
'RESTART')
THEN
414 optimizer%task =
'START'
422 IF (optimizer%task(1:2) ==
'FG')
THEN
423 IF (optimizer%isave(36) > optimizer%max_f_per_iter)
THEN
424 optimizer%task =
'STOP: CPU, hit max f eval in iter'
430 ELSE IF (optimizer%task(1:5) ==
'NEW_X')
THEN
431 IF (just_entered)
THEN
445 ELSE IF (optimizer%task(1:4) ==
'CONV')
THEN
447 ELSE IF (optimizer%task(1:4) ==
'STOP')
THEN
449 cpwarn(
"task became stop in an unknown way")
450 ELSE IF (optimizer%task(1:5) ==
'ERROR')
THEN
453 cpwarn(
"unknown task '"//optimizer%task//
"'")
457 "PRINT%PROGRAM_RUN_INFO")
458 CALL optimizer%para_env%bcast(optimizer%status, optimizer%master)
460 IF (optimizer%status == 3)
THEN
464 its = optimizer%isave(30)
468 SELECT CASE (optimizer%status)
471 CALL cp_eval_at(optimizer%obj_funct, x=optimizer%x, &
473 gradient=optimizer%gradient, &
474 master=optimizer%master, para_env=optimizer%para_env)
477 "PRINT%PROGRAM_RUN_INFO", extension=
".geoLog")
487 "PRINT%PROGRAM_RUN_INFO")
488 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
491 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
497 "PRINT%PROGRAM_RUN_INFO", extension=
".geoLog")
498 IF (is_master) its = optimizer%isave(30)
499 CALL optimizer%para_env%bcast(its, optimizer%master)
503 t_diff = t_now - t_old
505 CALL gopt_f_io(optimizer%obj_funct, force_env, force_env%root_section, &
506 its, optimizer%f, dataunit, optimizer%eold, optimizer%emin, wildcard, gopt_param, &
507 SIZE(optimizer%x), optimizer%x - xold, optimizer%gradient, conv, used_time=t_diff)
508 CALL optimizer%para_env%bcast(conv, optimizer%master)
510 "PRINT%PROGRAM_RUN_INFO")
511 optimizer%eold = optimizer%f
512 optimizer%emin = min(optimizer%emin, optimizer%eold)
514 IF (
PRESENT(converged)) converged = conv
521 "PRINT%PROGRAM_RUN_INFO", extension=
".geoLog")
522 IF (dataunit > 0)
THEN
523 WRITE (dataunit,
'(T2,A)')
""
524 WRITE (dataunit,
'(T2,A)')
"************************************************"
525 WRITE (dataunit,
'(T2,A)')
"* Specific L-BFGS convergence criteria *"
526 WRITE (dataunit,
'(T2,A)')
"* WANTED_PROJ_GRADIENT and WANTED_REL_F_ERROR *"
527 WRITE (dataunit,
'(T2,A)')
"* satisfied .... run CONVERGED! *"
528 WRITE (dataunit,
'(T2,A)')
"* * * * *"
529 WRITE (dataunit,
'(T2,A)')
"* General convergence criteria on stepsize and *"
530 WRITE (dataunit,
'(T2,A)')
"* gradients may or may not have been satisfied *"
531 WRITE (dataunit,
'(T2,A)')
"* yet; if unsatisfactory, try tightening the *"
532 WRITE (dataunit,
'(T2,A)')
"* L-BFGS convergence criteria and restart run. *"
533 WRITE (dataunit,
'(T2,A)')
"************************************************"
534 WRITE (dataunit,
'(T2,A)')
""
537 "PRINT%PROGRAM_RUN_INFO")
538 IF (
PRESENT(converged)) converged = .true.
542 CALL optimizer%para_env%bcast(optimizer%task, optimizer%master)
544 CALL cp_eval_at(optimizer%obj_funct, x=optimizer%x, &
545 f=optimizer%f, gradient=optimizer%gradient, &
546 master=optimizer%master, para_env=optimizer%para_env)
547 IF (
PRESENT(converged)) converged = .false.
551 cpabort(
"step on a deallocated opt structure ")
553 CALL cp_abort(__location__, &
558 IF (optimizer%status == 1 .AND. just_entered)
THEN
559 optimizer%eold = optimizer%f
560 optimizer%emin = optimizer%eold
562 just_entered = .false.
565 CALL optimizer%para_env%bcast(optimizer%x, optimizer%master)
566 CALL cp_opt_gopt_bcast_res(optimizer, &
567 n_iter=optimizer%n_iter, &
568 f=optimizer%f, last_f=optimizer%last_f, &
569 projected_gradient=optimizer%projected_gradient)
572 IF (
PRESENT(f)) f = optimizer%f
573 IF (
PRESENT(last_f)) last_f = optimizer%last_f
574 IF (
PRESENT(projected_gradient)) projected_gradient = optimizer%projected_gradient
575 IF (
PRESENT(n_iter)) n_iter = optimizer%n_iter
576 CALL timestop(handle)
578 END SUBROUTINE cp_opt_gopt_step
594 SUBROUTINE cp_opt_gopt_bcast_res(optimizer, n_iter, f, last_f, &
597 INTEGER,
INTENT(out),
OPTIONAL :: n_iter
598 REAL(kind=
dp),
INTENT(inout),
OPTIONAL :: f, last_f, projected_gradient
600 REAL(kind=
dp),
DIMENSION(4) :: results
602 IF (optimizer%master == optimizer%para_env%mepos)
THEN
603 results = [real(optimizer%isave(30), kind=
dp), &
604 optimizer%f, optimizer%dsave(2), optimizer%dsave(13)]
606 CALL optimizer%para_env%bcast(results, optimizer%master)
607 IF (
PRESENT(n_iter)) n_iter = nint(results(1))
608 IF (
PRESENT(f)) f = results(2)
609 IF (
PRESENT(last_f)) last_f = results(3)
610 IF (
PRESENT(projected_gradient)) projected_gradient = results(4)
612 END SUBROUTINE cp_opt_gopt_bcast_res
635 projected_gradient, converged, geo_section, force_env, &
636 gopt_param)
RESULT(res)
638 INTEGER,
INTENT(out),
OPTIONAL :: n_iter
639 REAL(kind=
dp),
INTENT(out),
OPTIONAL :: f, last_f, projected_gradient
640 LOGICAL,
INTENT(out) :: converged
646 CALL cp_opt_gopt_step(optimizer, n_iter=n_iter, f=f, &
647 last_f=last_f, projected_gradient=projected_gradient, &
648 converged=converged, geo_section=geo_section, &
649 force_env=force_env, gopt_param=gopt_param)
650 res = (optimizer%status < 4) .AND. .NOT. converged
665 optimizer%task =
'STOPPED on user request'
667 IF (optimizer%master == optimizer%para_env%mepos)
THEN
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
subroutine cp_opt_gopt_setulb(optimizer, spgr, iwunit)
calls the L-BFGS optimizer
subroutine, public cp_opt_gopt_stop(optimizer)
stops the optimization
logical function, public cp_opt_gopt_next(optimizer, n_iter, f, last_f, projected_gradient, converged, geo_section, force_env, gopt_param)
goes to the next optimal point (after an optimizer iteration) returns true if converged
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, iwunit)
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...
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,...
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, file_access)
...
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_project_coord(gopt_env, x)
Project optimizer coordinates onto the space-group-invariant subspace.
subroutine, public gopt_f_project_vector(gopt_env, v)
Project a gradient, step, or search direction onto the space-group subspace.
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.
subroutine, public cp_eval_at(gopt_env, x, f, gradient, master, para_env)
evaluete the potential energy and its gradients using an array with same dimension as the particle_se...
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).
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