environment.F

Go to the documentation of this file.

!--------------------------------------------------------------------------------------------------!
!   CP2K: A general program to perform molecular dynamics simulations                              !
!   Copyright 2000-2026 CP2K developers group <https://cp2k.org>                                   !
!                                                                                                  !
!   SPDX-License-Identifier: GPL-2.0-or-later                                                      !
!--------------------------------------------------------------------------------------------------!
 
! **************************************************************************************************
!> \brief Sets up and terminates the global environment variables
!> \par History
!>      - Merged with Quickstep MODULE start_program_run (17.01.2002,MK)
!>      - Compile information added (16.01.2002,MK)
!>      - Merged with MODULE cp2k_input, some rearrangements (30.10.2002,MK)
!>      - Update seed input (24.10.2016,MK)
!> \author JGH,MK
! **************************************************************************************************
MODULE environment
   USE bibliography,                    ONLY: frigo2005,&
                                              marek2014,&
                                              solca2024,&
                                              cite_reference
   USE cp2k_info,                       ONLY: &
        compile_arch, compile_date, compile_host, compile_revision, cp2k_flags, cp2k_home, &
        cp2k_version, cp2k_year, get_runtime_info, r_host_name, r_pid, r_user_name
   USE cp_cfm_elpa,                     ONLY: check_elpa_c_kernel_correctness
   USE cp_error_handling,               ONLY: warning_counter
   USE cp_files,                        ONLY: close_file,&
                                              get_data_dir,&
                                              open_file
   USE cp_fm_cholesky,                  ONLY: fm_cholesky_type_dlaf,&
                                              fm_cholesky_type_scalapack,&
                                              cholesky_type,&
                                              dlaf_cholesky_n_min
   USE cp_fm_diag,                      ONLY: &
        fm_diag_type_cusolver, fm_diag_type_dlaf, fm_diag_type_elpa, fm_diag_type_scalapack, &
        cusolver_n_min, diag_finalize, diag_init, diag_lib_explicit, diag_type, &
        eps_check_diag_default
   USE cp_fm_diag_utils,                ONLY: cp_fm_redistribute_init
   USE cp_fm_struct,                    ONLY: cp_fm_struct_config
   USE cp_fm_types,                     ONLY: cp_fm_get_mm_type,&
                                              cp_fm_setup
   USE cp_log_handling,                 ONLY: &
        cp_add_default_logger, cp_get_default_logger, cp_logger_create, &
        cp_logger_get_default_unit_nr, cp_logger_release, cp_logger_set, cp_logger_type, &
        cp_rm_default_logger, cp_to_string
   USE cp_output_handling,              ONLY: cp_mpi_io_set,&
                                              cp_print_key_finished_output,&
                                              cp_print_key_unit_nr,&
                                              debug_print_level,&
                                              high_print_level,&
                                              low_print_level,&
                                              medium_print_level,&
                                              silent_print_level
   USE fft_tools,                       ONLY: fwfft,&
                                              fft3d,&
                                              finalize_fft,&
                                              init_fft
   USE force_env_types,                 ONLY: multiple_fe_list
   USE gamma,                           ONLY: deallocate_md_ftable
   USE global_types,                    ONLY: global_environment_type
   USE grid_api,                        ONLY: grid_backend_auto,&
                                              grid_backend_cpu,&
                                              grid_backend_dgemm,&
                                              grid_backend_gpu,&
                                              grid_backend_ref
   USE header,                          ONLY: cp2k_footer,&
                                              cp2k_header
   USE input_constants,                 ONLY: &
        callgraph_all, callgraph_none, do_cosma, do_cp2k, do_dgemm_blas, do_dgemm_spla, do_eip, &
        do_farming, do_fft_fftw3, do_fft_sg, do_fist, do_qs, do_scalapack, do_sirius, do_test, &
        energy_run, mol_dyn_run, none_run
   USE input_cp2k_global,               ONLY: create_global_section
   USE input_enumeration_types,         ONLY: enum_i2c,&
                                              enumeration_type
   USE input_keyword_types,             ONLY: keyword_get,&
                                              keyword_type
   USE input_section_types,             ONLY: &
        section_get_ival, section_get_keyword, section_get_lval, section_get_rval, &
        section_release, section_type, section_vals_get, section_vals_get_subs_vals, &
        section_vals_get_subs_vals3, section_vals_type, section_vals_val_get, section_vals_val_set
   USE integral_library_types,          ONLY: integral_library_init
   USE kinds,                           ONLY: default_path_length,&
                                              default_string_length,&
                                              dp,&
                                              int_8,&
                                              print_kind_info
   USE local_gemm_api,                  ONLY: local_gemm_set_library
   USE machine,                         ONLY: &
        flush_should_flush, m_cpuid, m_cpuid_name, m_cpuid_static, m_cpuid_vlen, m_cpuinfo, &
        m_energy, m_memory_details, m_omp_get_stacksize, m_omp_trace_issues, m_procrun
   USE message_passing,                 ONLY: mp_collect_timings,&
                                              mp_para_env_type
   USE mp_perf_env,                     ONLY: add_mp_perf_env,&
                                              describe_mp_perf_env,&
                                              rm_mp_perf_env
   USE orbital_pointers,                ONLY: deallocate_orbital_pointers,&
                                              init_orbital_pointers
   USE orbital_transformation_matrices, ONLY: deallocate_spherical_harmonics,&
                                              init_spherical_harmonics
   USE parallel_rng_types,              ONLY: gaussian,&
                                              check_rng,&
                                              rng_stream_type,&
                                              write_rng_matrices
   USE physcon,                         ONLY: write_physcon
   USE reference_manager,               ONLY: collect_citations_from_ranks,&
                                              print_cited_references
   USE string_utilities,                ONLY: ascii_to_string,&
                                              integer_to_string,&
                                              string_to_ascii
   USE timings,                         ONLY: add_timer_env,&
                                              global_timings_level,&
                                              rm_timer_env,&
                                              root_cp2k_name,&
                                              timings_setup_tracing
   USE timings_report,                  ONLY: cost_type_energy,&
                                              cost_type_time,&
                                              timings_report_callgraph,&
                                              timings_report_print
   USE voronoi_interface,               ONLY: finalize_libvori
   USE xc_libxc,                        ONLY: libxc_release_workers
 
!$ USE OMP_LIB, ONLY: omp_get_max_threads, omp_get_thread_num, omp_get_num_threads
#include "./base/base_uses.f90"
 
   IMPLICIT NONE
 
   PRIVATE
 
   CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'environment'
 
   ! Public subroutines
 
   PUBLIC :: cp2k_finalize, cp2k_init, cp2k_read, cp2k_setup, cp2k_get_walltime
 
CONTAINS
 
! **************************************************************************************************
!> \brief Initializes a CP2K run (setting of the global environment variables)
!> \param para_env ...
!> \param output_unit ...
!> \param globenv ...
!> \param input_file_name ...
!> \param wdir ...
!> \par History
!>      JGH (28.11.2001) : default for pp_library_path
!>      - print keys added (17.01.2002, MK)
!>      - merged with cp2k_input (30.10.2002,MK)
!> \author JGH,MK
! **************************************************************************************************
   SUBROUTINE cp2k_init(para_env, output_unit, globenv, input_file_name, wdir)
 
      TYPE(mp_para_env_type), POINTER                    :: para_env
      INTEGER                                            :: output_unit
      TYPE(global_environment_type), POINTER             :: globenv
      CHARACTER(LEN=*)                                   :: input_file_name
      CHARACTER(LEN=*), OPTIONAL                         :: wdir
 
      CHARACTER(LEN=10*default_string_length)            :: cp_flags
      INTEGER                                            :: i, ilen, my_output_unit
      TYPE(cp_logger_type), POINTER                      :: logger
 
      ! create a timer_env
 
      CALL add_timer_env()
 
      ! Message passing performance
      CALL add_mp_perf_env()
 
      ! Init the default logger
      IF (para_env%is_source()) THEN
         my_output_unit = output_unit
      ELSE
         my_output_unit = -1
      END IF
      NULLIFY (logger)
      CALL cp_logger_create(logger, para_env=para_env, &
                            default_global_unit_nr=output_unit, &
                            close_global_unit_on_dealloc=.false.)
      CALL cp_add_default_logger(logger)
      CALL cp_logger_release(logger)
 
      ! Initialize timing
      CALL timeset(root_cp2k_name, globenv%handle)
 
      ! Print header
      CALL cp2k_header(my_output_unit, wdir)
 
      IF (my_output_unit > 0) THEN
         WRITE (unit=my_output_unit, fmt="(/,T2,A,T31,A50)") &
            "CP2K| version string: ", adjustr(trim(cp2k_version))
         WRITE (unit=my_output_unit, fmt="(T2,A,T41,A40)") &
            "CP2K| source code revision number:", &
            adjustr(compile_revision)
         cp_flags = cp2k_flags()
         ilen = len_trim(cp_flags)
         WRITE (unit=my_output_unit, fmt="(T2,A)") &
            "CP2K| "//cp_flags(1:73)
         IF (ilen > 73) THEN
            DO i = 0, (ilen - 75)/61
               WRITE (unit=my_output_unit, fmt="(T2,A)") &
                  "CP2K|            "//trim(cp_flags(74 + i*61:min(74 + (i + 1)*61, ilen)))
            END DO
         END IF
         WRITE (unit=my_output_unit, fmt="(T2,A,T41,A40)") &
            "CP2K| is freely available from ", &
            adjustr(trim(cp2k_home))
         WRITE (unit=my_output_unit, fmt="(T2,A,T31,A50)") &
            "CP2K| Program compiled at", &
            adjustr(compile_date(1:min(50, len(compile_date))))
         WRITE (unit=my_output_unit, fmt="(T2,A,T31,A50)") &
            "CP2K| Program compiled on", &
            adjustr(compile_host(1:min(50, len(compile_host))))
         WRITE (unit=my_output_unit, fmt="(T2,A,T31,A50)") &
            "CP2K| Program compiled for", &
            adjustr(compile_arch(1:min(50, len(compile_arch))))
         WRITE (unit=my_output_unit, fmt="(T2,A,T31,A50)") &
            "CP2K| Data directory path", &
            adjustr(trim(get_data_dir()))
         WRITE (unit=my_output_unit, fmt="(T2,A,T31,A50)") &
            "CP2K| Input file name", &
            adjustr(trim(input_file_name))
         FLUSH (my_output_unit) ! ignore &GLOBAL / FLUSH_SHOULD_FLUSH
      END IF
 
#if defined(__FAST_MATH__)
      CALL cp_warn(__location__, &
                   "During compilation one of the following flags was active:"// &
                   "   `-ffast-math` (GCC)"// &
                   "   `-hfpN` (Cray, N > 0, default N=2)"// &
                   " This can lead to wrong results and numerical instabilities"// &
                   " and is therefore no longer supported.")
 
#if !defined(__FORCE_USE_FAST_MATH)
#error "-ffast-math (GCC) or -hfpN (N>0, Cray) can lead to wrong results and numerical instabilities and are therefore no longer supported"
#endif
#endif
 
#if defined(NDEBUG)
#error "Please do not build CP2K with NDEBUG. There is no performance advantage and asserts will save your neck."
#endif
 
   END SUBROUTINE cp2k_init
 
! **************************************************************************************************
!> \brief echoes the list of host names and pids
!> \param para_env ...
!> \param output_unit ...
! **************************************************************************************************
   SUBROUTINE echo_all_hosts(para_env, output_unit)
      TYPE(mp_para_env_type), POINTER                    :: para_env
      INTEGER, INTENT(IN)                                :: output_unit
 
      CHARACTER(LEN=default_string_length)               :: string
      INTEGER                                            :: ipe
      INTEGER, ALLOCATABLE, DIMENSION(:)                 :: all_pid
      INTEGER, ALLOCATABLE, DIMENSION(:, :)              :: all_host
 
      ! Print a list of all started processes
 
      ALLOCATE (all_pid(para_env%num_pe), source=0)
      all_pid(para_env%mepos + 1) = r_pid
 
      CALL para_env%sum(all_pid)
      ALLOCATE (all_host(30, para_env%num_pe), source=0)
 
      CALL string_to_ascii(r_host_name, all_host(:, para_env%mepos + 1))
      CALL para_env%sum(all_host)
      IF (output_unit > 0) THEN
         WRITE (unit=output_unit, fmt="(T2,A)") ""
         DO ipe = 1, para_env%num_pe
            CALL ascii_to_string(all_host(:, ipe), string)
            WRITE (unit=output_unit, fmt="(T2,A,T63,I8,T71,I10)") &
               trim(r_user_name)//"@"//trim(string)// &
               " has created rank and process ", ipe - 1, all_pid(ipe)
         END DO
      END IF
 
      DEALLOCATE (all_pid)
      DEALLOCATE (all_host)
 
   END SUBROUTINE echo_all_hosts
 
! **************************************************************************************************
!> \brief echoes the list the number of process per host
!> \param para_env ...
!> \param output_unit ...
!> \param node_count Count number of distributed systems (nodes)
! **************************************************************************************************
   SUBROUTINE echo_all_process_host(para_env, output_unit, node_count)
      TYPE(mp_para_env_type), POINTER                    :: para_env
      INTEGER, INTENT(IN)                                :: output_unit
      INTEGER, INTENT(OUT), OPTIONAL                     :: node_count
 
      CHARACTER(LEN=default_string_length)               :: string, string_sec
      INTEGER                                            :: ipe, jpe, nr_dist, nr_occu
      INTEGER, ALLOCATABLE, DIMENSION(:)                 :: all_pid
      INTEGER, ALLOCATABLE, DIMENSION(:, :)              :: all_host
 
      ALLOCATE (all_host(30, para_env%num_pe), source=0)
      ALLOCATE (all_pid(para_env%num_pe), source=0)
 
      IF (m_procrun(r_pid) == 1) THEN
         CALL string_to_ascii(r_host_name, all_host(:, para_env%mepos + 1))
         CALL para_env%sum(all_host)
      END IF
 
      nr_dist = 0
      IF (output_unit > 0) WRITE (unit=output_unit, fmt="(T2,A)") ""
      DO ipe = 1, para_env%num_pe
         nr_occu = 0
         IF (all_pid(ipe) /= -1) THEN
            CALL ascii_to_string(all_host(:, ipe), string)
            DO jpe = 1, para_env%num_pe
               CALL ascii_to_string(all_host(:, jpe), string_sec)
               IF (string == string_sec) THEN
                  nr_occu = nr_occu + 1
                  all_pid(jpe) = -1
               END IF
            END DO
            IF (output_unit > 0) THEN
               WRITE (unit=output_unit, fmt="(T2,A,T63,I8,A)") &
                  trim(r_user_name)//"@"//trim(string)// &
                  " is running ", nr_occu, " processes"
            END IF
            nr_dist = nr_dist + 1
         END IF
      END DO
 
      DEALLOCATE (all_pid)
      DEALLOCATE (all_host)
 
      cpassert(0 < nr_dist)
      IF (PRESENT(node_count)) node_count = nr_dist
 
   END SUBROUTINE echo_all_process_host
 
! **************************************************************************************************
!> \brief read part of cp2k_init
!> \param root_section ...
!> \param para_env ...
!> \param globenv the globenv
!> \author fawzi
!> \note
!>      The following routines need to be synchronized wrt. adding/removing
!>      of the default environments (logging, performance,error):
!>      environment:cp2k_init, environment:cp2k_finalize,
!>      f77_interface:f_env_add_defaults, f77_interface:f_env_rm_defaults,
!>      f77_interface:create_force_env, f77_interface:destroy_force_env
! **************************************************************************************************
   SUBROUTINE cp2k_read(root_section, para_env, globenv)
 
      TYPE(section_vals_type), POINTER                   :: root_section
      TYPE(mp_para_env_type), POINTER                    :: para_env
      TYPE(global_environment_type), POINTER             :: globenv
 
      CHARACTER(LEN=3*default_string_length)             :: message
      CHARACTER(LEN=default_string_length)               :: c_val
      INTEGER                                            :: i, iw
      TYPE(cp_logger_type), POINTER                      :: logger
 
      ! Read the input/output section
 
      logger => cp_get_default_logger()
 
      ! try to use better names for the local log if it is not too late
      CALL section_vals_val_get(root_section, "GLOBAL%OUTPUT_FILE_NAME", &
                                c_val=c_val)
      IF (c_val /= "") THEN
         CALL cp_logger_set(logger, &
                            local_filename=trim(c_val)//"_localLog")
      END IF
 
      ! Process project name
      CALL section_vals_val_get(root_section, "GLOBAL%PROJECT", c_val=c_val)
      IF (index(c_val(:len_trim(c_val)), " ") > 0) THEN
         message = "Project name <"//trim(c_val)// &
                   "> contains spaces which will be replaced with underscores"
         cpwarn(trim(message))
         DO i = 1, len_trim(c_val)
            ! Replace space with underscore
            IF (c_val(i:i) == " ") c_val(i:i) = "_"
         END DO
         CALL section_vals_val_set(root_section, "GLOBAL%PROJECT", c_val=trim(c_val))
      END IF
      IF (c_val /= "") THEN
         CALL cp_logger_set(logger, local_filename=trim(c_val)//"_localLog")
      END IF
      logger%iter_info%project_name = c_val
 
      CALL section_vals_val_get(root_section, "GLOBAL%PRINT_LEVEL", i_val=logger%iter_info%print_level)
 
      ! Read the CP2K section
      CALL read_cp2k_section(root_section, para_env, globenv)
 
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PRINT/BASIC_DATA_TYPES", &
                                extension=".Log")
      IF (iw > 0) CALL print_kind_info(iw)
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%PRINT/BASIC_DATA_TYPES")
 
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PRINT/PHYSCON", &
                                extension=".Log")
      IF (iw > 0) CALL write_physcon(iw)
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%PRINT/PHYSCON")
 
   END SUBROUTINE cp2k_read
 
! **************************************************************************************************
!> \brief globenv initializations that need the input and error
!> \param root_section ...
!> \param para_env ...
!> \param globenv the global environment to initialize
!> \author fawzi
!> \note
!>      if possible do the initializations here as the environment
!>      (error,...) is setup, instead of cp2k_init
! **************************************************************************************************
   SUBROUTINE cp2k_setup(root_section, para_env, globenv)
 
      TYPE(section_vals_type), POINTER                   :: root_section
      TYPE(mp_para_env_type), POINTER                    :: para_env
      TYPE(global_environment_type), POINTER             :: globenv
 
      INTEGER                                            :: iw, maxl
      INTEGER, DIMENSION(:), POINTER                     :: seed_vals
      REAL(kind=dp), DIMENSION(3, 2)                     :: initial_seed
      TYPE(cp_logger_type), POINTER                      :: logger
 
      NULLIFY (logger)
      logger => cp_get_default_logger()
 
      ! Initialize the parallel random number generator
 
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PRINT/RNG_MATRICES", &
                                extension=".Log")
      IF (iw > 0) THEN
         CALL write_rng_matrices(iw)
      END IF
 
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%PRINT/RNG_MATRICES")
 
      ! Initialize a global normally Gaussian distributed (pseudo)random number stream
 
      CALL section_vals_val_get(root_section, "GLOBAL%SEED", i_vals=seed_vals)
      IF (SIZE(seed_vals) == 1) THEN
         initial_seed(:, :) = real(seed_vals(1), kind=dp)
      ELSE IF (SIZE(seed_vals) == 6) THEN
         initial_seed(1:3, 1:2) = reshape(real(seed_vals(:), kind=dp), [3, 2])
      ELSE
         cpabort("Supply exactly 1 or 6 arguments for SEED in &GLOBAL only!")
      END IF
 
      globenv%gaussian_rng_stream = rng_stream_type( &
                                    name="Global Gaussian random numbers", &
                                    distribution_type=gaussian, &
                                    seed=initial_seed, &
                                    extended_precision=.true.)
 
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PRINT/RNG_CHECK", &
                                extension=".Log")
      IF (iw > 0) THEN
         CALL check_rng(iw, para_env%is_source())
      END IF
 
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%PRINT/RNG_CHECK")
 
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PRINT/GLOBAL_GAUSSIAN_RNG", &
                                extension=".Log")
      IF (iw > 0) THEN
         CALL globenv%gaussian_rng_stream%write(iw, write_all=.true.)
      END IF
 
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%PRINT/GLOBAL_GAUSSIAN_RNG")
 
      CALL section_vals_val_get(root_section, "GLOBAL%PRINT%SPHERICAL_HARMONICS", i_val=maxl)
      IF (maxl >= 0) THEN
         iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PRINT", &
                                   extension=".Log")
         CALL init_orbital_pointers(maxl)
         CALL init_spherical_harmonics(maxl, iw)
         CALL deallocate_spherical_harmonics()
         CALL deallocate_orbital_pointers()
         CALL cp_print_key_finished_output(iw, logger, root_section, &
                                           "GLOBAL%PRINT")
      END IF
 
   END SUBROUTINE cp2k_setup
 
! **************************************************************************************************
!> \brief read the global section of new input
!> \param root_section ...
!> \param para_env ...
!> \param globenv ...
!> \par History
!>      06-2005 [created]
!> \author MI
!> \note
!>      Should not be required anymore once everything is converted
!>      to get information directly from the input structure
! **************************************************************************************************
   SUBROUTINE read_global_section(root_section, para_env, globenv)
 
      TYPE(section_vals_type), POINTER                   :: root_section
      TYPE(mp_para_env_type), POINTER                    :: para_env
      TYPE(global_environment_type), POINTER             :: globenv
 
      CHARACTER(LEN=6), PARAMETER                        :: start_section_label = "GLOBAL"
 
      CHARACTER(LEN=13)                                  :: omp_stacksize, tracing_string
      CHARACTER(LEN=6)                                   :: print_level_string
      CHARACTER(LEN=default_path_length)                 :: basis_set_file_name, coord_file_name, &
                                                            mm_potential_file_name, &
                                                            potential_file_name
      CHARACTER(LEN=default_string_length)               :: env_num, model_name, project_name
      CHARACTER(LEN=default_string_length), &
         DIMENSION(:), POINTER                           :: trace_routines
      INTEGER :: cpuid, cpuid_static, i_cholesky, i_dgemm, i_diag, i_fft, i_grid_backend, &
         iforce_eval, method_name_id, n_rep_val, nforce_eval, node_count, num_threads, &
         output_unit, print_level, trace_max, unit_nr
      INTEGER(kind=int_8) :: buffers, buffers_avr, buffers_max, buffers_min, cached, cached_avr, &
         cached_max, cached_min, memfree, memfree_avr, memfree_max, memfree_min, memlikelyfree, &
         memlikelyfree_avr, memlikelyfree_max, memlikelyfree_min, memtotal, memtotal_avr, &
         memtotal_max, memtotal_min, slab, slab_avr, slab_max, slab_min, sreclaimable, &
         sreclaimable_avr, sreclaimable_max, sreclaimable_min
      INTEGER, DIMENSION(:), POINTER                     :: i_force_eval
      LOGICAL                                            :: ata, do_echo_all_hosts, explicit, flag, &
                                                            report_maxloc, trace, trace_master
      TYPE(cp_logger_type), POINTER                      :: logger
      TYPE(enumeration_type), POINTER                    :: enum1, enum2
      TYPE(keyword_type), POINTER                        :: keyword
      TYPE(section_type), POINTER                        :: section
      TYPE(section_vals_type), POINTER                   :: dft_section, force_env_sections, &
                                                            global_section, qmmm_section, &
                                                            subsys_section
 
      NULLIFY (dft_section, global_section, i_force_eval)
 
      logger => cp_get_default_logger()
      global_section => section_vals_get_subs_vals(root_section, "GLOBAL")
      CALL section_vals_val_get(global_section, "BLACS_GRID", i_val=globenv%blacs_grid_layout)
      CALL section_vals_val_get(global_section, "BLACS_REPEATABLE", l_val=globenv%blacs_repeatable)
      CALL section_vals_val_get(global_section, "PREFERRED_DIAG_LIBRARY", i_val=i_diag)
      CALL section_vals_val_get(global_section, "DIRECT_GENERALIZED_DIAGONALIZATION", &
                                l_val=globenv%direct_generalized_diagonalization)
      CALL section_vals_val_get(global_section, "PREFERRED_CHOLESKY_LIBRARY", i_val=i_cholesky)
      CALL section_vals_val_get(global_section, "PREFERRED_DGEMM_LIBRARY", i_val=i_dgemm)
      CALL section_vals_val_get(global_section, "EPS_CHECK_DIAG", r_val=globenv%eps_check_diag)
      CALL section_vals_val_get(global_section, "ENABLE_MPI_IO", l_val=flag)
      CALL cp_mpi_io_set(flag)
      CALL section_vals_val_get(global_section, "ELPA_KERNEL", i_val=globenv%k_elpa)
      CALL section_vals_val_get(global_section, "ELPA_COMPLEX_KERNEL", i_val=globenv%k_elpa_c)
      CALL section_vals_val_get(global_section, "ELPA_NEIGVEC_MIN", i_val=globenv%elpa_neigvec_min)
      CALL section_vals_val_get(global_section, "ELPA_QR", l_val=globenv%elpa_qr)
      CALL section_vals_val_get(global_section, "ELPA_ONE_STAGE", l_val=globenv%elpa_one_stage)
      CALL section_vals_val_get(global_section, "ELPA_PRINT", l_val=globenv%elpa_print)
      CALL section_vals_val_get(global_section, "DLAF_NEIGVEC_MIN", i_val=globenv%dlaf_neigvec_min)
      CALL section_vals_val_get(global_section, "DLAF_CHOLESKY_N_MIN", i_val=globenv%dlaf_cholesky_n_min)
      CALL section_vals_val_get(global_section, "PREFERRED_FFT_LIBRARY", i_val=i_fft)
      CALL section_vals_val_get(global_section, "PRINT_LEVEL", i_val=print_level)
      CALL section_vals_val_get(global_section, "PROGRAM_NAME", i_val=globenv%prog_name_id)
      CALL section_vals_val_get(global_section, "FFT_POOL_SCRATCH_LIMIT", i_val=globenv%fft_pool_scratch_limit)
      CALL section_vals_val_get(global_section, "FFTW_PLAN_TYPE", i_val=globenv%fftw_plan_type)
      CALL section_vals_val_get(global_section, "PROJECT_NAME", c_val=project_name)
      CALL section_vals_val_get(global_section, "FFTW_WISDOM_FILE_NAME", c_val=globenv%fftw_wisdom_file_name)
      CALL section_vals_val_get(global_section, "RUN_TYPE", i_val=globenv%run_type_id)
      CALL cp2k_get_walltime(section=global_section, keyword_name="WALLTIME", &
                             walltime=globenv%cp2k_target_time)
      CALL section_vals_val_get(global_section, "TRACE", l_val=trace)
      CALL section_vals_val_get(global_section, "TRACE_MASTER", l_val=trace_master)
      CALL section_vals_val_get(global_section, "TRACE_MAX", i_val=trace_max)
      CALL section_vals_val_get(global_section, "TRACE_ROUTINES", explicit=explicit)
      IF (explicit) THEN
         CALL section_vals_val_get(global_section, "TRACE_ROUTINES", c_vals=trace_routines)
      ELSE
         NULLIFY (trace_routines)
      END IF
      CALL section_vals_val_get(global_section, "FLUSH_SHOULD_FLUSH", l_val=flush_should_flush)
      CALL section_vals_val_get(global_section, "ECHO_ALL_HOSTS", l_val=do_echo_all_hosts)
      report_maxloc = section_get_lval(global_section, "TIMINGS%REPORT_MAXLOC")
      global_timings_level = section_get_ival(global_section, "TIMINGS%TIMINGS_LEVEL")
      do_echo_all_hosts = do_echo_all_hosts .OR. report_maxloc
      force_env_sections => section_vals_get_subs_vals(root_section, "FORCE_EVAL")
      CALL section_vals_get(force_env_sections, n_repetition=nforce_eval)
      output_unit = cp_print_key_unit_nr(logger, global_section, "PROGRAM_RUN_INFO", &
                                         extension=".log")
 
      CALL fm_setup(global_section)
      CALL fm_diag_rules_setup(global_section)
      CALL dgemm_setup(global_section)
 
      IF (trace .AND. (.NOT. trace_master .OR. para_env%mepos == 0)) THEN
         unit_nr = -1
         IF (logger%para_env%is_source() .OR. .NOT. trace_master) THEN
            unit_nr = cp_logger_get_default_unit_nr(logger, local=.true.)
         END IF
         WRITE (tracing_string, "(I6.6,A1,I6.6)") para_env%mepos, ":", para_env%num_pe
         IF (ASSOCIATED(trace_routines)) THEN
            CALL timings_setup_tracing(trace_max, unit_nr, tracing_string, trace_routines)
         ELSE
            CALL timings_setup_tracing(trace_max, unit_nr, tracing_string)
         END IF
      END IF
 
      CALL section_vals_val_get(global_section, "TIMINGS%TIME_MPI", l_val=mp_collect_timings)
 
      SELECT CASE (i_diag)
      CASE (fm_diag_type_scalapack)
         globenv%diag_library = "ScaLAPACK"
      CASE (fm_diag_type_elpa)
         globenv%diag_library = "ELPA"
         CALL cite_reference(marek2014)
      CASE (fm_diag_type_cusolver)
         globenv%diag_library = "cuSOLVER"
      CASE (fm_diag_type_dlaf)
         globenv%diag_library = "DLAF"
         CALL cite_reference(solca2024)
      CASE DEFAULT
         cpabort("Unknown diagonalization library specified")
      END SELECT
 
      SELECT CASE (i_cholesky)
      CASE (fm_cholesky_type_scalapack)
         globenv%cholesky_library = "ScaLAPACK"
         cholesky_type = fm_cholesky_type_scalapack
      CASE (fm_cholesky_type_dlaf)
         globenv%cholesky_library = "DLAF"
         cholesky_type = fm_cholesky_type_dlaf
         dlaf_cholesky_n_min = globenv%dlaf_cholesky_n_min
         CALL cite_reference(solca2024)
      CASE DEFAULT
         cpabort("Unknown Cholesky decomposition library specified")
      END SELECT
 
      SELECT CASE (i_fft)
      CASE (do_fft_sg)
         globenv%default_fft_library = "FFTSG"
      CASE (do_fft_fftw3)
         globenv%default_fft_library = "FFTW3"
         CALL cite_reference(frigo2005)
      CASE DEFAULT
         cpabort("Unknown FFT library specified")
      END SELECT
 
      SELECT CASE (i_dgemm)
      CASE (do_dgemm_spla)
         globenv%default_dgemm_library = "SPLA"
      CASE (do_dgemm_blas)
         globenv%default_dgemm_library = "BLAS"
      CASE DEFAULT
         cpabort("Unknown DGEMM library specified")
      END SELECT
 
      IF (globenv%run_type_id == 0) THEN
         SELECT CASE (globenv%prog_name_id)
         CASE (do_farming, do_test)
            globenv%run_type_id = none_run
         CASE (do_cp2k)
            IF (nforce_eval /= 1) THEN
               ! multiple force_eval corresponds at the moment to RESPA calculations only
               ! default MD
               globenv%run_type_id = mol_dyn_run
            ELSE
               CALL section_vals_val_get(force_env_sections, "METHOD", i_val=method_name_id)
               SELECT CASE (method_name_id)
               CASE (do_fist)
                  globenv%run_type_id = mol_dyn_run
               CASE (do_eip)
                  globenv%run_type_id = mol_dyn_run
               CASE (do_qs)
                  globenv%run_type_id = energy_run
               CASE (do_sirius)
                  globenv%run_type_id = energy_run
               END SELECT
            END IF
         END SELECT
      END IF
 
      IF (globenv%prog_name_id == do_farming .AND. globenv%run_type_id /= none_run) THEN
         cpabort("FARMING program supports only NONE as run type")
      END IF
 
      IF (globenv%prog_name_id == do_test .AND. globenv%run_type_id /= none_run) THEN
         cpabort("TEST program supports only NONE as run type")
      END IF
 
      CALL m_memory_details(memtotal, memfree, buffers, cached, slab, sreclaimable, memlikelyfree)
      memtotal_avr = memtotal
      memfree_avr = memfree
      buffers_avr = buffers
      cached_avr = cached
      slab_avr = slab
      sreclaimable_avr = sreclaimable
      memlikelyfree_avr = memlikelyfree
      CALL para_env%sum(memtotal_avr); memtotal_avr = memtotal_avr/para_env%num_pe/1024
      CALL para_env%sum(memfree_avr); memfree_avr = memfree_avr/para_env%num_pe/1024
      CALL para_env%sum(buffers_avr); buffers_avr = buffers_avr/para_env%num_pe/1024
      CALL para_env%sum(cached_avr); cached_avr = cached_avr/para_env%num_pe/1024
      CALL para_env%sum(slab_avr); slab_avr = slab_avr/para_env%num_pe/1024
      CALL para_env%sum(sreclaimable_avr); sreclaimable_avr = sreclaimable_avr/para_env%num_pe/1024
      CALL para_env%sum(memlikelyfree_avr); memlikelyfree_avr = memlikelyfree_avr/para_env%num_pe/1024
 
      memtotal_min = -memtotal
      memfree_min = -memfree
      buffers_min = -buffers
      cached_min = -cached
      slab_min = -slab
      sreclaimable_min = -sreclaimable
      memlikelyfree_min = -memlikelyfree
      CALL para_env%max(memtotal_min); memtotal_min = -memtotal_min/1024
      CALL para_env%max(memfree_min); memfree_min = -memfree_min/1024
      CALL para_env%max(buffers_min); buffers_min = -buffers_min/1024
      CALL para_env%max(cached_min); cached_min = -cached_min/1024
      CALL para_env%max(slab_min); slab_min = -slab_min/1024
      CALL para_env%max(sreclaimable_min); sreclaimable_min = -sreclaimable_min/1024
      CALL para_env%max(memlikelyfree_min); memlikelyfree_min = -memlikelyfree_min/1024
 
      memtotal_max = memtotal
      memfree_max = memfree
      buffers_max = buffers
      cached_max = cached
      slab_max = slab
      sreclaimable_max = sreclaimable
      memlikelyfree_max = memlikelyfree
      CALL para_env%max(memtotal_max); memtotal_max = memtotal_max/1024
      CALL para_env%max(memfree_max); memfree_max = memfree_max/1024
      CALL para_env%max(buffers_max); buffers_max = buffers_max/1024
      CALL para_env%max(cached_max); cached_max = cached_max/1024
      CALL para_env%max(slab_max); slab_max = slab_max/1024
      CALL para_env%max(sreclaimable_max); sreclaimable_max = sreclaimable_max/1024
      CALL para_env%max(memlikelyfree_max); memlikelyfree_max = memlikelyfree_max/1024
 
      memtotal = memtotal/1024
      memfree = memfree/1024
      buffers = buffers/1024
      cached = cached/1024
      slab = slab/1024
      sreclaimable = sreclaimable/1024
      memlikelyfree = memlikelyfree/1024
 
      node_count = 1
      ! Print a list of all started processes
      IF (do_echo_all_hosts) THEN
         CALL echo_all_hosts(para_env, output_unit)
 
         ! Print the number of processes per host
         CALL echo_all_process_host(para_env, output_unit, node_count)
      ELSE ! no echo
         CALL echo_all_process_host(para_env, 0, node_count)
      END IF
 
      num_threads = 1
!$    num_threads = omp_get_max_threads()
      IF (output_unit > 0) THEN
         WRITE (unit=output_unit, fmt=*)
         CALL multiple_fe_list(force_env_sections, root_section, i_force_eval, nforce_eval)
         DO iforce_eval = 1, nforce_eval
            dft_section => section_vals_get_subs_vals3(force_env_sections, "DFT", &
                                                       i_rep_section=i_force_eval(iforce_eval))
            qmmm_section => section_vals_get_subs_vals3(force_env_sections, "QMMM", &
                                                        i_rep_section=i_force_eval(iforce_eval))
            CALL section_vals_val_get(dft_section, "BASIS_SET_FILE_NAME", &
                                      c_val=basis_set_file_name)
            CALL section_vals_val_get(dft_section, "POTENTIAL_FILE_NAME", &
                                      c_val=potential_file_name)
 
            CALL section_vals_val_get(qmmm_section, "MM_POTENTIAL_FILE_NAME", &
                                      c_val=mm_potential_file_name)
            ! SUBSYS - If any
            subsys_section => section_vals_get_subs_vals3(force_env_sections, "SUBSYS", &
                                                          i_rep_section=i_force_eval(iforce_eval))
            CALL section_vals_get(subsys_section, explicit=explicit)
            coord_file_name = "__STD_INPUT__"
            IF (explicit) THEN
               CALL section_vals_val_get(subsys_section, "TOPOLOGY%COORD_FILE_NAME", &
                                         n_rep_val=n_rep_val)
               IF (n_rep_val == 1) THEN
                  CALL section_vals_val_get(subsys_section, "TOPOLOGY%COORD_FILE_NAME", &
                                            c_val=coord_file_name)
               END IF
            END IF
            CALL integer_to_string(i_force_eval(iforce_eval), env_num)
 
            WRITE (unit=output_unit, fmt="(T2,A,T41,A)") &
               start_section_label//"| Force Environment number", &
               adjustr(env_num(:40)), &
               start_section_label//"| Basis set file name", &
               adjustr(basis_set_file_name(:40)), &
               start_section_label//"| Potential file name", &
               adjustr(potential_file_name(:40)), &
               start_section_label//"| MM Potential file name", &
               adjustr(mm_potential_file_name(:40)), &
               start_section_label//"| Coordinate file name", &
               adjustr(coord_file_name(:40))
         END DO
         DEALLOCATE (i_force_eval)
 
         NULLIFY (enum1, enum2, keyword, section)
         CALL create_global_section(section)
         keyword => section_get_keyword(section, "PROGRAM_NAME")
         CALL keyword_get(keyword, enum=enum1)
         keyword => section_get_keyword(section, "RUN_TYPE")
         CALL keyword_get(keyword, enum=enum2)
 
         WRITE (unit=output_unit, fmt="(T2,A,T41,A40)") &
            start_section_label//"| Method name", &
            adjustr(trim(enum_i2c(enum1, globenv%prog_name_id))), &
            start_section_label//"| Project name", &
            adjustr(project_name(:40)), &
            start_section_label//"| Run type", &
            adjustr(trim(enum_i2c(enum2, globenv%run_type_id))), &
            start_section_label//"| FFT library", &
            adjustr(globenv%default_fft_library(:40)), &
            start_section_label//"| Diagonalization library", &
            adjustr(globenv%diag_library(:40)), &
            start_section_label//"| Cholesky decomposition library", &
            adjustr(globenv%cholesky_library(:40)), &
            start_section_label//"| DGEMM library", &
            adjustr(globenv%default_dgemm_library(:40))
 
         IF (globenv%diag_library == "ELPA") THEN
            WRITE (unit=output_unit, fmt="(T2,A,T71,I10)") &
               start_section_label//"| Minimum number of eigenvectors for ELPA usage", &
               globenv%elpa_neigvec_min
         END IF
 
         IF (globenv%diag_library == "DLAF") THEN
            WRITE (unit=output_unit, fmt="(T2,A,T71,I10)") &
               start_section_label//"| Minimum number of eigenvectors for DLAF usage", &
               globenv%dlaf_neigvec_min
         END IF
 
         IF (globenv%diag_library == "cuSOLVER" .OR. globenv%diag_library == "ScaLAPACK" .OR. &
             globenv%diag_library == "DLAF") THEN
            WRITE (unit=output_unit, fmt="(T2,A,T71,L10)") &
               start_section_label//"| Direct generalized diagonalization requested", &
               globenv%direct_generalized_diagonalization
         END IF
 
         IF (globenv%diag_library == "cuSOLVER") THEN
            WRITE (unit=output_unit, fmt="(T2,A,T71,I10)") &
               start_section_label//"| Minimum matrix size for cuSOLVER diagonalization", &
               cusolver_n_min
         END IF
 
         IF (globenv%cholesky_library == "DLAF") THEN
            WRITE (unit=output_unit, fmt="(T2,A,T71,I10)") &
               start_section_label//"| Minimum matrix size for Cholesky decomposition with DLAF", &
               globenv%dlaf_cholesky_n_min
         END IF
 
#if defined(__CHECK_DIAG)
         ! Perform default check if no threshold value has been specified explicitly
         IF (globenv%eps_check_diag < 0.0_dp) THEN
            WRITE (unit=output_unit, fmt="(T2,A,T71,ES10.3)") &
               start_section_label//"| Orthonormality check for eigenvectors enabled", &
               eps_check_diag_default
         ELSE
            WRITE (unit=output_unit, fmt="(T2,A,T71,ES10.3)") &
               start_section_label//"| Orthonormality check for eigenvectors enabled", &
               globenv%eps_check_diag
         END IF
#else
         IF (globenv%eps_check_diag < 0.0_dp) THEN
            WRITE (unit=output_unit, fmt="(T2,A,T73,A)") &
               start_section_label//"| Orthonormality check for eigenvectors", &
               "DISABLED"
         ELSE
            WRITE (unit=output_unit, fmt="(T2,A,T71,ES10.3)") &
               start_section_label//"| Orthonormality check for eigenvectors enabled", &
               globenv%eps_check_diag
         END IF
#endif
         CALL section_release(section)
 
         SELECT CASE (cp_fm_get_mm_type())
         CASE (do_scalapack)
            WRITE (unit=output_unit, fmt="(T2,A,T72,A)") &
               start_section_label//"| Matrix multiplication library", "ScaLAPACK"
         CASE (do_cosma)
            WRITE (unit=output_unit, fmt="(T2,A,T76,A)") &
               start_section_label//"| Matrix multiplication library", "COSMA"
         END SELECT
 
         CALL section_vals_val_get(global_section, "ALLTOALL_SGL", l_val=ata)
         WRITE (unit=output_unit, fmt="(T2,A,T80,L1)") &
            start_section_label//"| All-to-all communication in single precision", ata
 
         SELECT CASE (print_level)
         CASE (silent_print_level)
            print_level_string = "SILENT"
         CASE (low_print_level)
            print_level_string = "   LOW"
         CASE (medium_print_level)
            print_level_string = "MEDIUM"
         CASE (high_print_level)
            print_level_string = "  HIGH"
         CASE (debug_print_level)
            print_level_string = " DEBUG"
         CASE DEFAULT
            cpabort("Unknown print_level")
         END SELECT
 
         CALL section_vals_val_get(global_section, "GRID%BACKEND", i_val=i_grid_backend)
         SELECT CASE (i_grid_backend)
         CASE (grid_backend_auto)
            WRITE (unit=output_unit, fmt="(T2,A,T75,A6)") &
               start_section_label//"| Grid backend", "AUTO"
         CASE (grid_backend_cpu)
            WRITE (unit=output_unit, fmt="(T2,A,T75,A6)") &
               start_section_label//"| Grid backend", "CPU"
         CASE (grid_backend_dgemm)
            WRITE (unit=output_unit, fmt="(T2,A,T75,A6)") &
               start_section_label//"| Grid backend", "DGEMM"
         CASE (grid_backend_gpu)
            WRITE (unit=output_unit, fmt="(T2,A,T75,A6)") &
               start_section_label//"| Grid backend", "GPU"
         CASE (grid_backend_ref)
            WRITE (unit=output_unit, fmt="(T2,A,T75,A6)") &
               start_section_label//"| Grid backend", "REF"
         END SELECT
 
         WRITE (unit=output_unit, fmt="(T2,A,T75,A6)") &
            start_section_label//"| Global print level", print_level_string
         WRITE (unit=output_unit, fmt="(T2,A,T75,L6)") &
            start_section_label//"| MPI I/O enabled", flag
         WRITE (unit=output_unit, fmt="(T2,A,T75,I6)") &
            start_section_label//"| Total number of message passing processes", &
            para_env%num_pe, &
            start_section_label//"| Number of distributed systems (nodes)", &
            node_count, &
            start_section_label//"| Number of threads for this process", &
            num_threads, &
            start_section_label//"| This output is from process", para_env%mepos
 
         CALL m_omp_get_stacksize(omp_stacksize)
         WRITE (unit=output_unit, fmt="(T2,A,T68,A13)") &
            start_section_label//"| OpenMP stack size per thread (OMP_STACKSIZE)", &
            adjustr(omp_stacksize)
 
         IF (0 <= m_omp_trace_issues()) THEN ! only show in header if enabled
            WRITE (unit=output_unit, fmt="(T2,A,T68,A13)") &
               start_section_label//"| OpenMP issue trace (CP2K_OMP_TRACE)", &
               "enabled"
         END IF
 
         CALL m_cpuinfo(model_name)
         WRITE (unit=output_unit, fmt="(T2,A,T30,A51)") &
            start_section_label//"| CPU model name", adjustr(trim(model_name))
 
         cpuid = m_cpuid()
         cpuid_static = m_cpuid_static()
 
         IF ((cpuid > 0) .OR. (cpuid_static > 0)) THEN
            WRITE (unit=output_unit, fmt="(T2,A,T75,I6)") &
               start_section_label//"| CPUID", cpuid
            IF (cpuid /= cpuid_static) THEN
               WRITE (unit=output_unit, fmt="(T2,A,T75,I6)") &
                  start_section_label//"| Compiled for CPUID", cpuid_static
            END IF
         END IF
 
         ! filter cpuids by vlen to show more relevant information
         IF (m_cpuid_vlen(cpuid_static) < m_cpuid_vlen(cpuid)) THEN
            ! base/machine_cpuid.c relies on the (same) target flags as the Fortran code
            CALL cp_hint(__location__, "The compiler target ("// &
                         trim(m_cpuid_name(cpuid_static))//") used to build this binary does not "// &
                         "enable all instruction-set extensions available on this CPU ("// &
                         trim(m_cpuid_name(cpuid))//"). Consider reconfiguring and rebuilding CP2K "// &
                         "for this target system to enable them.")
         END IF
 
         WRITE (unit=output_unit, fmt="()")
         WRITE (unit=output_unit, fmt="(T2,A)") "MEMORY| system memory details [Kb]"
         WRITE (unit=output_unit, fmt="(T2,A23,4A14)") "MEMORY|                ", "rank 0", "min", "max", "average"
         WRITE (unit=output_unit, fmt="(T2,A23,4I14)") "MEMORY| MemTotal       ", memtotal, memtotal_min, memtotal_max, memtotal_avr
         WRITE (unit=output_unit, fmt="(T2,A23,4I14)") "MEMORY| MemFree        ", memfree, memfree_min, memfree_max, memfree_avr
         WRITE (unit=output_unit, fmt="(T2,A23,4I14)") "MEMORY| Buffers        ", buffers, buffers_min, buffers_max, buffers_avr
         WRITE (unit=output_unit, fmt="(T2,A23,4I14)") "MEMORY| Cached         ", cached, cached_min, cached_max, cached_avr
         WRITE (unit=output_unit, fmt="(T2,A23,4I14)") "MEMORY| Slab           ", slab, slab_min, slab_max, slab_avr
         WRITE (unit=output_unit, fmt="(T2,A23,4I14)") &
            "MEMORY| SReclaimable   ", sreclaimable, sreclaimable_min, sreclaimable_max, &
            sreclaimable_avr
         WRITE (unit=output_unit, fmt="(T2,A23,4I14)") &
            "MEMORY| MemLikelyFree  ", memlikelyfree, memlikelyfree_min, memlikelyfree_max, &
            memlikelyfree_avr
         WRITE (unit=output_unit, fmt='()')
 
      END IF
 
      CALL cp_print_key_finished_output(output_unit, logger, global_section, &
                                        "PROGRAM_RUN_INFO")
 
   END SUBROUTINE read_global_section
 
! **************************************************************************************************
!> \brief ...
!> \param root_section ...
!> \param para_env ...
!> \param globenv ...
!> \par History
!>      2-Dec-2000 (JGH) added default fft library
!> \author JGH,MK
! **************************************************************************************************
   SUBROUTINE read_cp2k_section(root_section, para_env, globenv)
 
      TYPE(section_vals_type), POINTER                   :: root_section
      TYPE(mp_para_env_type), POINTER                    :: para_env
      TYPE(global_environment_type), POINTER             :: globenv
 
      INTEGER                                            :: output_unit
      TYPE(cp_logger_type), POINTER                      :: logger
      TYPE(section_vals_type), POINTER                   :: global_section
 
      global_section => section_vals_get_subs_vals(root_section, "GLOBAL")
      CALL read_global_section(root_section, para_env, globenv)
      logger => cp_get_default_logger()
      output_unit = cp_print_key_unit_nr(logger, global_section, "PROGRAM_RUN_INFO", &
                                         extension=".log")
 
      CALL integral_setup_library(global_section)
      CALL fft_setup_library(globenv, global_section)
      CALL diag_setup_library(globenv, global_section)
 
      ! Run a one-time correctness check of the ELPA complex kernels if they may be used.
      IF (diag_type == fm_diag_type_elpa .AND. diag_lib_explicit) THEN
         CALL check_elpa_c_kernel_correctness(para_env)
      END IF
 
      CALL cp_print_key_finished_output(output_unit, logger, global_section, &
                                        "PROGRAM_RUN_INFO")
 
   END SUBROUTINE read_cp2k_section
 
! **************************************************************************************************
!> \brief Resolve preferred integral libraries against the compiled-in backends.
!> \param global_section ...
! **************************************************************************************************
   SUBROUTINE integral_setup_library(global_section)
      TYPE(section_vals_type), POINTER                   :: global_section
 
      CHARACTER(LEN=3*default_string_length)             :: message
      INTEGER                                            :: coulomb2_library, coulomb3_library
      LOGICAL                                            :: fallback_applied
 
      CALL section_vals_val_get(global_section, "PREFERRED_INTEGRAL_LIBRARY%COULOMB_2C", &
                                i_val=coulomb2_library)
      CALL section_vals_val_get(global_section, "PREFERRED_INTEGRAL_LIBRARY%COULOMB_3C", &
                                i_val=coulomb3_library)
      CALL integral_library_init(coulomb2_library, coulomb3_library, fallback_applied)
 
      IF (fallback_applied) THEN
         message = "Integral library Libint is not available. "// &
                   "The native integral library is used as fallback."
         cpwarn(trim(message))
      END IF
 
   END SUBROUTINE integral_setup_library
 
! **************************************************************************************************
!> \brief check FFT preferred library availability, if not switch
!> \param globenv ...
!> \param global_section ...
!> \par History
!>      2-Dec-2000 (JGH) added default fft library
!>      Nov-2013 (MI) refactoring
!> \author JGH,MK
! **************************************************************************************************
   SUBROUTINE fft_setup_library(globenv, global_section)
 
      TYPE(global_environment_type), POINTER             :: globenv
      TYPE(section_vals_type), POINTER                   :: global_section
 
      CHARACTER(LEN=3*default_string_length)             :: message
      COMPLEX(KIND=dp), DIMENSION(4, 4, 4)               :: zz
      INTEGER                                            :: stat
      INTEGER, DIMENSION(3)                              :: n
      LOGICAL                                            :: try_fftw
 
      n(:) = 4
      zz(:, :, :) = 0.0_dp
 
      ! Setup the FFT library
      ! If the user has specified PREFERRED_FFT_LIBRARY try that first (default FFTW3)
      ! If that one is not available, try FFTW3 (unless it has been tried already)
      ! If FFTW3 is not available use FFTSG
 
      IF (globenv%default_fft_library == "FFTW3") THEN
         try_fftw = .false.
      ELSE
         try_fftw = .true.
      END IF
 
      ! Initialize FFT library with the user's preferred FFT library
      CALL init_fft(fftlib=trim(globenv%default_fft_library), &
                    alltoall=section_get_lval(global_section, "ALLTOALL_SGL"), &
                    pool_limit=globenv%fft_pool_scratch_limit, &
                    wisdom_file=globenv%fftw_wisdom_file_name, &
                    plan_style=globenv%fftw_plan_type)
 
      ! Check for FFT library
      CALL fft3d(fwfft, n, zz, status=stat)
      IF (stat /= 0) THEN
         IF (try_fftw) THEN
            message = "FFT library "//trim(globenv%default_fft_library)// &
                      " is not available. Trying FFT library FFTW3."
            cpwarn(trim(message))
            globenv%default_fft_library = "FFTW3"
            CALL init_fft(fftlib=trim(globenv%default_fft_library), &
                          alltoall=section_get_lval(global_section, "ALLTOALL_SGL"), &
                          pool_limit=globenv%fft_pool_scratch_limit, &
                          wisdom_file=globenv%fftw_wisdom_file_name, &
                          plan_style=globenv%fftw_plan_type)
 
            CALL fft3d(fwfft, n, zz, status=stat)
         END IF
         IF (stat /= 0) THEN
            message = "FFT library "//trim(globenv%default_fft_library)// &
                      " is not available. Trying FFT library FFTSG."
            cpwarn(trim(message))
            globenv%default_fft_library = "FFTSG"
            CALL init_fft(fftlib=trim(globenv%default_fft_library), &
                          alltoall=section_get_lval(global_section, "ALLTOALL_SGL"), &
                          pool_limit=globenv%fft_pool_scratch_limit, &
                          wisdom_file=globenv%fftw_wisdom_file_name, &
                          plan_style=globenv%fftw_plan_type)
 
            CALL fft3d(fwfft, n, zz, status=stat)
            IF (stat /= 0) THEN
               cpabort("FFT library FFTSG does not work. No FFT library available.")
            END IF
         END IF
      END IF
 
   END SUBROUTINE fft_setup_library
 
! **************************************************************************************************
!> \brief availability diagonalizatioon library
!>
!> \param globenv ...
!> \param global_section ...
!> \author MI
! **************************************************************************************************
   SUBROUTINE diag_setup_library(globenv, global_section)
      TYPE(global_environment_type), POINTER             :: globenv
      TYPE(section_vals_type), POINTER                   :: global_section
 
      CHARACTER(LEN=3*default_string_length)             :: message
      LOGICAL                                            :: diag_lib_explicit, fallback_applied
 
      CALL section_vals_val_get(global_section, "PREFERRED_DIAG_LIBRARY", explicit=diag_lib_explicit)
 
      CALL diag_init(diag_lib=trim(globenv%diag_library), &
                     fallback_applied=fallback_applied, &
                     diag_lib_explicit_input=diag_lib_explicit, &
                     elpa_kernel=globenv%k_elpa, &
                     elpa_c_kernel=globenv%k_elpa_c, &
                     elpa_neigvec_min_input=globenv%elpa_neigvec_min, &
                     elpa_qr=globenv%elpa_qr, &
                     elpa_print=globenv%elpa_print, &
                     elpa_one_stage=globenv%elpa_one_stage, &
                     dlaf_neigvec_min_input=globenv%dlaf_neigvec_min, &
                     eps_check_diag_input=globenv%eps_check_diag, &
                     direct_generalized_diagonalization_input= &
                     globenv%direct_generalized_diagonalization)
 
      IF (fallback_applied) THEN
         message = "Diagonalization library "//trim(globenv%diag_library)// &
                   " is not available. The ScaLAPACK library is used as fallback."
         cpwarn(trim(message))
      END IF
 
   END SUBROUTINE diag_setup_library
 
! **************************************************************************************************
!> \brief ...
!> \param glob_section ...
! **************************************************************************************************
   SUBROUTINE fm_setup(glob_section)
      TYPE(section_vals_type), POINTER                   :: glob_section
 
      INTEGER                                            :: mm_type, ncb, nrb
      LOGICAL                                            :: force_me
      TYPE(section_vals_type), POINTER                   :: fm_section
 
      fm_section => section_vals_get_subs_vals(glob_section, "FM")
 
      CALL section_vals_val_get(fm_section, "NROW_BLOCKS", i_val=nrb)
      CALL section_vals_val_get(fm_section, "NCOL_BLOCKS", i_val=ncb)
      CALL section_vals_val_get(fm_section, "FORCE_BLOCK_SIZE", l_val=force_me)
      CALL cp_fm_struct_config(nrow_block=nrb, ncol_block=ncb, force_block=force_me)
 
      CALL section_vals_val_get(fm_section, "TYPE_OF_MATRIX_MULTIPLICATION", i_val=mm_type)
      CALL cp_fm_setup(mm_type)
 
   END SUBROUTINE fm_setup
 
! **************************************************************************************************
!> \brief ...
!> \param glob_section ...
! **************************************************************************************************
   SUBROUTINE dgemm_setup(glob_section)
      TYPE(section_vals_type), POINTER                   :: glob_section
 
      INTEGER                                            :: dgemm_type
 
      CALL section_vals_val_get(glob_section, "PREFERRED_DGEMM_LIBRARY", i_val=dgemm_type)
 
      CALL local_gemm_set_library(dgemm_type)
 
   END SUBROUTINE dgemm_setup
 
! **************************************************************************************************
!> \brief   Parses the input section used to define the heuristic rules which determine if
!>          a FM matrix should be redistributed before diagonalizing it.
!> \param glob_section the global input section
!> \author Nico Holmberg [01.2018]
! **************************************************************************************************
   SUBROUTINE fm_diag_rules_setup(glob_section)
      TYPE(section_vals_type), POINTER                   :: glob_section
 
      INTEGER                                            :: a, x
      LOGICAL                                            :: elpa_force_redistribute, should_print
      TYPE(section_vals_type), POINTER                   :: section
 
      section => section_vals_get_subs_vals(glob_section, "FM_DIAG_SETTINGS")
 
      CALL section_vals_val_get(section, "PARAMETER_A", i_val=a)
      CALL section_vals_val_get(section, "PARAMETER_X", i_val=x)
      CALL section_vals_val_get(section, "PRINT_FM_REDISTRIBUTE", l_val=should_print)
      CALL section_vals_val_get(section, "ELPA_FORCE_REDISTRIBUTE", l_val=elpa_force_redistribute)
 
      CALL cp_fm_redistribute_init(a, x, should_print, elpa_force_redistribute)
 
   END SUBROUTINE fm_diag_rules_setup
! **************************************************************************************************
!> \brief reads the Walltime also in format HH:MM:SS
!> \param section ...
!> \param keyword_name ...
!> \param walltime ...
!> \par History
!>      none
!> \author Mandes
! **************************************************************************************************
   SUBROUTINE cp2k_get_walltime(section, keyword_name, walltime)
      TYPE(section_vals_type), POINTER                   :: section
      CHARACTER(LEN=*), INTENT(in)                       :: keyword_name
      REAL(kind=dp), INTENT(out)                         :: walltime
 
      CHARACTER(LEN=1)                                   :: c1, c2
      CHARACTER(LEN=100)                                 :: txt
      INTEGER                                            :: hours, ierr, minutes, n, seconds
 
      CALL section_vals_val_get(section, keyword_name, c_val=txt)
      n = len_trim(txt)
 
      IF (n == 0) THEN
         walltime = -1.0_dp
      ELSE IF (index(txt, ":") == 0) THEN
         READ (txt(1:n), fmt=*, iostat=ierr) walltime
         IF (ierr /= 0) cpabort('Could not parse WALLTIME: "'//txt(1:n)//'"')
      ELSE
         READ (txt(1:n), fmt="(I2,A1,I2,A1,I2)", iostat=ierr) hours, c1, minutes, c2, seconds
         IF (n /= 8 .OR. ierr /= 0 .OR. c1 /= ":" .OR. c2 /= ":") THEN
            cpabort('Could not parse WALLTIME: "'//txt(1:n)//'"')
         END IF
         walltime = 3600.0_dp*real(hours, dp) + 60.0_dp*real(minutes, dp) + real(seconds, dp)
      END IF
   END SUBROUTINE cp2k_get_walltime
 
! **************************************************************************************************
!> \brief Writes final timings and banner for CP2K
!> \param root_section ...
!> \param para_env ...
!> \param globenv ...
!> \param wdir ...
!> \param q_finalize ...
!> \par History
!>      none
!> \author JGH,MK
!> \note
!>      The following routines need to be synchronized wrt. adding/removing
!>      of the default environments (logging, performance,error):
!>      environment:cp2k_init, environment:cp2k_finalize,
!>      f77_interface:f_env_add_defaults, f77_interface:f_env_rm_defaults,
!>      f77_interface:create_force_env, f77_interface:destroy_force_env
! **************************************************************************************************
   SUBROUTINE cp2k_finalize(root_section, para_env, globenv, wdir, q_finalize)
 
      TYPE(section_vals_type), POINTER                   :: root_section
      TYPE(mp_para_env_type), POINTER                    :: para_env
      TYPE(global_environment_type), POINTER             :: globenv
      CHARACTER(LEN=*), OPTIONAL                         :: wdir
      LOGICAL, INTENT(IN), OPTIONAL                      :: q_finalize
 
      CHARACTER(LEN=default_path_length)                 :: cg_filename
      INTEGER                                            :: cg_mode, iw, unit_exit
      LOGICAL                                            :: delete_it, do_finalize, report_maxloc, &
                                                            sort_by_self_time
      REAL(kind=dp)                                      :: r_timings
      TYPE(cp_logger_type), POINTER                      :: logger
 
      ! Look if we inherited a failure, more care is needed if so
      ! i.e. the input is most likely not available
      ! Set flag if this is a development version
 
      do_finalize = .true.
      IF (PRESENT(q_finalize)) do_finalize = q_finalize
      ! Clean up
      NULLIFY (logger)
      logger => cp_get_default_logger()
      IF (do_finalize) THEN
         CALL deallocate_spherical_harmonics()
         CALL deallocate_orbital_pointers()
         CALL deallocate_md_ftable()
         CALL diag_finalize()
         ! the LibXC functional objects are kept alive across calculations
         CALL libxc_release_workers()
         ! finalize the fft (i.e. writes the wisdom if FFTW3 )
         CALL finalize_fft(para_env, globenv%fftw_wisdom_file_name)
         CALL finalize_libvori()
      END IF
 
      ! Write message passing performance info
 
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PROGRAM_RUN_INFO", &
                                extension=".log")
      CALL describe_mp_perf_env(iw)
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%PROGRAM_RUN_INFO")
 
      CALL collect_citations_from_ranks(para_env)
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%REFERENCES", &
                                extension=".Log")
      IF (iw > 0) THEN
         WRITE (unit=iw, fmt="(/,T2,A)") repeat("-", 79)
         WRITE (unit=iw, fmt="(T2,A,T80,A)") "-", "-"
         WRITE (unit=iw, fmt="(T2,A,T30,A,T80,A)") "-", "R E F E R E N C E S", "-"
         WRITE (unit=iw, fmt="(T2,A,T80,A)") "-", "-"
         WRITE (unit=iw, fmt="(T2,A)") repeat("-", 79)
         WRITE (unit=iw, fmt="(T2,A)") ""
         WRITE (unit=iw, fmt="(T2,A)") trim(cp2k_version)//", the CP2K developers group ("//trim(cp2k_year)//")."
         WRITE (unit=iw, fmt="(T2,A)") "CP2K is freely available from "//trim(cp2k_home)//" ."
         WRITE (unit=iw, fmt="(T2,A)") ""
         CALL print_cited_references(unit=iw)
      END IF
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%REFERENCES")
 
      CALL timestop(globenv%handle) ! corresponding the "CP2K" in cp2k_init
 
      iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%TIMINGS", &
                                extension=".Log")
      r_timings = section_get_rval(root_section, "GLOBAL%TIMINGS%THRESHOLD")
      sort_by_self_time = section_get_lval(root_section, "GLOBAL%TIMINGS%SORT_BY_SELF_TIME")
      report_maxloc = section_get_lval(root_section, "GLOBAL%TIMINGS%REPORT_MAXLOC")
      IF (m_energy() /= 0.0_dp) THEN
         CALL timings_report_print(iw, r_timings, sort_by_self_time, cost_type_energy, report_maxloc, para_env)
      END IF
      CALL timings_report_print(iw, r_timings, sort_by_self_time, cost_type_time, report_maxloc, para_env)
 
      ! Write the callgraph, if desired by user
      CALL section_vals_val_get(root_section, "GLOBAL%CALLGRAPH", i_val=cg_mode)
      IF (cg_mode /= callgraph_none) THEN
         CALL section_vals_val_get(root_section, "GLOBAL%CALLGRAPH_FILE_NAME", c_val=cg_filename)
         IF (len_trim(cg_filename) == 0) cg_filename = trim(logger%iter_info%project_name)
         IF (cg_mode == callgraph_all) THEN
            !incorporate mpi-rank into filename
            cg_filename = trim(cg_filename)//"_"//trim(adjustl(cp_to_string(para_env%mepos)))
         END IF
         IF (iw > 0) THEN
            WRITE (unit=iw, fmt="(T2,3X,A)") "Writing callgraph to: "//trim(cg_filename)//".callgraph"
            WRITE (unit=iw, fmt="()")
            WRITE (unit=iw, fmt="(T2,A)") "-------------------------------------------------------------------------------"
         END IF
         IF (cg_mode == callgraph_all .OR. para_env%is_source()) THEN
            CALL timings_report_callgraph(trim(cg_filename)//".callgraph")
         END IF
      END IF
 
      CALL cp_print_key_finished_output(iw, logger, root_section, &
                                        "GLOBAL%TIMINGS")
 
      CALL rm_mp_perf_env()
      CALL rm_timer_env()
 
      IF (para_env%is_source()) THEN
         iw = cp_print_key_unit_nr(logger, root_section, "GLOBAL%PROGRAM_RUN_INFO", &
                                   extension=".log")
 
         ! Deleting (if existing) the external EXIT files
         delete_it = .false.
         INQUIRE (file="EXIT", exist=delete_it)
         IF (delete_it) THEN
            CALL open_file(file_name="EXIT", unit_number=unit_exit)
            CALL close_file(unit_number=unit_exit, file_status="DELETE")
         END IF
 
         delete_it = .false.
         INQUIRE (file=trim(logger%iter_info%project_name)//".EXIT", exist=delete_it)
         IF (delete_it) THEN
            CALL open_file(file_name=trim(logger%iter_info%project_name)//".EXIT", unit_number=unit_exit)
            CALL close_file(unit_number=unit_exit, file_status="DELETE")
         END IF
 
         ! Print OpenMP issue counter and number of warnings for this workload
         IF (iw > 0) THEN
            IF (0 <= m_omp_trace_issues()) THEN
               WRITE (iw, "(T2,A,I0)") "The number of traced issues for OpenMP : ", m_omp_trace_issues()
            END IF
            WRITE (iw, "(T2,A,I0)") "The number of warnings for this run is : ", warning_counter
            WRITE (iw, *) ""
            WRITE (unit=iw, fmt="(T2,A)") repeat("-", 79)
         END IF
 
         ! Update the runtime environment variables
         CALL get_runtime_info()
 
         ! Just a choice, do not print the CP2K footer if there is a failure
         CALL cp2k_footer(iw, wdir)
         IF (iw > 0) FLUSH (iw)  ! ignore &GLOBAL / FLUSH_SHOULD_FLUSH
 
         CALL cp_print_key_finished_output(iw, logger, root_section, &
                                           "GLOBAL%PROGRAM_RUN_INFO")
      END IF
 
      ! Release message passing environment
      CALL cp_rm_default_logger()
 
   END SUBROUTINE cp2k_finalize
 
END MODULE environment