input_cp2k_global.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 builds the global input section for cp2k
!> \par History
!>      06.2004 created [fawzi]
!>      03.2014 moved to separate file [Ole Schuett]
!>      10.2016 update seed input [Matthias Krack]
!> \author fawzi
! **************************************************************************************************
MODULE input_cp2k_global
   USE bibliography,                    ONLY: ceriotti2014,&
                                              frigo2005,&
                                              schonherr2014
   USE cp_blacs_env,                    ONLY: blacs_grid_col,&
                                              blacs_grid_row,&
                                              blacs_grid_square
   USE cp_cfm_elpa,                     ONLY: elpa_c_kernel_descriptions,&
                                              elpa_c_kernel_ids,&
                                              elpa_c_kernel_names
   USE cp_dbcsr_cp2k_link,              ONLY: create_dbcsr_section
   USE cp_fm_cholesky,                  ONLY: fm_cholesky_type_default,&
                                              fm_cholesky_type_dlaf,&
                                              fm_cholesky_type_scalapack
   USE cp_fm_diag,                      ONLY: fm_diag_type_cusolver,&
                                              fm_diag_type_default,&
                                              fm_diag_type_dlaf,&
                                              fm_diag_type_elpa,&
                                              fm_diag_type_scalapack
   USE cp_fm_elpa,                      ONLY: elpa_kernel_descriptions,&
                                              elpa_kernel_ids,&
                                              elpa_kernel_names,&
                                              elpa_one_stage,&
                                              elpa_print,&
                                              elpa_qr
   USE cp_fm_struct,                    ONLY: cp_fm_struct_get_ncol_block,&
                                              cp_fm_struct_get_nrow_block
   USE cp_iter_types,                   ONLY: iter_notice,&
                                              iter_silent,&
                                              iter_stack
   USE cp_output_handling,              ONLY: add_last_numeric,&
                                              cp_print_key_section_create,&
                                              debug_print_level,&
                                              high_print_level,&
                                              low_print_level,&
                                              medium_print_level,&
                                              silent_print_level
   USE grid_api,                        ONLY: grid_backend_auto,&
                                              grid_backend_cpu,&
                                              grid_backend_dgemm,&
                                              grid_backend_gpu,&
                                              grid_backend_ref
   USE input_constants,                 ONLY: &
        bsse_run, callgraph_all, callgraph_master, callgraph_none, cell_opt_run, debug_run, &
        do_atom, do_band, do_cosma, do_cp2k, do_dgemm_blas, do_dgemm_spla, do_farming, &
        do_fft_fftw3, do_fft_sg, do_opt_basis, do_optimize_input, do_scalapack, do_swarm, do_tamc, &
        do_test, do_tree_mc, do_tree_mc_ana, driver_run, ehrenfest, energy_force_run, energy_run, &
        fftw_plan_estimate, fftw_plan_exhaustive, fftw_plan_measure, fftw_plan_patient, gaussian, &
        geo_opt_run, linear_response_run, mimic_run, mol_dyn_run, mon_car_run, mtlr_run, negf_run, &
        none_run, pint_run, real_time_propagation, tree_mc_run, vib_anal
   USE input_keyword_types,             ONLY: keyword_create,&
                                              keyword_release,&
                                              keyword_type
   USE input_section_types,             ONLY: section_add_keyword,&
                                              section_add_subsection,&
                                              section_create,&
                                              section_release,&
                                              section_type
   USE input_val_types,                 ONLY: char_t,&
                                              integer_t,&
                                              logical_t
   USE integral_library_types,          ONLY: default_coulomb_library,&
                                              library_libint,&
                                              library_native
   USE kinds,                           ONLY: dp
   USE string_utilities,                ONLY: s2a
   USE timings,                         ONLY: default_timings_level
#include "./base/base_uses.f90"
 
   IMPLICIT NONE
   PRIVATE
 
   LOGICAL, PRIVATE, PARAMETER :: debug_this_module = .true.
   CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'input_cp2k_global'
 
   PUBLIC :: create_global_section
 
CONTAINS
 
! **************************************************************************************************
!> \brief section to hold global settings for the whole program
!> \param section the section to be created
!> \author fawzi
! **************************************************************************************************
   SUBROUTINE create_global_section(section)
      TYPE(section_type), POINTER                        :: section
 
      INTEGER                                            :: default_dgemm
      TYPE(keyword_type), POINTER                        :: keyword
      TYPE(section_type), POINTER                        :: print_key, sub_section
 
      NULLIFY (print_key)
      cpassert(.NOT. ASSOCIATED(section))
      CALL section_create(section, __location__, name="GLOBAL", &
                          description="Section with general information on which kind "// &
                          "of simulation to perform and parameters for the whole PROGRAM", &
                          n_keywords=7, n_subsections=1, repeats=.false.)
 
      NULLIFY (keyword)
      CALL keyword_create(keyword, __location__, name="BLACS_GRID", &
                          description="how to distribute the processors on the 2d grid needed "// &
                          "by BLACS (and thus SCALAPACK)", usage="BLACS_GRID SQUARE", &
                          default_i_val=blacs_grid_square, enum_c_vals=s2a("SQUARE", "ROW", "COLUMN"), &
                          enum_desc=s2a("Distribution by matrix blocks", "Distribution by matrix rows", &
                                        "Distribution by matrix columns"), &
                          enum_i_vals=[blacs_grid_square, blacs_grid_row, blacs_grid_col])
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="BLACS_REPEATABLE", &
                          description="Use a topology for BLACS collectives that is guaranteed to be repeatable "// &
                          "on homogeneous architectures", &
                          usage="BLACS_REPEATABLE", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="PREFERRED_DIAG_LIBRARY", &
                          description="Specifies the diagonalization library to be used. If not available, "// &
                          "the ScaLAPACK library is used. Complex (k-point) matrices use ELPA only when it is "// &
                          "requested explicitly", &
                          usage="PREFERRED_DIAG_LIBRARY ELPA", &
                          enum_i_vals=[fm_diag_type_elpa, &
                                       fm_diag_type_scalapack, &
                                       fm_diag_type_scalapack, &
                                       fm_diag_type_cusolver, &
                                       fm_diag_type_dlaf], &
                          enum_c_vals=s2a("ELPA", "ScaLAPACK", "SL", "CUSOLVER", "DLAF"), &
                          enum_desc=s2a("ELPA library", &
                                        "ScaLAPACK library", &
                                        "ScaLAPACK library (shorthand)", &
                                        "cuSOLVER (CUDA GPU library)", &
                                        "DLA-Future (CUDA/HIP GPU library)"), &
                          default_i_val=fm_diag_type_default)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="DIRECT_GENERALIZED_DIAGONALIZATION", &
                          description="Request direct generalized eigenvalue problem diagonalization "// &
                          "without a CP2K-side Cholesky reduction in supported dense matrix paths. "// &
                          "The eigensolver is still selected by PREFERRED_DIAG_LIBRARY.", &
                          usage="DIRECT_GENERALIZED_DIAGONALIZATION", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="PREFERRED_CHOLESKY_LIBRARY", &
                          description="Specifies Cholesky decomposition library to be used. If not available, "// &
                          "the ScaLAPACK library is used", &
                          usage="PREFERRED_CHOLESKY_LIBRARY DLAF", &
                          enum_i_vals=[fm_cholesky_type_scalapack, &
                                       fm_cholesky_type_scalapack, &
                                       fm_cholesky_type_dlaf], &
                          enum_c_vals=s2a("ScaLAPACK", "SL", "DLAF"), &
                          enum_desc=s2a("ScaLAPACK library", &
                                        "ScaLAPACK library (shorthand)", &
                                        "DLA-Future (CUDA/HIP GPU library)"), &
                          default_i_val=fm_cholesky_type_default)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
#if defined(__SPLA) && defined(__OFFLOAD_GEMM)
      default_dgemm = do_dgemm_spla
#else
      default_dgemm = do_dgemm_blas
#endif
      CALL keyword_create(keyword, __location__, name="PREFERRED_DGEMM_LIBRARY", &
                          description="Specifies the library for supported local real and complex matrix multiplications, "// &
                          "including wavefunction correlation and k-point calculations. SPLA enables GPU acceleration "// &
                          "when available; otherwise BLAS is used. This does not affect distributed matrix multiplications "// &
                          "(see keyword FM%TYPE_OF_MATRIX_MULTIPLICATION).", &
                          usage="PREFERRED_DGEMM_LIBRARY SPLA", &
                          default_i_val=default_dgemm, &
                          enum_i_vals=[do_dgemm_spla, do_dgemm_blas], &
                          enum_c_vals=s2a("SPLA", "BLAS"), &
                          enum_desc=s2a("SPLA library", "BLAS library"))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="EPS_CHECK_DIAG", &
                          description="Check that the orthonormality of the eigenvectors after a diagonalization "// &
                          "fulfills the specified numerical accuracy. A negative threshold value disables the check.", &
                          usage="EPS_CHECK_DIAG 1.0E-14", &
                          default_r_val=-1.0_dp)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ELPA_KERNEL", &
                          description="Specifies the kernel to be used when ELPA is in use for real "// &
                          "symmetric matrices", &
                          default_i_val=elpa_kernel_ids(1), &
                          enum_i_vals=elpa_kernel_ids, &
                          enum_c_vals=elpa_kernel_names, &
                          enum_desc=elpa_kernel_descriptions)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ELPA_COMPLEX_KERNEL", &
                          description="Specifies the kernel to be used when ELPA is in use for complex "// &
                          "Hermitian matrices (k-points)", &
                          default_i_val=elpa_c_kernel_ids(1), &
                          enum_i_vals=elpa_c_kernel_ids, &
                          enum_c_vals=elpa_c_kernel_names, &
                          enum_desc=elpa_c_kernel_descriptions)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ELPA_NEIGVEC_MIN", &
                          description="Minimum number of eigenvectors for the use of the eigensolver from "// &
                          "the ELPA library. The eigensolver from the ScaLAPACK library is used as fallback "// &
                          "for all smaller cases", &
                          usage="ELPA_NEIGVEC_MIN 32", &
                          default_i_val=min(cp_fm_struct_get_nrow_block(), cp_fm_struct_get_ncol_block()))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ELPA_QR", &
                          description="For ELPA, enable a blocked QR step when reducing the input matrix "// &
                          "to banded form before diagonalization. Requires ELPA version 201505 or newer and "// &
                          "is automatically deactivated otherwise. QR is activated only when the matrix size "// &
                          "is suitable. Keyword ELPA_PRINT helps identify suitable cases. Can accelerate "// &
                          "diagonalization for suitable matrices.", &
                          usage="ELPA_QR", &
                          default_l_val=elpa_qr, lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ELPA_ONE_STAGE", &
                          description="For ELPA, enable the one-stage solver (instead of the two-stage solver). "// &
                          "Please note, ELPA_QR and ELPA_KERNEL settings may be ignored.", &
                          usage="ELPA_ONE_STAGE", &
                          default_l_val=elpa_one_stage, lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ELPA_PRINT", &
                          description="Controls the printing of ELPA diagonalization information. "// &
                          "Useful for testing purposes, especially together with keyword ELPA_QR.", &
                          usage="ELPA_PRINT", default_l_val=elpa_print, lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="DLAF_NEIGVEC_MIN", &
                          description="Minimum number of eigenvectors for the use of the eigensolver from "// &
                          "the DLA-Future library. The eigensolver from the ScaLAPACK library is used as fallback "// &
                          "for all smaller cases", &
                          usage="DLAF_NEIGVEC_MIN 512", &
                          default_i_val=1024)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="DLAF_CHOLESKY_N_MIN", &
                          description="Minimum matrix size for the use of the Cholesky decomposition from "// &
                          "the DLA-Future library. The Cholesky decomposition from the ScaLAPACK library is used as fallback "// &
                          "for all smaller cases", &
                          usage="DLAF_CHOLESKY_N_MIN 512", &
                          default_i_val=1024)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create( &
         keyword, __location__, name="PREFERRED_FFT_LIBRARY", &
         description="Specifies the FFT library which should be preferred. "// &
         "If it is not available, use FFTW3 if this is linked in, if FFTW3 is not available use FFTSG. "// &
         "Improved performance with FFTW3 can be obtained specifying a proper value for FFTW_PLAN_TYPE. "// &
         "Contrary to earlier CP2K versions, all libraries will result in the same grids, "// &
         "i.e. the subset of grids which all FFT libraries can transform. "// &
         "FFTW3 is often (close to) optimal, and well tested with CP2K.", &
         usage="PREFERRED_FFT_LIBRARY FFTW3", &
         citations=[frigo2005], &
         default_i_val=do_fft_fftw3, &
         enum_i_vals=[do_fft_sg, do_fft_fftw3, do_fft_fftw3], &
         enum_c_vals=s2a("FFTSG", "FFTW3", "FFTW"), &
         enum_desc=s2a("Stefan Goedecker's FFT (FFTSG), always available, "// &
                       "will be used in case a FFT library is specified and not available.", &
                       "a fast portable FFT library. Recommended. "// &
                       "See also the FFTW_PLAN_TYPE, and FFTW_WISDOM_FILE_NAME keywords.", &
                       "Same as FFTW3 (for compatibility with CP2K 2.3)"))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      NULLIFY (sub_section)
      CALL section_create(sub_section, __location__, name="preferred_integral_library", &
                          description="Selects the implementation of individual Gaussian integral operations.", &
                          n_keywords=2, n_subsections=0, repeats=.false.)
 
      CALL keyword_create(keyword, __location__, name="COULOMB_2C", &
                          description="Preferred library for two-center Coulomb integrals (Coulomb_2c). "// &
                          "Libint is used by default when available; otherwise the native implementation is used.", &
                          usage="COULOMB_2C LIBINT", &
                          enum_c_vals=s2a("NATIVE", "LIBINT"), &
                          enum_i_vals=[library_native, library_libint], &
                          enum_desc=s2a("Use CP2K's native implementation.", &
                                        "Use the Libint implementation."), &
                          default_i_val=default_coulomb_library)
      CALL section_add_keyword(sub_section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="COULOMB_3C", &
                          description="Preferred library for three-center Coulomb integrals (Coulomb_3c). "// &
                          "Libint is used by default when available; otherwise the native implementation is used.", &
                          usage="COULOMB_3C LIBINT", &
                          enum_c_vals=s2a("NATIVE", "LIBINT"), &
                          enum_i_vals=[library_native, library_libint], &
                          enum_desc=s2a("Use CP2K's native implementation.", &
                                        "Use the Libint implementation."), &
                          default_i_val=default_coulomb_library)
      CALL section_add_keyword(sub_section, keyword)
      CALL keyword_release(keyword)
 
      CALL section_add_subsection(section, sub_section)
      CALL section_release(sub_section)
 
      CALL keyword_create(keyword, __location__, name="FFTW_WISDOM_FILE_NAME", &
                          description="The name of the file that contains wisdom (pre-planned FFTs) for use with FFTW3. "// &
                          "Using wisdom can significantly speed up the FFTs (see the FFTW homepage for details). "// &
                          "Note that wisdom is not transferable between different computer (architectures). "// &
                          "Wisdom can be generated using the fftw-wisdom tool that is part of the fftw installation. "// &
                          "cp2k/tools/cp2k-wisdom is a script that contains some additional info, and can help "// &
                          "to generate a useful default for /etc/fftw/wisdom or particular values for a given simulation. "// &
                          "The wisdom is read from the file, if it exists. The updated wisdom is written back to "// &
                          "the file at the end of the run only if this keyword is specified explicitly.", &
                          usage="FFTW_WISDOM_FILE_NAME wisdom.dat", default_lc_val="/etc/fftw/wisdom")
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="FFTW_PLAN_TYPE", &
                          description="FFTW can have improved performance if it is allowed to plan with "// &
                          "explicit measurements which strategy is best for a given FFT. "// &
                          "While a plan based on measurements is generally faster, "// &
                          "differences in machine load will lead to different plans for the same input file, "// &
                          "and thus numerics for the FFTs will be slightly different from run to run. "// &
                          "PATIENT planning is recommended for long ab initio MD runs.", &
                          usage="FFTW_PLAN_TYPE PATIENT", &
                          citations=[frigo2005], &
                          default_i_val=fftw_plan_estimate, &
                          enum_i_vals=[fftw_plan_estimate, fftw_plan_measure, fftw_plan_patient, fftw_plan_exhaustive], &
                          enum_c_vals=s2a("ESTIMATE", &
                                          "MEASURE", &
                                          "PATIENT", &
                                          "EXHAUSTIVE"), &
                          enum_desc=s2a("Quick estimate, no runtime measurements.", &
                                        "Quick measurement, somewhat faster FFTs.", &
                                        "Measurements trying a wider range of possibilities.", &
                                        "Measurements trying all possibilities - use with caution."))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="FFT_POOL_SCRATCH_LIMIT", &
                          description="Limits the memory usage of the FFT scratch pool, potentially reducing efficiency a bit", &
                          usage="FFT_POOL_SCRATCH_LIMIT {INTEGER}", default_i_val=15)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ALLTOALL_SGL", &
                          description="All-to-all communication (FFT) should use single precision", &
                          usage="ALLTOALL_SGL YES", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="PRINT_LEVEL", &
                          variants=["IOLEVEL"], &
                          description="How much output is written out.", &
                          usage="PRINT_LEVEL HIGH", &
                          default_i_val=medium_print_level, enum_c_vals= &
                          s2a("SILENT", "LOW", "MEDIUM", "HIGH", "DEBUG"), &
                          enum_desc=s2a("Almost no output", &
                                        "Little output", "Quite some output", "Lots of output", &
                                        "Everything is written out, useful for debugging purposes only"), &
                          enum_i_vals=[silent_print_level, low_print_level, medium_print_level, &
                                       high_print_level, debug_print_level])
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create( &
         keyword, __location__, name="PROGRAM_NAME", &
         variants=["PROGRAM"], &
         description="Which program should be run", &
         usage="PROGRAM_NAME {STRING}", &
         enum_c_vals=s2a("ATOM", "FARMING", "TEST", "CP2K", "OPTIMIZE_INPUT", "OPTIMIZE_BASIS", "TMC", "MC_ANALYSIS", "SWARM"), &
         enum_desc=s2a("Runs single atom calculations", &
                       "Runs N independent jobs in a single run", &
                       "Do some benchmarking and testing", &
                       "Runs one of the CP2K package", &
                       "A tool to optimize parameters in a CP2K input", &
                       "A tool to create a MOLOPT or ADMM basis for a given set"// &
                       " of training structures", &
                       "Runs Tree Monte Carlo algorithm using additional input file(s)", &
                       "Runs (Tree) Monte Carlo trajectory file analysis", &
                       "Runs swarm based calculation"), &
         enum_i_vals=[do_atom, do_farming, do_test, do_cp2k, do_optimize_input, &
                      do_opt_basis, do_tree_mc, do_tree_mc_ana, do_swarm], &
         default_i_val=do_cp2k)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="PROJECT_NAME", &
                          variants=["PROJECT"], &
                          description="Name of the project (used to build the name of the "// &
                          "trajectory, and other files generated by the program)", &
                          usage="PROJECT_NAME {STRING}", &
                          default_c_val="PROJECT")
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="OUTPUT_FILE_NAME", &
                          description="Name of the output file. "// &
                          "Relevant only if automatically started (through farming for example). "// &
                          "If empty uses the project name as basis for it.", &
                          usage="OUTPUT_FILE_NAME {filename}", default_lc_val="")
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create( &
         keyword, __location__, name="RUN_TYPE", &
         description="Selects the top-level task CP2K should run, such as an energy, "// &
         "energy-and-force, molecular dynamics, geometry optimization, or response calculation.", &
         usage="RUN_TYPE MD", &
         default_i_val=energy_force_run, &
         citations=[ceriotti2014, schonherr2014], &
         enum_c_vals=s2a("NONE", "ENERGY", "ENERGY_FORCE", "MD", "GEO_OPT", &
                         "MC", "DEBUG", "BSSE", "LR", "PINT", "VIBRATIONAL_ANALYSIS", &
                         "BAND", "CELL_OPT", "WFN_OPT", "WAVEFUNCTION_OPTIMIZATION", &
                         "MOLECULAR_DYNAMICS", "GEOMETRY_OPTIMIZATION", "MONTECARLO", &
                         "LINEAR_RESPONSE", "NORMAL_MODES", "RT_PROPAGATION", &
                         "EHRENFEST_DYN", "TAMC", "TMC", "DRIVER", "NEGF", "MIMIC", "RTP", &
                         "MTLR"), &
         enum_i_vals=[none_run, energy_run, energy_force_run, mol_dyn_run, &
                      geo_opt_run, mon_car_run, debug_run, &
                      bsse_run, linear_response_run, pint_run, vib_anal, do_band, &
                      cell_opt_run, energy_run, energy_run, mol_dyn_run, geo_opt_run, &
                      mon_car_run, linear_response_run, &
                      vib_anal, real_time_propagation, ehrenfest, do_tamc, tree_mc_run, &
                      driver_run, negf_run, mimic_run, real_time_propagation, mtlr_run], &
         enum_desc=s2a("Perform no tasks", "Computes energy", "Computes energy and forces", &
                       "Molecular Dynamics", "Geometry Optimization", "Monte Carlo", &
                       "Performs a Debug analysis", "Basis set superposition error", "Linear Response", &
                       "Path integral", "Vibrational analysis", "Band methods", &
                       "Cell optimization. Both cell vectors and atomic positions are optimised.", &
                       "Alias for ENERGY", "Alias for ENERGY", "Alias for MD", "Alias for GEO_OPT", &
                       "Alias for MC", "Alias for LR", "Alias for VIBRATIONAL_ANALYSIS", &
                       "Real Time propagation run (fixed ionic positions)", &
                       "Ehrenfest dynamics (using real time propagation of the wavefunction)", &
                       "Temperature Accelerated Monte Carlo (TAMC)", &
                       "Tree Monte Carlo (TMC), a pre-sampling MC algorithm", &
                       "i-PI driver mode", &
                       "Non-equilibrium Green's function method", &
                       "Run as a client in a simulation through the MiMiC framework", &
                       "Alias for RT_PROPAGATION", &
                       "Minimum tracking linear response calculation for Hubbard U and Hund's J"))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="WALLTIME", &
                          variants=["WALLTI"], &
                          description="Maximum execution time for this run. Time in seconds or in HH:MM:SS.", &
                          usage="WALLTIME {real} or {HH:MM:SS}", default_lc_val="")
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ECHO_INPUT", &
                          description="If the input should be echoed to the output with all the "// &
                          "defaults made explicit", &
                          usage="ECHO_INPUT NO", default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ECHO_ALL_HOSTS", &
                          description="Echo a list of hostname and pid for all MPI processes.", &
                          usage="ECHO_ALL_HOSTS NO", default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ENABLE_MPI_IO", &
                          description="Enable MPI parallelization for all supported I/O routines "// &
                          "Currently, only cube file writer/reader routines use MPI I/O. Disabling "// &
                          "this flag might speed up calculations dominated by I/O.", &
                          usage="ENABLE_MPI_IO FALSE", default_l_val=.true., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="TRACE", &
                          description="If a debug trace of the execution of the program should be written", &
                          usage="TRACE", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="TRACE_MASTER", &
                          description="For parallel TRACEd runs: only the master node writes output.", &
                          usage="TRACE_MASTER", &
                          default_l_val=.true., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create( &
         keyword, __location__, name="TRACE_MAX", &
         description="Limit the total number a given subroutine is printed in the trace. Accounting is not influenced.", &
         usage="TRACE_MAX 100", default_i_val=huge(0))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create( &
         keyword, __location__, name="TRACE_ROUTINES", &
         description="A list of routines to trace. If left empty all routines are traced. Accounting is not influenced.", &
         usage="TRACE_ROUTINES {routine_name1} {routine_name2} ...", type_of_var=char_t, &
         n_var=-1)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create( &
         keyword, __location__, name="FLUSH_SHOULD_FLUSH", &
         description="Flush output regularly, enabling this option might degrade performance significantly on certain machines.", &
         usage="FLUSH_SHOULD_FLUSH", &
         default_l_val=.true., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ITER_LEVEL_VERBOSITY", &
                          description="Controls the verbosity of information about iteration levels "// &
                          "printed upon entry or exit of one. Iteration levels are defined by type "// &
                          "of task; the names and descriptions of iteration levels are listed under "// &
                          "the EACH section of printkeys. The default is dependent on PRINT_LEVEL: "// &
                          "SILENT for MEDIUM or lower, NOTICE for HIGH, STACK for DEBUG.", &
                          usage="ITER_LEVEL_VERBOSITY NOTICE", default_i_val=iter_silent, &
                          enum_c_vals=s2a("SILENT", "NOTICE", "STACK"), &
                          enum_desc=s2a("Do not print anything about iter levels", &
                                        "Print a notice when entering or exiting an iter level", &
                                        "Print a notice and also the full stack of iter levels"), &
                          enum_i_vals=[iter_silent, iter_notice, iter_stack])
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="CALLGRAPH", &
                          description="At the end of the run write a callgraph to file, "// &
                          "which contains detailed timing informations. "// &
                          "This callgraph can be viewed e.g. with the open-source program kcachegrind.", &
                          usage="CALLGRAPH {NONE|MASTER|ALL}", &
                          default_i_val=callgraph_none, lone_keyword_i_val=callgraph_master, &
                          enum_c_vals=s2a("NONE", "MASTER", "ALL"), &
                          enum_desc=s2a("No callgraph gets written", &
                                        "Only the master process writes his callgraph", &
                                        "All processes write their callgraph (into a separate files)."), &
                          enum_i_vals=[callgraph_none, callgraph_master, callgraph_all])
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="CALLGRAPH_FILE_NAME", &
                          description="Name of the callgraph file, which is written at the end of the run. "// &
                          "If not specified the project name will be used as filename.", &
                          usage="CALLGRAPH_FILE_NAME {filename}", default_lc_val="")
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="SEED", &
                          description="Initial seed for the global (pseudo)random number generator "// &
                          "to create a stream of normally Gaussian distributed random numbers. "// &
                          "Exactly 1 or 6 positive integer values are expected. A single value is "// &
                          "replicated to fill up the full seed array with 6 numbers.", &
                          n_var=-1, &
                          type_of_var=integer_t, &
                          usage="SEED {INTEGER} .. {INTEGER}", &
                          default_i_vals=[2000])
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="SAVE_MEM", &
                          description="Some sections of the input structure are deallocated when not needed,"// &
                          " and reallocated only when used. This reduces the required maximum memory.", &
                          usage="SAVE_MEM", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL cp_print_key_section_create(print_key, __location__, "TIMINGS", description= &
                                       "Controls the printing of the timing report at the end of CP2K execution", &
                                       print_level=silent_print_level, filename="__STD_OUT__")
 
      CALL keyword_create(keyword, __location__, name="THRESHOLD", &
                          description="Specify % of CPUTIME above which the contribution will be inserted in the"// &
                          " final timing report (e.g. 0.02 = 2%)", &
                          usage="THRESHOLD {REAL}", &
                          default_r_val=0.02_dp)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="SORT_BY_SELF_TIME", &
                          description="Sort the final timing report by the average self (exclusive) time instead of the "// &
                          "total (inclusive) time of a routine", &
                          usage="SORT_BY_SELF_TIME on", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="REPORT_MAXLOC", &
                          description="Report the rank with the slowest maximum self timing."// &
                          " Can be used to debug hard- or software."// &
                          " Also enables ECHO_ALL_HOSTS to link rank to hostname.", &
                          usage="REPORT_MAXLOC on", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="TIME_MPI", &
                          description="Include message_passing calls in the timing report (useful with CALLGRAPH).", &
                          usage="TIME_MPI .FALSE.", &
                          default_l_val=.true., lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="TIMINGS_LEVEL", &
                          description="Specify the level of timings report. "// &
                          "Possible values are: 0 (report only CP2K root timer), 1 (all timers).", &
                          usage="TIMINGS_LEVEL 1", &
                          default_i_val=default_timings_level, lone_keyword_i_val=default_timings_level)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
 
      CALL section_add_subsection(section, print_key)
      CALL section_release(print_key)
 
      CALL cp_print_key_section_create(print_key, __location__, "REFERENCES", description= &
                                       "Controls the printing of the references relevant to the calculations performed", &
                                       print_level=silent_print_level, filename="__STD_OUT__")
      CALL section_add_subsection(section, print_key)
      CALL section_release(print_key)
 
      CALL cp_print_key_section_create(print_key, __location__, "PROGRAM_RUN_INFO", &
                                       description="controls the printing of  initialization controlled by the global section", &
                                       print_level=silent_print_level, add_last=add_last_numeric, filename="__STD_OUT__")
      CALL section_add_subsection(section, print_key)
      CALL section_release(print_key)
 
      CALL cp_print_key_section_create(print_key, __location__, "PRINT", description= &
                                       "controls the printing of physical and mathematical constants", &
                                       print_level=medium_print_level, filename="__STD_OUT__")
 
      CALL keyword_create(keyword, __location__, name="BASIC_DATA_TYPES", &
                          description="Controls the printing of the basic data types.", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
      CALL keyword_create(keyword, __location__, name="physcon", &
                          description="if the printkey is active prints the physical constants", &
                          default_l_val=.true., lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
      CALL keyword_create(keyword, __location__, name="SPHERICAL_HARMONICS", &
                          description="if the printkey is active prints the spherical harmonics", &
                          default_i_val=-1, type_of_var=integer_t)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
      CALL keyword_create(keyword, __location__, name="RNG_MATRICES", &
                          description="Prints the transformation matrices used by the  random number generator", &
                          default_l_val=.false., &
                          lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
      CALL keyword_create(keyword, __location__, name="RNG_CHECK", &
                          description="Performs a check of the global (pseudo)random "// &
                          "number generator (RNG) and prints the result", &
                          default_l_val=.false., &
                          lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
      CALL keyword_create(keyword, __location__, name="GLOBAL_GAUSSIAN_RNG", &
                          description="Prints the initial status of the global Gaussian "// &
                          "(pseudo)random number stream which is mostly used for "// &
                          "the velocity initialization", &
                          default_l_val=.false., &
                          lone_keyword_l_val=.true.)
      CALL section_add_keyword(print_key, keyword)
      CALL keyword_release(keyword)
 
      CALL section_add_subsection(section, print_key)
      CALL section_release(print_key)
      NULLIFY (sub_section)
      ! FM section
      CALL create_fm_section(sub_section)
      CALL section_add_subsection(section, sub_section)
      CALL section_release(sub_section)
      ! DBCSR options
      CALL create_dbcsr_section(sub_section)
      CALL section_add_subsection(section, sub_section)
      CALL section_release(sub_section)
      ! FM diagonalization redistribution rules
      CALL create_fm_diag_rules_section(sub_section)
      CALL section_add_subsection(section, sub_section)
      CALL section_release(sub_section)
      ! Grid library
      CALL create_grid_section(sub_section)
      CALL section_add_subsection(section, sub_section)
      CALL section_release(sub_section)
 
   END SUBROUTINE create_global_section
 
! **************************************************************************************************
!> \brief   Creates the dbcsr section for configuring FM
!> \param section ...
!> \date    2011-04-05
!> \author  Florian Schiffmann
! **************************************************************************************************
   SUBROUTINE create_fm_section(section)
      TYPE(section_type), POINTER                        :: section
 
      INTEGER                                            :: default_matmul
      TYPE(keyword_type), POINTER                        :: keyword
 
      cpassert(.NOT. ASSOCIATED(section))
      CALL section_create(section, __location__, name="FM", &
                          description="Configuration options for the full matrices.", &
                          n_keywords=1, n_subsections=0, repeats=.false.)
 
      NULLIFY (keyword)
 
      CALL keyword_create(keyword, __location__, name="NROW_BLOCKS", &
                          description="Defines the number of rows per scalapack block in "// &
                          "the creation of block cyclic dense matrices. "// &
                          "Use an internal default if zero or negative.", &
                          default_i_val=cp_fm_struct_get_nrow_block())
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="NCOL_BLOCKS", &
                          description="Defines the number of columns per scalapack block in "// &
                          "the creation of vlock cyclic dense matrices. "// &
                          "Use an internal default if zero or negative.", &
                          default_i_val=cp_fm_struct_get_ncol_block())
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="FORCE_BLOCK_SIZE", &
                          description="Ensure for small matrices that the layout is compatible "// &
                          "with bigger ones, i.e. no subdivision is performed (can break LAPACK).", &
                          usage="FORCE_BLOCK_SIZE", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
#if defined(__COSMA)
      default_matmul = do_cosma
#else
      default_matmul = do_scalapack
#endif
 
      CALL keyword_create(keyword, __location__, name="TYPE_OF_MATRIX_MULTIPLICATION", &
                          description="Allows to switch between scalapack pxgemm and COSMA pxgemm. "// &
                          "COSMA reduces the communication costs but increases the memory demands. "// &
                          "The performance of Scalapack's pxgemm on GPU's depends "// &
                          "crucially on the BLOCK_SIZES. Make sure optimized kernels are available.", &
                          default_i_val=default_matmul, &
                          enum_i_vals=[do_scalapack, do_scalapack, do_cosma], &
                          enum_c_vals=s2a("SCALAPACK", "PDGEMM", "COSMA"), &
                          enum_desc=s2a("Standard ScaLAPACK pdgemm", &
                                        "Alias for ScaLAPACK", &
                                        "COSMA is employed. See <https://github.com/eth-cscs/COSMA>."))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      !
   END SUBROUTINE create_fm_section
! **************************************************************************************************
!> \brief   Creates the input section used to define the heuristic rules which determine if
!>          a FM matrix should be redistributed before diagonalizing it.
!> \param section the input section to create
!> \author Nico Holmberg [01.2018]
! **************************************************************************************************
   SUBROUTINE create_fm_diag_rules_section(section)
      TYPE(section_type), POINTER                        :: section
 
      TYPE(keyword_type), POINTER                        :: keyword
 
      cpassert(.NOT. ASSOCIATED(section))
      CALL section_create(section, __location__, name="FM_DIAG_SETTINGS", &
                          description="This section defines a set of heuristic rules which are "// &
                          "used to calculate the optimal number of CPUs, M, needed to diagonalize a "// &
                          "full matrix distributed on N processors (FM type). If M &lt N, the matrix "// &
                          "is redistributed onto M processors before it is diagonalized. "// &
                          "The optimal value is calculate according to M = ((K+a*x-1)/(a*x))*a, "// &
                          "where K is the size of the matrix, and {a, x} are integers defined below. "// &
                          "The default values have been selected based on timings on a Cray XE6. "// &
                          "Supports diagonalization libraries SL and ELPA (see keyword ELPA_FORCE_REDISTRIBUTE).", &
                          n_keywords=3, n_subsections=0, repeats=.false.)
 
      NULLIFY (keyword)
 
      CALL keyword_create(keyword, __location__, name="PARAMETER_A", &
                          description="Parameter used for defining the rule which determines the optimal "// &
                          "number of CPUs needed to diagonalize a full distributed matrix. The optimal "// &
                          "number of CPUs will be an integer multiple of this variable.", &
                          usage="PARAMETER_A 4", type_of_var=integer_t, &
                          default_i_val=4)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="PARAMETER_X", &
                          description="Parameter used for defining the rule which determines the optimal "// &
                          "number of CPUs needed to diagonalize a full distributed matrix. The optimal "// &
                          "number of CPUs will be roughly proportional to this value.", &
                          usage="PARAMETER_X 60", type_of_var=integer_t, &
                          default_i_val=60)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="PRINT_FM_REDISTRIBUTE", &
                          description="Controls printing of information related to this section. For each "// &
                          "diagonalized matrix, prints the size of the matrix, the optimal number of CPUs, "// &
                          "as well as notifies if the matrix was redistributed. Useful for testing.", &
                          usage="PRINT_FM_REDISTRIBUTE", type_of_var=logical_t, &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="ELPA_FORCE_REDISTRIBUTE", &
                          description="Controls how to perform redistribution when ELPA is used for diagonalization. "// &
                          "By default, matrices are redistributed only when required by the ELPA layout. "// &
                          "Turning on this keyword also applies the defined rules to reduce the number of "// &
                          "processors, using a layout without empty process rows or columns.", &
                          usage="ELPA_FORCE_REDISTRIBUTE", type_of_var=logical_t, &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
   END SUBROUTINE create_fm_diag_rules_section
 
! **************************************************************************************************
!> \brief Creates the section for configuring the grid library
!> \param section ...
!> \author Ole Schuett
! **************************************************************************************************
   SUBROUTINE create_grid_section(section)
      TYPE(section_type), POINTER                        :: section
 
      TYPE(keyword_type), POINTER                        :: keyword
 
      cpassert(.NOT. ASSOCIATED(section))
      CALL section_create(section, __location__, name="GRID", &
                          description="Configuration options for the grid library, "// &
                          "which performs e.g. the collocate and integrate of the GPW method.", &
                          n_keywords=1, n_subsections=0, repeats=.false.)
 
      NULLIFY (keyword)
      CALL keyword_create(keyword, __location__, name="BACKEND", &
                          description="Selects the backed used by the grid library.", &
                          default_i_val=grid_backend_auto, &
                          enum_i_vals=[grid_backend_auto, grid_backend_ref, grid_backend_cpu, &
                                       grid_backend_dgemm, grid_backend_gpu], &
                          enum_c_vals=s2a("AUTO", "REFERENCE", "CPU", "DGEMM", "GPU"), &
                          enum_desc=s2a("Let the grid library pick the backend automatically", &
                                        "Reference backend implementation", &
                                        "Optimized CPU backend", &
                                        "Alternative CPU backend based on DGEMM", &
                                        "GPU backend optimized for NVIDIA and AMD GPU"))
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="VALIDATE", &
                          description="When enabled the reference backend is run in shadow mode "// &
                          "and its results are compared with those from the selected backend. "// &
                          "If the two results differ by too much then the calculation is aborted.", &
                          default_l_val=.false., lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
      CALL keyword_create(keyword, __location__, name="APPLY_CUTOFF", &
                          description="When enabled the cpu backend "// &
                          "apply a spherical cutoff on the top of the cube. "// &
                          "There is a performance penalty using it in "// &
                          "combination with the cpu backend but it is on by "// &
                          "default for the regtests", default_l_val=.true., &
                          lone_keyword_l_val=.true.)
      CALL section_add_keyword(section, keyword)
      CALL keyword_release(keyword)
 
   END SUBROUTINE create_grid_section
 
END MODULE input_cp2k_global