d7/d56/qs__subsys__methods_8F_source.html

 !--------------------------------------------------------------------------------------------------!

 !   CP2K: A general program to perform molecular dynamics simulations                              !

 !   Copyright 2000-2024 CP2K developers group <https://cp2k.org>                                   !

 !                                                                                                  !

 !   SPDX-License-Identifier: GPL-2.0-or-later                                                      !

 !--------------------------------------------------------------------------------------------------!


 ! **************************************************************************************************

 !> \brief Routines that work on qs_subsys_type

 !> \author Ole Schuett

 ! **************************************************************************************************

 MODULE qs_subsys_methods

    USE atom_types,                      ONLY: lmat

    USE atomic_kind_types,               ONLY: atomic_kind_type,&

                                               get_atomic_kind

    USE basis_set_types,                 ONLY: get_gto_basis_set,&

                                               gto_basis_set_type

    USE cell_methods,                    ONLY: cell_create,&

                                               read_cell,&

                                               write_cell

    USE cell_types,                      ONLY: cell_clone,&

                                               cell_release,&

                                               cell_type

    USE cp_subsys_methods,               ONLY: cp_subsys_create

    USE cp_subsys_types,                 ONLY: cp_subsys_get,&

                                               cp_subsys_release,&

                                               cp_subsys_set,&

                                               cp_subsys_type

    USE external_potential_types,        ONLY: all_potential_type,&

                                               get_potential,&

                                               gth_potential_type,&

                                               sgp_potential_type

    USE input_section_types,             ONLY: section_vals_get_subs_vals,&

                                               section_vals_type

    USE kinds,                           ONLY: dp

    USE message_passing,                 ONLY: mp_para_env_type

    USE molecule_kind_types,             ONLY: get_molecule_kind,&

                                               molecule_kind_type,&

                                               set_molecule_kind

    USE qs_kind_types,                   ONLY: create_qs_kind_set,&

                                               get_qs_kind,&

                                               init_atom_electronic_state,&

                                               qs_kind_type

    USE qs_subsys_types,                 ONLY: qs_subsys_set,&

                                               qs_subsys_type

 #include "./base/base_uses.f90"


    IMPLICIT NONE

    PRIVATE


    CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'qs_subsys_methods'


    PUBLIC :: qs_subsys_create


 CONTAINS


 ! **************************************************************************************************

 !> \brief Creates a qs_subsys. Optionally an existsing cp_subsys is used.

 !> \param subsys ...

 !> \param para_env ...

 !> \param root_section ...

 !> \param force_env_section ...

 !> \param subsys_section ...

 !> \param use_motion_section ...

 !> \param cp_subsys ...

 !> \param cell ...

 !> \param cell_ref ...

 !> \param elkind ...

 ! **************************************************************************************************

    SUBROUTINE qs_subsys_create(subsys, para_env, root_section, force_env_section, subsys_section, &

                                use_motion_section, cp_subsys, cell, cell_ref, elkind)

       TYPE(qs_subsys_type), INTENT(OUT)                  :: subsys

       TYPE(mp_para_env_type), POINTER                    :: para_env

       TYPE(section_vals_type), OPTIONAL, POINTER         :: root_section

       TYPE(section_vals_type), POINTER                   :: force_env_section, subsys_section

       LOGICAL, INTENT(IN)                                :: use_motion_section

       TYPE(cp_subsys_type), OPTIONAL, POINTER            :: cp_subsys

       TYPE(cell_type), OPTIONAL, POINTER                 :: cell, cell_ref

       LOGICAL, INTENT(IN), OPTIONAL                      :: elkind


       LOGICAL                                            :: use_ref_cell

       TYPE(atomic_kind_type), DIMENSION(:), POINTER      :: atomic_kind_set

       TYPE(cell_type), POINTER                           :: my_cell, my_cell_ref

       TYPE(cp_subsys_type), POINTER                      :: my_cp_subsys

       TYPE(qs_kind_type), DIMENSION(:), POINTER          :: qs_kind_set

       TYPE(section_vals_type), POINTER                   :: cell_section, kind_section


       NULLIFY (atomic_kind_set, qs_kind_set, cell_section, kind_section, my_cell, my_cell_ref, my_cp_subsys)


       ! create cp_subsys

       IF (PRESENT(cp_subsys)) THEN

          my_cp_subsys => cp_subsys

       ELSE IF (PRESENT(root_section)) THEN

          CALL cp_subsys_create(my_cp_subsys, para_env, root_section=root_section, &

                                force_env_section=force_env_section, &

                                subsys_section=subsys_section, &

                                use_motion_section=use_motion_section, &

                                elkind=elkind)

       ELSE

          cpabort("qs_subsys_create: cp_subsys or root_section needed")

       END IF


       ! create cp_subsys%cell

       !TODO: moved to cp_subsys_create(), needs further disentanglement of cell_ref.

       use_ref_cell = .false.

       IF (PRESENT(cell)) THEN

          my_cell => cell

          IF (PRESENT(cell_ref)) THEN

             my_cell_ref => cell_ref

             use_ref_cell = .true.

          ELSE

             CALL cell_create(my_cell_ref)

             CALL cell_clone(my_cell, my_cell_ref, tag="CELL_REF")

          END IF

       ELSE

          cell_section => section_vals_get_subs_vals(subsys_section, "CELL")

          CALL read_cell(my_cell, my_cell_ref, use_ref_cell=use_ref_cell, &

                         cell_section=cell_section, para_env=para_env)

       END IF

       CALL cp_subsys_set(my_cp_subsys, cell=my_cell)

       CALL write_cell(my_cell, subsys_section)

       CALL write_cell(my_cell_ref, subsys_section)


       ! setup qs_kinds

       CALL cp_subsys_get(my_cp_subsys, atomic_kind_set=atomic_kind_set)

       kind_section => section_vals_get_subs_vals(subsys_section, "KIND")

       CALL create_qs_kind_set(qs_kind_set, atomic_kind_set, kind_section, &

                               para_env, force_env_section)


       CALL num_ao_el_per_molecule(my_cp_subsys%molecule_kinds%els, &

                                   qs_kind_set)


       CALL qs_subsys_set(subsys, &

                          cp_subsys=my_cp_subsys, &

                          cell_ref=my_cell_ref, &

                          use_ref_cell=use_ref_cell, &

                          qs_kind_set=qs_kind_set)


       IF (.NOT. PRESENT(cell)) CALL cell_release(my_cell)

       IF (.NOT. PRESENT(cell_ref)) CALL cell_release(my_cell_ref)

       IF (.NOT. PRESENT(cp_subsys)) CALL cp_subsys_release(my_cp_subsys)

    END SUBROUTINE qs_subsys_create


 ! **************************************************************************************************

 !> \brief   Read a molecule kind data set from the input file.

 !> \param molecule_kind_set ...

 !> \param qs_kind_set ...

 !> \date    22.11.2004

 !> \par History

 !>      Rustam Z. Khaliullin 10.2014 - charges and electrons of molecules

 !>                                     are now in agreement with atomic guess

 !> \author  MI

 !> \version 1.0

 ! **************************************************************************************************

    SUBROUTINE num_ao_el_per_molecule(molecule_kind_set, qs_kind_set)


       TYPE(molecule_kind_type), DIMENSION(:), POINTER    :: molecule_kind_set

       TYPE(qs_kind_type), DIMENSION(:), POINTER          :: qs_kind_set


       INTEGER                                            :: arbitrary_spin, iatom, ikind, imol, &

                                                             n_ao, natom, nmol_kind, nsgf, nspins, &

                                                             z_molecule

       INTEGER, DIMENSION(0:lmat, 10)                     :: ne_core, ne_elem, ne_explicit

       INTEGER, DIMENSION(2)                              :: n_occ_alpha_and_beta

       REAL(kind=dp)                                      :: charge_molecule, zeff, zeff_correction

       REAL(kind=dp), DIMENSION(0:lmat, 10, 2)            :: edelta

       TYPE(all_potential_type), POINTER                  :: all_potential

       TYPE(atomic_kind_type), POINTER                    :: atomic_kind

       TYPE(gth_potential_type), POINTER                  :: gth_potential

       TYPE(gto_basis_set_type), POINTER                  :: orb_basis_set

       TYPE(molecule_kind_type), POINTER                  :: molecule_kind

       TYPE(sgp_potential_type), POINTER                  :: sgp_potential


       IF (ASSOCIATED(molecule_kind_set)) THEN


          nspins = 2

          nmol_kind = SIZE(molecule_kind_set, 1)

          natom = 0


          !   *** Initialize the molecule kind data structure ***

          arbitrary_spin = 1

          DO imol = 1, nmol_kind


             molecule_kind => molecule_kind_set(imol)

             CALL get_molecule_kind(molecule_kind=molecule_kind, &

                                    natom=natom)

             !nelectron = 0

             n_ao = 0

             n_occ_alpha_and_beta(1:nspins) = 0

             z_molecule = 0


             DO iatom = 1, natom


                atomic_kind => molecule_kind%atom_list(iatom)%atomic_kind

                CALL get_atomic_kind(atomic_kind, kind_number=ikind)

                CALL get_qs_kind(qs_kind_set(ikind), &

                                 basis_set=orb_basis_set, &

                                 all_potential=all_potential, &

                                 gth_potential=gth_potential, &

                                 sgp_potential=sgp_potential)


                ! Obtain the electronic state of the atom

                ! The same state is used to calculate the ATOMIC GUESS

                ! It is great that we are consistent with ATOMIC_GUESS

                CALL init_atom_electronic_state(atomic_kind=atomic_kind, &

                                                qs_kind=qs_kind_set(ikind), &

                                                ncalc=ne_explicit, &

                                                ncore=ne_core, &

                                                nelem=ne_elem, &

                                                edelta=edelta)


                ! If &BS section is used ATOMIC_GUESS is calculated twice

                ! for two separate wfns with their own alpha-beta combinations

                ! This is done to break the spin symmetry of the initial wfn

                ! For now, only alpha part of &BS is used to count electrons on

                ! molecules

                ! Get the number of explicit electrons (i.e. with orbitals)

                ! For now, only the total number of electrons can be obtained

                ! from init_atom_electronic_state

                n_occ_alpha_and_beta(arbitrary_spin) = &

                   n_occ_alpha_and_beta(arbitrary_spin) + sum(ne_explicit) + &

                   sum(nint(2*edelta(:, :, arbitrary_spin)))

                ! We need a way to specify the number of alpha and beta electrons

                ! on each molecule (i.e. multiplicity is not enough)

                !n_occ(ispin) = n_occ(ispin) + SUM(ne_explicit) + SUM(NINT(2*edelta(:, :, ispin)))


                IF (ASSOCIATED(all_potential)) THEN

                   CALL get_potential(potential=all_potential, zeff=zeff, &

                                      zeff_correction=zeff_correction)

                ELSE IF (ASSOCIATED(gth_potential)) THEN

                   CALL get_potential(potential=gth_potential, zeff=zeff, &

                                      zeff_correction=zeff_correction)

                ELSE IF (ASSOCIATED(sgp_potential)) THEN

                   CALL get_potential(potential=sgp_potential, zeff=zeff, &

                                      zeff_correction=zeff_correction)

                ELSE

                   zeff = 0.0_dp

                   zeff_correction = 0.0_dp

                END IF

                z_molecule = z_molecule + nint(zeff - zeff_correction)


                ! this one does not work because nelem is not adjusted in the symmetry breaking code

                !CALL get_atomic_kind(atomic_kind,z=z)

                !z_molecule=z_molecule+z


                IF (ASSOCIATED(orb_basis_set)) THEN

                   CALL get_gto_basis_set(gto_basis_set=orb_basis_set, nsgf=nsgf)

                ELSE

                   nsgf = 0

                END IF

                n_ao = n_ao + nsgf


             END DO ! iatom


             ! At this point we have the number of electrons (alpha+beta) on the molecule

             !  as they are seen by the ATOMIC GUESS routines

             charge_molecule = real(z_molecule - n_occ_alpha_and_beta(arbitrary_spin), dp)

             CALL set_molecule_kind(molecule_kind=molecule_kind, &

                                    nelectron=n_occ_alpha_and_beta(arbitrary_spin), &

                                    charge=charge_molecule, &

                                    nsgf=n_ao)


          END DO ! imol

       END IF


    END SUBROUTINE num_ao_el_per_molecule


 END MODULE qs_subsys_methods

atom_types
Define the atom type and its sub types.
Definition: atom_types.F:15

atom_types::lmat
integer, parameter, public lmat
Definition: atom_types.F:67

atomic_kind_types
Define the atomic kind types and their sub types.
Definition: atomic_kind_types.F:23

atomic_kind_types::get_atomic_kind
subroutine, public get_atomic_kind(atomic_kind, fist_potential, element_symbol, name, mass, kind_number, natom, atom_list, rcov, rvdw, z, qeff, apol, cpol, mm_radius, shell, shell_active, damping)
Get attributes of an atomic kind.
Definition: atomic_kind_types.F:138

basis_set_types
Definition: basis_set_types.F:15

basis_set_types::get_gto_basis_set
subroutine, public get_gto_basis_set(gto_basis_set, name, aliases, norm_type, kind_radius, ncgf, nset, nsgf, cgf_symbol, sgf_symbol, norm_cgf, set_radius, lmax, lmin, lx, ly, lz, m, ncgf_set, npgf, nsgf_set, nshell, cphi, pgf_radius, sphi, scon, zet, first_cgf, first_sgf, l, last_cgf, last_sgf, n, gcc, maxco, maxl, maxpgf, maxsgf_set, maxshell, maxso, nco_sum, npgf_sum, nshell_sum, maxder, short_kind_radius)
...
Definition: basis_set_types.F:615

cell_methods
Handles all functions related to the CELL.
Definition: cell_methods.F:15

cell_methods::read_cell
recursive subroutine, public read_cell(cell, cell_ref, use_ref_cell, cell_section, check_for_ref, para_env)
...
Definition: cell_methods.F:272

cell_methods::write_cell
subroutine, public write_cell(cell, subsys_section, tag)
Write the cell parameters to the output unit.
Definition: cell_methods.F:731

cell_methods::cell_create
subroutine, public cell_create(cell, hmat, periodic, tag)
allocates and initializes a cell
Definition: cell_methods.F:85

cell_types
Handles all functions related to the CELL.
Definition: cell_types.F:15

cell_types::cell_release
subroutine, public cell_release(cell)
releases the given cell (see doc/ReferenceCounting.html)
Definition: cell_types.F:559

cell_types::cell_clone
subroutine, public cell_clone(cell_in, cell_out, tag)
Clone cell variable.
Definition: cell_types.F:107

cp_subsys_methods
Initialize a small environment for a particular calculation.
Definition: cp_subsys_methods.F:15

cp_subsys_methods::cp_subsys_create
subroutine, public cp_subsys_create(subsys, para_env, root_section, force_env_section, subsys_section, use_motion_section, qmmm, qmmm_env, exclusions, elkind)
Creates allocates and fills subsys from given input.
Definition: cp_subsys_methods.F:96

cp_subsys_types
types that represent a subsys, i.e. a part of the system
Definition: cp_subsys_types.F:16

cp_subsys_types::cp_subsys_release
subroutine, public cp_subsys_release(subsys)
releases a subsys (see doc/ReferenceCounting.html)
Definition: cp_subsys_types.F:150

cp_subsys_types::cp_subsys_set
subroutine, public cp_subsys_set(subsys, atomic_kinds, particles, local_particles, molecules, molecule_kinds, local_molecules, para_env, colvar_p, shell_particles, core_particles, gci, multipoles, results, cell)
sets various propreties of the subsys
Definition: cp_subsys_types.F:205

cp_subsys_types::cp_subsys_get
subroutine, public cp_subsys_get(subsys, ref_count, atomic_kinds, atomic_kind_set, particles, particle_set, local_particles, molecules, molecule_set, molecule_kinds, molecule_kind_set, local_molecules, para_env, colvar_p, shell_particles, core_particles, gci, multipoles, natom, nparticle, ncore, nshell, nkind, atprop, virial, results, cell)
returns information about various attributes of the given subsys
Definition: cp_subsys_types.F:345

external_potential_types
Definition of the atomic potential types.
Definition: external_potential_types.F:14

input_section_types
objects that represent the structure of input sections and the data contained in an input section
Definition: input_section_types.F:15

input_section_types::section_vals_get_subs_vals
recursive type(section_vals_type) function, pointer, public section_vals_get_subs_vals(section_vals, subsection_name, i_rep_section, can_return_null)
returns the values of the requested subsection
Definition: input_section_types.F:724

kinds
Defines the basic variable types.
Definition: kinds.F:23

kinds::dp
integer, parameter, public dp
Definition: kinds.F:34

message_passing
Interface to the message passing library MPI.
Definition: message_passing.F:23

molecule_kind_types
Define the molecule kind structure types and the corresponding functionality.
Definition: molecule_kind_types.F:16

molecule_kind_types::get_molecule_kind
subroutine, public get_molecule_kind(molecule_kind, atom_list, bond_list, bend_list, ub_list, impr_list, opbend_list, colv_list, fixd_list, g3x3_list, g4x6_list, vsite_list, torsion_list, shell_list, name, mass, charge, kind_number, natom, nbend, nbond, nub, nimpr, nopbend, nconstraint, nconstraint_fixd, nfixd, ncolv, ng3x3, ng4x6, nvsite, nfixd_restraint, ng3x3_restraint, ng4x6_restraint, nvsite_restraint, nrestraints, nmolecule, nsgf, nshell, ntorsion, molecule_list, nelectron, nelectron_alpha, nelectron_beta, bond_kind_set, bend_kind_set, ub_kind_set, impr_kind_set, opbend_kind_set, torsion_kind_set, molname_generated)
Get informations about a molecule kind.
Definition: molecule_kind_types.F:510

molecule_kind_types::set_molecule_kind
subroutine, public set_molecule_kind(molecule_kind, name, mass, charge, kind_number, molecule_list, atom_list, nbond, bond_list, nbend, bend_list, nub, ub_list, nimpr, impr_list, nopbend, opbend_list, ntorsion, torsion_list, fixd_list, ncolv, colv_list, ng3x3, g3x3_list, ng4x6, nfixd, g4x6_list, nvsite, vsite_list, ng3x3_restraint, ng4x6_restraint, nfixd_restraint, nshell, shell_list, nvsite_restraint, bond_kind_set, bend_kind_set, ub_kind_set, torsion_kind_set, impr_kind_set, opbend_kind_set, nelectron, nsgf, molname_generated)
Set the components of a molecule kind.
Definition: molecule_kind_types.F:779

qs_kind_types
Define the quickstep kind type and their sub types.
Definition: qs_kind_types.F:23

qs_kind_types::get_qs_kind
subroutine, public get_qs_kind(qs_kind, basis_set, basis_type, ncgf, nsgf, all_potential, tnadd_potential, gth_potential, sgp_potential, upf_potential, se_parameter, dftb_parameter, xtb_parameter, dftb3_param, zeff, elec_conf, mao, lmax_dftb, alpha_core_charge, ccore_charge, core_charge, core_charge_radius, paw_proj_set, paw_atom, hard_radius, hard0_radius, max_rad_local, covalent_radius, vdw_radius, gpw_r3d_rs_type_forced, harmonics, max_iso_not0, max_s_harm, grid_atom, ngrid_ang, ngrid_rad, lmax_rho0, dft_plus_u_atom, l_of_dft_plus_u, n_of_dft_plus_u, u_minus_j, U_of_dft_plus_u, J_of_dft_plus_u, alpha_of_dft_plus_u, beta_of_dft_plus_u, J0_of_dft_plus_u, occupation_of_dft_plus_u, dispersion, bs_occupation, magnetization, no_optimize, addel, laddel, naddel, orbitals, max_scf, eps_scf, smear, u_ramping, u_minus_j_target, eps_u_ramping, init_u_ramping_each_scf, reltmat, ghost, floating, name, element_symbol, pao_basis_size, pao_potentials, pao_descriptors, nelec)
Get attributes of an atomic kind.
Definition: qs_kind_types.F:451

qs_kind_types::init_atom_electronic_state
subroutine, public init_atom_electronic_state(atomic_kind, qs_kind, ncalc, ncore, nelem, edelta)
...
Definition: qs_kind_types.F:3152

qs_kind_types::create_qs_kind_set
subroutine, public create_qs_kind_set(qs_kind_set, atomic_kind_set, kind_section, para_env, force_env_section)
Read an atomic kind set data set from the input file.
Definition: qs_kind_types.F:2600

qs_subsys_methods
Routines that work on qs_subsys_type.
Definition: qs_subsys_methods.F:12

qs_subsys_methods::qs_subsys_create
subroutine, public qs_subsys_create(subsys, para_env, root_section, force_env_section, subsys_section, use_motion_section, cp_subsys, cell, cell_ref, elkind)
Creates a qs_subsys. Optionally an existsing cp_subsys is used.
Definition: qs_subsys_methods.F:72

qs_subsys_types
types that represent a quickstep subsys
Definition: qs_subsys_types.F:12

qs_subsys_types::qs_subsys_set
subroutine, public qs_subsys_set(subsys, cp_subsys, local_particles, local_molecules, cell, cell_ref, use_ref_cell, energy, force, qs_kind_set, nelectron_total, nelectron_spin)
...
Definition: qs_subsys_types.F:226