minimizer_factory.F90

Go to the documentation of this file.

!! Copyright (C) 2024 N. Tancogne-Dejean
!!
!! This program is free software; you can redistribute it and/or modify
!! it under the terms of the GNU General Public License as published by
!! the Free Software Foundation; either version 2, or (at your option)
!! any later version.
!!
!! This program is distributed in the hope that it will be useful,
!! but WITHOUT ANY WARRANTY; without even the implied warranty of
!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!! GNU General Public License for more details.
!!
!! You should have received a copy of the GNU General Public License
!! along with this program; if not, write to the Free Software
!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
!! 02110-1301, USA.
!!
 
#include "global.h"
 
 
 
module minimizer_factory_oct_m
  use, intrinsic :: iso_fortran_env
  use algorithm_factory_oct_m
  use algorithm_oct_m
  use debug_oct_m
  use electrons_oct_m
  use global_oct_m
  use minimizer_algorithm_oct_m
  use minimizer_static_oct_m
  use minimizer_scf_oct_m
  use interaction_partner_oct_m
  use messages_oct_m
  use multisystem_basic_oct_m
  use namespace_oct_m
  use parser_oct_m
  use unit_system_oct_m
  use varinfo_oct_m
  use system_oct_m
  implicit none
 
  private
  public :: minimizer_factory_t
 
  ! Known multisystem minimizers
  integer, public, parameter ::        &
    GROUND_STATE_STATIC           = 0, &
    ground_state_scf              = 1
 
 
  type, extends(algorithm_factory_t) :: minimizer_factory_t
    private
    integer :: max_iter
  contains
    procedure :: create => minimizer_factory_create               
    procedure :: create_static => minimizer_factory_create_static 
  end type minimizer_factory_t
 
  interface minimizer_factory_t
    module procedure minimizer_factory_constructor
  end interface minimizer_factory_t
 
 
contains
  ! ---------------------------------------------------------------------------------------
  !
  function minimizer_factory_constructor(namespace) result(factory)
    type(namespace_t), intent(in) :: namespace
    type(minimizer_factory_t) :: factory
 
    push_sub(minimizer_factory_constructor)
 
    ! Get the maximum number of iterations
    ! This variable is also defined (and properly documented) in scf/scf.F90.
    call parse_variable(namespace, 'MaximumIter', 200, factory%max_iter)
 
    pop_sub(minimizer_factory_constructor)
  end function minimizer_factory_constructor
 
  ! ---------------------------------------------------------------------------------------
  !
  function minimizer_factory_create(this, system) result(algorithm)
    class(minimizer_factory_t),  intent(in) :: this
    class(interaction_partner_t), intent(in), target :: system
    class(algorithm_t), pointer :: algorithm
 
    integer :: default, algo_type
    class(minimizer_algorithm_t), pointer :: algo
 
    push_sub(minimizer_factory_create)
 
    !%Variable GroundStateAlgorithm
    !%Type integer
    !%Section SCF
    !%Description
    !% A variable to set the algorithm for the ground state.
    !%Option static 0
    !% Do not change during the SCF iterations. Default for anything apart electrons.
    !%Option scf 1
    !% Self-consistent field. Default for electrons.
    !%End
    default = ground_state_static
    select type(system)
    type is(electrons_t)
      default = ground_state_scf
    end select
    call parse_variable(system%namespace, 'GroundStateAlgorithm',default, algo_type)
    if (.not. varinfo_valid_option('GroundStateAlgorithm', algo_type)) then
      call messages_input_error(system%namespace, 'GroundStateAlgorithm')
    end if
    call messages_print_with_emphasis(msg='System algorithm', namespace=system%namespace)
    call messages_print_var_option('GroundStateAlgorithm', algo_type, namespace=system%namespace)
 
    select case (algo_type)
    case (ground_state_static)
      algo => minimizer_static_t()
    case (ground_state_scf)
      algo => minimizer_scf_t()
    case default
      call messages_input_error(system%namespace, 'GroudStateAlgorithm')
    end select
 
    call messages_print_with_emphasis(namespace=system%namespace)
 
    algo%max_iter = this%max_iter
 
    select type (system)
    class is (system_t)
      algo%system => system
    class default
      assert(.false.)
    end select
 
    algorithm => algo
 
    pop_sub(minimizer_factory_create)
  end function minimizer_factory_create
 
  ! ---------------------------------------------------------------------------------------
  !
  function minimizer_factory_create_static(this, system) result(algorithm)
    class(minimizer_factory_t),  intent(in)         :: this
    class(interaction_partner_t), intent(in), target :: system
    class(algorithm_t), pointer :: algorithm
 
    class(minimizer_algorithm_t), pointer :: minimizer
 
    push_sub(minimizer_factory_create_static)
 
    minimizer => minimizer_static_t()
    minimizer%max_iter = this%max_iter
 
    select type (system)
    class is (system_t)
      minimizer%system => system
    class default
      assert(.false.)
    end select
 
    algorithm => minimizer
 
    pop_sub(minimizer_factory_create_static)
  end function minimizer_factory_create_static
 
 
end module minimizer_factory_oct_m
 
!! Local Variables:
!! mode: f90
!! coding: utf-8
!! End: