minimizer_algorithm.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_algorithm_oct_m
  use algorithm_oct_m
  use debug_oct_m
  use global_oct_m
  use iteration_counter_oct_m
  use loct_oct_m
  use messages_oct_m
  use namespace_oct_m
  use system_oct_m
  use walltimer_oct_m
 
  implicit none
 
  private
  public ::                       &
    minimizer_algorithm_t,     &
    minimizer_algorithm_finished
 
  type, extends(algorithm_t), abstract :: minimizer_algorithm_t
    private
    class(system_t), pointer, public :: system
    integer, public :: max_iter
    logical, public :: converged = .false.
  contains
    ! Below are the list of operations that needs to be implemented
    procedure :: do_operation => minimizer_algorithm_do_operation
    
    procedure :: finished => minimizer_algorithm_finished
    
    procedure :: init_iteration_counters => minimizer_algorithm_init_iteration_counters
    
    procedure :: write_output_header => minimizer_algorithm_write_output_header
    
    procedure :: continues_after_finished => minimizer_continues_after_finished
    
    procedure :: print_speed => minimizer_algorithm_print_speed 
  end type minimizer_algorithm_t
 
contains
 
  logical function minimizer_algorithm_do_operation(this, operation) result(done)
    class(minimizer_algorithm_t),           intent(inout) :: this
    type(algorithmic_operation_t), intent(in)    :: operation
 
    ! Nothing done yet here
    done = .false.
 
  end function minimizer_algorithm_do_operation
 
  ! ---------------------------------------------------------
  logical function minimizer_algorithm_finished(this) result(finished)
    class(minimizer_algorithm_t), intent(in) :: this
 
    type(iteration_counter_t) :: iter
 
    iter = this%system%iteration
    finished = iter%value() > this%max_iter
 
    finished = finished .or. this%converged
  end function minimizer_algorithm_finished
 
  ! ---------------------------------------------------------
  subroutine minimizer_algorithm_init_iteration_counters(this)
    class(minimizer_algorithm_t), intent(inout) :: this
 
    this%iteration = iteration_counter_t()
    this%system%iteration = iteration_counter_t()
 
  end subroutine minimizer_algorithm_init_iteration_counters
 
 
  subroutine minimizer_algorithm_write_output_header(this)
    class(minimizer_algorithm_t), intent(in) :: this
 
    push_sub(minimizer_algorithm_write_output_header)
 
    call messages_print_with_emphasis(msg="Multi-system minimizer", namespace=this%system%namespace)
    call messages_print_with_emphasis(namespace=this%system%namespace)
 
    pop_sub(minimizer_algorithm_write_output_header)
  end subroutine minimizer_algorithm_write_output_header
 
 
  ! The GS algorithms need to keep going even when they are finished,
  ! otherwise other systems would get stuck at the update coupling step
  logical function minimizer_continues_after_finished(this)
    class(minimizer_algorithm_t), intent(in) :: this
 
    push_sub(minimizer_continues_after_finished)
 
    minimizer_continues_after_finished = .true.
 
    pop_sub(minimizer_continues_after_finished)
  end function minimizer_continues_after_finished
 
  ! ---------------------------------------------------------
  !
  subroutine minimizer_algorithm_print_speed(this)
    class(minimizer_algorithm_t), intent(in) :: this
    real(real64) :: wall_time, simulation_time, speed_per_day
 
    ! Output propagation speed in iterations/day
    wall_time = loct_clock() - walltimer_get_start_time()
    simulation_time = this%iteration%value(elapsed=.true.)
    speed_per_day = simulation_time / (wall_time / 86400.0_real64)
    write(message(1), '(a,f10.3,a)') 'Propagation speed: ', speed_per_day, ' iterations/day'
    write(message(2), '(a)') ''
    call messages_info(2, namespace=this%system%namespace)
 
  end subroutine minimizer_algorithm_print_speed
end module minimizer_algorithm_oct_m
 
 
!! Local Variables:
!! mode: f90
!! coding: utf-8
!! End: