| admm_methods | Contains methods used in the context of density fitting |
| admm_types | Types and set/get functions for auxiliary denisty matrix methods |
| admm_utils | Contains methods used in the context of density fitting |
| ai_angmom | Calculation of the angular momentum integrals over Cartesian Gaussian-type functions |
| ai_coulomb | Calculation of Coulomb integrals over Cartesian Gaussian-type functions (electron repulsion integrals, ERIs) |
| ai_coulomb_test | Test of Electron Repulsion Routines (ERI) |
| ai_derivatives | Calculate the first derivative of an integral block |
| ai_elec_field | Calculation of Coulomb integrals over Cartesian Gaussian-type functions (electron repulsion integrals, ERIs) |
| ai_eri_debug | Calculation of Coulomb integrals over Cartesian Gaussian-type functions (electron repulsion integrals, ERIs) |
| ai_fermi_contact | Calculation of the Fermi contact integrals over Cartesian Gaussian-type functions |
| ai_geminals | Calculation of Coulomb integrals over Correlated Cartesian Gaussian Geminals (electron repulsion integrals, ERIs) |
| ai_geminals_debug | Calculation of Coulomb integrals over Correlated Cartesian Gaussian Geminals (electron repulsion integrals, ERIs). This is a slow reference implementation for debugging perposes |
| ai_geminals_utils | Calculation of Coulomb integrals over Correlated Cartesian Gaussian Geminals (electron repulsion integrals, ERIs). Utility routines |
| ai_kinetic | Calculation of the kinetic energy integrals over Cartesian Gaussian-type functions |
| ai_moments | Calculation of the moment integrals over Cartesian Gaussian-type functions |
| ai_onecenter | |
| ai_oneelectron | Calculation of general three-center integrals over Cartesian Gaussian-type functions and a spherical operator centered at position C |
| ai_os_rr | |
| ai_overlap3 | |
| ai_overlap_new | Calculation of the overlap integrals over Cartesian Gaussian-type functions |
| ai_overlap_ppl | Calculation of three-center overlap integrals over Cartesian Gaussian-type functions for the second term V(ppl) of the local part of the Goedecker pseudopotential (GTH): |
| ai_spin_orbit | Calculation of spin orbit integrals over Cartesian Gaussian-type functions |
| ai_verfc | Build up the nuclear potential part of the core Hamiltonian matrix in the case of an allelectron calculation by computing the nuclear attraction integral matrix <a|-Z/r|b> and the integral matrix <a|Z*erf(r)/r|b>. The integrals <a|Z*erf(r)/r|b> can be rewritten as the three-center Coulomb integrals <ab||c> with a primitive s-type Gaussian function c multiplied by a factor N |
| al_system_dynamics | |
| al_system_init | |
| al_system_mapping | |
| al_system_types | Type for the canonical sampling through velocity rescaling |
| array_types | Array objects with reference counting |
| atom | |
| atom_basis | |
| atom_electronic_structure | |
| atom_energy | |
| atom_fit | Routines that fit parameters for /from atomic calculations |
| atom_kind_orbitals | Calculate the orbitals for a given atomic kind type |
| atom_operators | Calculate the atomic operator matrices |
| atom_optimization | Optimizer for the atomic code |
| atom_output | Routines that build the integrals of the Vxc potential calculated for the atomic code |
| atom_pseudo | |
| atom_types | Define the atom type and its sub types |
| atom_utils | Some basic routines for atomic calculations |
| atom_xc | Routines that build the integrals of the Vxc potential calculated for the atomic code |
| atomic_charges | Simple routine to print charges for all atomic charge methods (currently mulliken, lowdin and ddapc) |
| atomic_kind_list_types | Represent a simple array based list of the given type |
| atomic_kind_types | Define the atomic kind types and their sub types |
| atoms_input | |
| atprop_types | Holds information on atomic properties |
| averages_types | Handles the type to compute averages during an MD |
| barostat_types | Barostat structure: module containing barostat available for MD |
| barostat_utils | Barostat utils |
| basis_set_types | |
| bessel_lib | Calculates Bessel functions |
| beta_gamma_psi | |
| bfgs_optimizer | Routines for Geometry optimization using BFGS algorithm |
| bibliography | Collects all references to literature in CP2K as new algorithms / method are included from literature sources we add a citation, to give credit to the authors (often ourselves, but this need not to be the case), and as a form of documentation |
| block_p_types | Collect pointers to a block of reals |
| bsse | Module to perform a counterpoise correction (BSSE) |
| btree_i8_k_cp2d_v | B-tree implementation template |
| btree_i8_k_dp2d_v | B-tree implementation template |
| btree_i8_k_sp2d_v | B-tree implementation template |
| btree_i8_k_zp2d_v | B-tree implementation template |
| c_mpi_calls | Wrapper for various memory allocation methods and bindings |
| cell_opt | Performs CELL optimization |
| cell_opt_types | Contains type used for a Simulation Cell Optimization |
| cell_opt_utils | Functional that calculates the energy and its derivatives for the geometry optimizer |
| cell_types | Handles all functions related to the CELL |
| cg_optimizer | Routines for Geometry optimization using Conjugate Gradients |
| cg_test | Test of Clebsch-Gordon Coefficients |
| cg_utils | Utilities for Geometry optimization using Conjugate Gradients |
| colvar_methods | Defines collective variables s({R}) and the derivative of this variable wrt R these can then be used in constraints, restraints and metadynamics .. |
| colvar_types | Initialize the collective variables types |
| colvar_utils | Evaluations of colvar for internal coordinates schemes |
| constraint | |
| constraint_3x3 | |
| constraint_4x6 | |
| constraint_clv | Module that handles the COLLECTIVE constraints |
| constraint_fxd | |
| constraint_util | Contains routines useful for the application of constraints during MD |
| constraint_vsite | Routines to handle the virtual site constraint/restraint |
| core_ae | Calculation of the nuclear attraction contribution to the core Hamiltonian <a|erfc|b> :we only calculate the non-screened part |
| core_ppl | Calculation of the local pseudopotential contribution to the core Hamiltonian <a|V(local)|b> = <a|Sum e^a*rc**2|b> |
| core_ppnl | Calculation of the non-local pseudopotential contribution to the core Hamiltonian <a|V(non-local)|b> = <a|p(l,i)>*h(i,j)*<p(l,j)|b> |
| cp2k_debug | Debug energy and derivatives w.r.t. finite differences |
| cp2k_info | Some minimal info about CP2K, including its version and license |
| cp2k_runs | |
| cp_array_i4_sort | Routine for sorting an array |
| cp_array_i8_sort | Routine for sorting an array |
| cp_array_i_sort | Routine for sorting an array |
| cp_array_i_utils | Various utilities that regard array of different kinds: output, allocation,.. |
| cp_array_logical_utils | Various utilities that regard array of different kinds: output, allocation,.. |
| cp_array_r_sort | Routine for sorting an array |
| cp_array_r_utils | Various utilities that regard array of different kinds: output, allocation,.. |
| cp_array_utils | Wrapper for all the array utils |
| cp_blacs_calls | Wrappers for the actual blacs calls. all functionality needed in the code should actually be provide by cp_blacs_env these functions should be private members of that module |
| cp_blacs_env | Methods related to the blacs parallel environment |
| cp_cfm_basic_linalg | Basic linear algebra operations for complex full matrixes |
| cp_cfm_diag | Used for collecting some of the diagonalization shemes available for cp_cfm_type cp_fm_power also moved here as it is very related |
| cp_cfm_types | Represent a complex full matrix distribued on many processors |
| cp_control_types | Defines control structures, which contain the parameters and the settings for the DFT-based calculations |
| cp_control_utils | Utilities to set up the control types |
| cp_dbcsr_cholesky | Interface to (sca)lapack for the Cholesky based procedures |
| cp_dbcsr_diag | Interface to (sca)lapack for the Cholesky based procedures |
| cp_dbcsr_interface | DBCSR interface in CP2K |
| cp_dbcsr_methods | Methods for the CP2K DBCSR type |
| cp_dbcsr_operations | DBCSR operations in CP2K |
| cp_dbcsr_output | DBCSR output in CP2K |
| cp_dbcsr_types | DBCSR types in CP2K |
| cp_dbcsr_util | Helper routines for cp_dbcsr |
| cp_ddapc | Density Derived atomic point charges from a QM calculation (see Bloechl, J. Chem. Phys. Vol. 103 pp. 7422-7428) |
| cp_ddapc_forces | Density Derived atomic point charges from a QM calculation (see J. Chem. Phys. Vol. 103 pp. 7422-7428) |
| cp_ddapc_methods | Information regarding the decoupling/recoupling method of Bloechl |
| cp_ddapc_types | Information regarding the decoupling/recoupling method of Bloechl |
| cp_ddapc_util | Density Derived atomic point charges from a QM calculation (see Bloechl, J. Chem. Phys. Vol. 103 pp. 7422-7428) |
| cp_error_handling | Module that contains the routines for error handling The idea is that in general routines have an optional parameter that can be used to change the error behaviour |
| cp_external_control | Routines to handle the external control of CP2K |
| cp_files | Utility routines to open and close files. Tracking of preconnections |
| cp_fm_basic_linalg | Basic linear algebra operations for full matrixes |
| cp_fm_cholesky | Various cholesky decomposition related routines |
| cp_fm_diag | Used for collecting some of the diagonalization shemes available for cp_fm_type. cp_fm_power also moved here as it is very related |
| cp_fm_pool_types | Pool for for elements that are retained and released |
| cp_fm_struct | Represent the structure of a full matrix |
| cp_fm_types | Represent a full matrix distribued on many processors |
| cp_fm_vect | Routine to handle vectors of full matrixes |
| cp_iter_types | Collection of routines to handle the iteration info |
| cp_lbfgs | LBFGS-B routine (version 3.0, April 25, 2011) |
| cp_lbfgs_geo | Main driver for L-BFGS optimizer |
| cp_lbfgs_optimizer_gopt | Routines that optimize a functional using the limited memory bfgs quasi-newton method. The process set up so that a master runs the real optimizer and the others help then to calculate the objective function. The arguments for the objective function are physicaly present in every processor (nedeed in the actual implementation of pao). In the future tha arguments themselves could be distributed |
| cp_linked_list_3d_r | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_char | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_fm | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_int | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_logical | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_pw | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_real | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_rs | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_val | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_linked_list_xc_deriv | Describes a generic linked list template. Linked list are supposed to always use pointers to the nodes for basically everything: a pointer to the node is a list, an element of the list, an iterator between the elment of the list. An empty list is represented by an unassociated pointer |
| cp_log_handling | Various routines to log and control the output. The idea is that decisions about where to log should not be done in the code that generates the log, but should be globally changeable a central place. So some care has been taken to have enough information about the place from where the log comes so that in the future intelligent and flexible decisions can be taken by the logger, without having to change other code |
| cp_ma_interface | MACHINE ARCH interface in CP2K |
| cp_output_handling | Routines to handle the output, The idea is to remove the decision of wheter to output and what to output from the code that does the output, and centralize it here |
| cp_para_env | Type to store parallelization informations (at the moment assumes 1d position and uses mpi) |
| cp_para_types | Type to store parallelization informations (at the moment assumes 1d position and uses mpi). type def in this separate module to avoid circular ref |
| cp_parser_buffer_types | Module to allow simple buffering of read lines of a parser |
| cp_parser_ilist_methods | Module to allow simple internal preprocessing in input files |
| cp_parser_ilist_types | Module to allow simple internal preprocessing in input files |
| cp_parser_inpp_methods | Module to allow simple internal preprocessing in input files |
| cp_parser_inpp_types | Module to allow simple internal preprocessing in input files |
| cp_parser_methods | Utility routines to read data from files. Kept as close as possible to the old parser because 1. string handling is a weak point of fortran compilers, and it is easy to write correct things that do not work 2. conversion of old code |
| cp_parser_status_types | Module to allow the storage of the parser status |
| cp_parser_types | Utility routines to read data from files. Kept as close as possible to the old parser because 1. string handling is a weak point of fortran compilers, and it is easy to write correct things that do not work 2. conversion of old code |
| cp_result_methods | Set of type/routines to handle the storage of results in force_envs |
| cp_result_types | Set of type/routines to handle the storage of results in force_envs |
| cp_subsys_methods | Initialize a small environment for a particular calculation |
| cp_subsys_types | Types that represent a subsys, i.e. a part of the system |
| cp_symmetry | Work with symmetry |
| cp_units | Unit conversion facility |
| cpot_types | Makes a run that valuates the chemical potential difference between two different two box situations |
| csvr_system_dynamics | |
| csvr_system_init | |
| csvr_system_mapping | |
| csvr_system_types | Type for the canonical sampling through velocity rescaling |
| csvr_system_utils | |
| cube_utils | For a given dr()/dh(r) this will provide the bounds to be used if one wants to go over a sphere-subregion of given radius |
| cuda_memory | Routines involved in management of device memory when cuda support is enabled |
| d3_poly | Routines to efficently handle dense polynomial in 3 variables up to a given degree. Multiplication, partial evalution, affine transform (change of reference system), differentiation are efficiently implemented. some functions accept or return several polynomial together, these have to have all the same size, and are stored one after the other in an unique 1d array. This gives them an easy handling and even seem to be faster than the transposed layout |
| damping_dipole_types | |
| dbcsr_array_i4_sort | Routine for sorting an array |
| dbcsr_array_i8_sort | Routine for sorting an array |
| dbcsr_blas_operations | Wrappers to BLAS calls |
| dbcsr_block_access | DBCSR block access |
| dbcsr_block_buffers | Operations with block buffers |
| dbcsr_block_operations | Routines for basic block transformations |
| dbcsr_c_mpi_calls | Wrapper for various memory allocation methods and bindings |
| dbcsr_config | Configuration options for DBCSR |
| dbcsr_cuda_device | CUDA device support for DBCSR |
| dbcsr_cuda_memory | CUDA support for DBCSR |
| dbcsr_cuda_methods | CUDA support for DBCSR |
| dbcsr_cuda_operations | CUDA support for DBCSR |
| dbcsr_cuda_types | CUDA support for DBCSR |
| dbcsr_data_methods | DBCSR data methods |
| dbcsr_data_operations | DBCSR data operations |
| dbcsr_dist_operations | DBCSR operations on distributions |
| dbcsr_error_handling | |
| dbcsr_index_operations | Operations on the DBCSR index |
| dbcsr_io | DBCSR input/output |
| dbcsr_iterator_operations | DBCSR iterator operations |
| dbcsr_kinds | Defines the basic variable types |
| dbcsr_machine | |
| dbcsr_message_passing | Interface to the message passing library MPI |
| dbcsr_methods | Base methods on DBCSR data structures |
| dbcsr_mm_cannon | First layer of the dbcsr matrix-matrix multiplication. It performs the MPI parallelization according to Cannon's algorithm |
| dbcsr_mm_csr | Third layer of the dbcsr matrix-matrix multiplication. It collects the full matrix blocks, which need to be multiplied, and stores their parameters in various stacks. After a certain amount of parameters is collected it dispatches the filled stacks to either the CPU or the GPU |
| dbcsr_mm_driver | Fourth layer of the dbcsr matrix-matrix multiplication. It hides the differences between performing calculations on the GPU or the CPU |
| dbcsr_mm_multrec | Second layer of the dbcsr matrix-matrix multiplication. It divides the multiplication in a cache-oblivious manner |
| dbcsr_mm_stack | Stacks of small matrix multiplications |
| dbcsr_mm_types | Datatypes used by the dbcsr matrix-matrix multiplication machinery |
| dbcsr_mp_operations | Wrappers to message passing calls |
| dbcsr_operations | Higher-level operations on DBCSR matrices |
| dbcsr_performance_multiply | Performance for DBCSR multiply |
| dbcsr_plasma_interface | Interface to PLASMA |
| dbcsr_ptr_util | DBCSR pointer and unmanaged array utilities |
| dbcsr_test_add | Tests for DBCSR add |
| dbcsr_test_methods | Tests for CP2K DBCSR operations |
| dbcsr_test_multiply | Tests for DBCSR multiply |
| dbcsr_tests | Tests for CP2K DBCSR operations |
| dbcsr_toollib | Tools usually found in a standard library |
| dbcsr_transformations | DBCSR transformations |
| dbcsr_types | DBCSR data types |
| dbcsr_util | DBCSR sparse matrix utility routines |
| dbcsr_work_operations | DBCSR work matrix utilities |
| dft_plus_u | Add the DFT+U contribution to the Hamiltonian matrix |
| dg_rho0_types | |
| dg_types | |
| dgs | |
| dict | A common interface for all instances of dict__keytype___valuetype_.template |
| dict_i4tuple_callstat | A dictionary (also known as hashtable or hashmap). Internally the dictionary uses an array to holds its data. If this array reaches a load-factor of 75%, a new array with twice the size will be allocated and the items are then copied over. This ensures that the dictionary will perform operations in O(1) |
| dict_str_i4 | A dictionary (also known as hashtable or hashmap). Internally the dictionary uses an array to holds its data. If this array reaches a load-factor of 75%, a new array with twice the size will be allocated and the items are then copied over. This ensures that the dictionary will perform operations in O(1) |
| dimer_methods | Contains types used for a Dimer Method calculations |
| dimer_types | Contains types used for a Dimer Method calculations |
| dimer_utils | Contains utilities for a Dimer Method calculations |
| distribution_1d_types | Stores a lists of integer that are local to a processor. The idea is that these integers represent objects that are distributed between the different processors. The ordering is just to make some operation more efficent, logically these lists are like sets. Some operations assume that the integers represent a range of values from 1 to a (not too big) maxval, and that an element is present just once, and only on a processor (these assumption are marked in the documentation of such operations). The concrete task for which this structure was developed was distributing atoms between the processors |
| distribution_2d_types | Stores a mapping of 2D info (e.g. matrix) on a 2D processor distribution (i.e. blacs grid) where cpus in the same blacs row own the same rows of the 2D info (and similar for the cols) |
| distribution_methods | Distribution methods for atoms, particles, or molecules |
| distribution_optimize | Optimizes the parallel distribution trying to minimize a cost function |
| dkh_main | |
| dm_ls_chebyshev | Routines using linear scaling chebyshev methods |
| dm_ls_scf | Routines for a linear scaling quickstep SCF run based on the density matrix |
| dm_ls_scf_curvy | Density matrix optimization using exponential transformations |
| dm_ls_scf_methods | Lower level routines for linear scaling SCF |
| dm_ls_scf_qs | Routines for a linear scaling quickstep SCF run based on the density matrix, with a focus on the interface between dm_ls_scf and qs |
| dm_ls_scf_types | Types needed for a linear scaling quickstep SCF run based on the density matrix |
| dummy_c_bindings | Dummy C bindings |
| efield_utils | All routins needed for a nonperiodic electric field |
| eigenvalueproblems | Provides interfaces to LAPACK eigenvalue/SVD routines |
| eip_environment | Methods and functions on the EIP environment |
| eip_environment_types | The environment for the empirical interatomic potential methods |
| eip_main | Main program which drives the EIP calculation |
| eip_silicon | Empirical interatomic potentials for Silicon |
| elpa1 | |
| elpa2 | |
| elpa_pdgeqrf | |
| elpa_pdlarfb | |
| environment | Sets up and terminates the global environment variables |
| ep_methods | In this module there are the routines for the calculation of psi and energy without scf, but perturbatively as in PRL 87(22);226401; 26 Nov 2001,"Accurate Total Energies without Self-Consistency", David M. Benoit, Daniel Sebastiani, and Michele Parrinello |
| ep_qs_methods | Methods that change a qs calculation to perform an ep calculation |
| ep_qs_types | Types for the modifications of the qs calculation to perform an ep calculation |
| ep_types | Types needed for the calculation of the enrgy with perturbation |
| erf_fn | Calculates error function and complementary error function |
| et_coupling | Calculates the electron transfer coupling elements Wu, Van Voorhis, JCP 125, 164105 (2006) |
| et_coupling_types | Definition and initialisation of the et_coupling data type |
| ewald_environment_types | |
| ewald_pw_methods | Pw_methods |
| ewald_pw_types | Pw_types |
| ewald_spline_util | |
| ewalds | |
| ewalds_multipole | Treats the electrostatic for multipoles (up to quadrupoles) |
| exclusion_types | Exclusion type |
| extended_system_dynamics | |
| extended_system_init | |
| extended_system_mapping | |
| extended_system_types | Lumps all possible extended system variables into one type for easy access and passing |
| external_potential_methods | Methods to include the effect of an external potential during an MD or energy calculation |
| external_potential_types | Definition of the atomic potential types |
| f77_blas | This module is the real poisoning for BLAS. To avoid I/O issues at compiling time it is better to avoid the inclusion of the f77_blas_extra and f77_blas_generic into this module and include them directly in the needed modules. This reduces a lot the compile time on several machines.. See f77_blas_netlib, f77_blas_poison and f77_blas_generic for further comments |
| f77_blas_extra | |
| f77_blas_generic | |
| f77_blas_netlib | |
| f77_blas_poison | |
| f77_interface | Interface to use cp2k as library |
| farming_methods | |
| farming_types | |
| fermi_utils | Deal with the Fermi distribution, compute it, fix mu, get derivs |
| fft_kinds | Defines the basic variable types |
| fft_plan | Type to store data about a (1D or 3D) FFT, including FFTW plan |
| fft_tools | |
| fist_energy_types | |
| fist_environment | Initialize fist environment |
| fist_environment_types | |
| fist_force | |
| fist_intra_force | |
| fist_main | Perform classical molecular dynamics and path integral simulations |
| fist_neighbor_list_control | |
| fist_neighbor_list_types | Define the neighbor list data types and the corresponding functionality |
| fist_neighbor_lists | Generate the atomic neighbor lists for FIST |
| fist_nonbond_env_types | |
| fist_nonbond_force | |
| fist_pol_scf | |
| force_env_methods | Interface for the force calculations |
| force_env_types | Interface for the force calculations |
| force_env_utils | Util force_env module |
| force_field_types | Define all structures types related to force_fields |
| force_fields | |
| force_fields_all | |
| force_fields_ext | |
| force_fields_input | |
| force_fields_util | |
| fp_methods | Methods used in the flexible partitioning scheme |
| fp_types | Types used in the flexible partitioning scheme |
| fparser | |
| free_energy_methods | Methods to perform free energy and free energy derivatives calculations |
| free_energy_types | Defines types for metadynamics calculation |
| ga_environment_types | Module that collects GA functionality for semi-empirical |
| gamma | Calculation of the incomplete Gamma function F_n(t) for multi-center integrals over Cartesian Gaussian functions |
| gauss_colloc | Routines to efficently collocate and integrate gaussians on a grid These use most of Joost's tricks and a couple more... result is *speed* and genericity |
| gaussian_gridlevels | |
| geo_opt | Performs geometry optimization |
| gle_system_dynamics | |
| gle_system_types | |
| glob_matching | |
| global_types | Represent the global information of a run: the input file, parallel environment (and partially output). Use sparingly, try not to send it too deep in your structures |
| gopt_f_methods | Functional that calculates the energy and its derivatives for the geometry optimizer |
| gopt_f_types | Functional that calculates the energy and its derivatives for the geometry optimizer |
| gopt_param_types | Typo and related routines to handle parameters controlling the GEO_OPT module |
| graphcon | Uses a combination of graphs and hashing to determine if two molecules are topologically equivalent, and if so, finds the one by one mapping |
| harris_energy_types | The Harris energy type, which contains all the informations needed to perform and analyse the Harris functional energy correction |
| harris_env_types | The Harris environment, which contains beside the harris energy and force types all the informations needed to perform and analyse the Harris functional energy and force corrections |
| harris_force | Performs the Harris functional force correction |
| harris_force_types | The Harris force , which contains all the informations needed to perform and analyse the Harris functional force correction |
| harris_functional | Performs the Harris functional energy correction |
| hartree_local_methods | |
| hartree_local_types | |
| header | |
| helium_common | Independent helium subroutines shared by other modules |
| helium_interactions | Methods that handle helium-solvent and helium-helium interactions |
| helium_io | I/O subroutines for helium |
| helium_methods | Methods dealing with helium_solvent_type |
| helium_sampling | Methods for sampling helium variables |
| helium_types | Data types representing superfluid helium |
| hfx_admm_utils | Utilities for hfx and admm methods |
| hfx_communication | Routines for data exchange between MPI processes |
| hfx_compression_core_methods | Contains routines for data compression. PLEASE DO NOT MODIFY |
| hfx_compression_methods | Routines and types for Hartree-Fock-Exchange |
| hfx_contract_block | Routines to contract density matrix blocks with the for center integrals to yield the Kohn-Sham matrix. The specialized routines are about 1.2-2.0 as fast as the default one |
| hfx_contraction_methods | Contains routines for contraction without dgemms. PLEASE DO NOT MODIFY. Contains specific routines for contraction. The compiler flag -D__MAX_CONTR defines the maximum angular momentum up to which specialized code will be used. Default setting is d-functions. Increasing -D__MAX_CONTR produces faster code but might overburden the optimization capabilities of some poor compilers. This file contains specific code up to g-functions. If you need more look at cp2k/tools/hfx_tools/contraction/ |
| hfx_derivatives | Routines to calculate derivatives with respect to basis function origin |
| hfx_energy_potential | Rountines to calculate HFX energy and potential |
| hfx_helpers | Some auxiliary functions and subroutines needed for HFX calculations |
| hfx_libint_interface | Interface to the Libint-Library |
| hfx_libint_wrapper | Interface to the Libint-Library or a c++ wrapper |
| hfx_libint_wrapper_types | Provides types that are used to interface with the libint library |
| hfx_load_balance_methods | Rountines for optimizing load balance between processes in HFX calculations |
| hfx_pair_list_methods | Rountines for optimizing load balance between processes in HFX calculations |
| hfx_ri_gemopt | Optimizer for geminal basis sets |
| hfx_ri_methods | Master routines for the Hartree-Fock RI Method |
| hfx_screening_methods | Several screening methods used in HFX calcualtions |
| hfx_types | Types and set/get functions for HFX |
| input_constants | Collects all constants needed in input so that they can be used without circular dependencies |
| input_cp2k | Builds the input structure for cp2k |
| input_cp2k_atom | Builds the input structure for the ATOM module |
| input_cp2k_atprop | Input section for atomic properties |
| input_cp2k_barostats | |
| input_cp2k_binary_restarts | Routines to read the binary restart file of CP2K |
| input_cp2k_check | Checks the input and perform some automatic "magic" on it |
| input_cp2k_colvar | |
| input_cp2k_constraints | |
| input_cp2k_dft | Function that build the dft section of the input |
| input_cp2k_distribution | Function that builds the distribution section of the input |
| input_cp2k_eip | Creates the EIP section of the input |
| input_cp2k_force_eval | Builds the input structure for the FORCE_EVAL section of cp2k |
| input_cp2k_free_energy | |
| input_cp2k_hfx | Function that builds the hartree fock exchange section of the input |
| input_cp2k_mixed | Builds the input structure for the MIXED environment |
| input_cp2k_mm | Creates the mm section of the input |
| input_cp2k_motion | |
| input_cp2k_mp2 | Input section for MP2 |
| input_cp2k_poisson | Function that build the poisson section of the input |
| input_cp2k_properties_dft | Function that build the dft section of the input |
| input_cp2k_qmmm | Creates the qmmm section of the input |
| input_cp2k_resp | Function that builds the resp section of the input |
| input_cp2k_restarts | Set of routines to dump the restart file of CP2K |
| input_cp2k_rsgrid | |
| input_cp2k_subsys | Builds the subsystem section of the input |
| input_cp2k_thermostats | |
| input_cp2k_vib | Builds the input structure for the VIBRATIONAL_ANALYSIS module |
| input_cp2k_xc | Function that build the xc section of the input |
| input_enumeration_types | Enumeration, i.e. a mapping between integers and strings |
| input_keyword_types | Keywords in an input |
| input_optimize_basis | Builds the input structure for optimize_basis |
| input_optimize_input | Builds the input structure for optimize_input |
| input_parsing | Routines that parse the input |
| input_section_types | Objects that represent the structure of input sections and the data contained in an input section |
| input_val_types | Wrapper for basic fortran types |
| integrator | Provides integrator routines (velocity verlet) for all the ensemble types |
| integrator_utils | Provides integrator utility routines for the integrators |
| iterate_matrix | Routines useful for iterative matrix calculations |
| k290 | K-points and crystal symmetry routines |
| kahan_sum | Sums arrays of real/complex numbers with *much* reduced round-off as compared to a naive implementation (or the one found in most compiler's SUM intrinsic) using an implementation of Kahan's algorithm for summing real numbers that can be used instead of the standard Fortran SUM(array[,mask]) |
| kg_correction | Routines for a Kim-Gordon-like partitioning into molecular subunits |
| kg_environment | Routines for a Kim-Gordon-like partitioning into molecular subunits |
| kg_environment_types | Types needed for a for a Kim-Gordon-like partitioning into molecular subunits |
| kg_min_heap | |
| kg_vertex_coloring_methods | Routines for a Kim-Gordon-like partitioning into molecular subunits unsing a vertex coloring algorithm (DSATUR) to find non-interating subsets, such that two molecules within the same subset have small/zero overlap (in other words: this molecular pair is not present in the neighborlist sab_orb for the current value of EPS_DEFAULT) |
| kinds | Defines the basic variable types |
| lapack | Interface to the LAPACK F77 library |
| lazy | Filters for interpolating scaling functions |
| lebedev | Generation of the spherical Lebedev grids. All Lebedev grids were generated with a precision of at least 33 digits (Mathematica). Thus the Lebedev abscissas and weights are accurate to 32 digits (quadruple precision) |
| lgrid_types | Scratch space for multiple threads writing to rs grids (see qs_collocate_density.F for an example |
| lib_kinds | Defines the basic variable types |
| library_tests | Performance tests for basic tasks like matrix multiplies, copy, fft |
| libxc_funcs_m | Correspondence between the functional name and identifier |
| linear_systems | Provides interfaces to LAPACK routines for factorisation and linear system solving |
| list | A common interface for all instances of list__valuetype_.template |
| list_callstackentry | An array-based list which grows on demand. When the internal array is full, a new array of twice the size will be allocated and the items are copied over |
| list_routinestat | An array-based list which grows on demand. When the internal array is full, a new array of twice the size will be allocated and the items are copied over |
| list_timerenv | An array-based list which grows on demand. When the internal array is full, a new array of twice the size will be allocated and the items are copied over |
| lri_environment_methods | Calculates integral matrices for lripaw method lri : local resolution of the identity |
| lri_environment_types | Types and subroutines for dealing with the lri_env lri : local resolution of the identity |
| ma_affinity | Affinity support for cp2k |
| ma_config | Configuration options for Machine Architecture |
| ma_dummy_c_bindings | Dummy C bindings |
| ma_errors | Machine Hardware support for cp2k |
| ma_kinds | Defines the basic variable types |
| ma_process_mapping | Process mapping support for cp2k |
| ma_topology | Network topology support for cp2k |
| machine | |
| machine_architecture | Machine Hardware support for cp2k |
| machine_architecture_types | Machine Hardware support for cp2k |
| machine_architecture_utils | Machine Hardware support for cp2k |
| machine_g95 | |
| manybody_eam | |
| manybody_potential | |
| manybody_siepmann | |
| manybody_tersoff | |
| mathconstants | Definition of mathematical constants and functions |
| mathlib | Collection of simple mathematical functions and subroutines |
| mc_control | Some general routines for dealing with the restart files and creating force_env for MC use |
| mc_coordinates | Miscellaneous subroutines used in the Monte Carlo runs,mostly geared towards changes in coordinates |
| mc_ensembles | Used to run the bulk of the MC simulation, doing things like choosing move types and writing data to files |
| mc_environment_types | Subroutines for dealing with the mc_env |
| mc_ge_moves | Monte Carlo moves that can handle more than one box, including the Quickstep move, a volume swap between boxes, and a particle swap between boxes |
| mc_misc | Miscellaneous subroutines used in the Monte Carlo runs, mostly I/O stuff |
| mc_move_control | Control the handling of the move data in Monte Carlo (MC) simulations |
| mc_moves | Various moves in Monte Carlo (MC) simulations, including change of internal conformation, translation of a molecule, rotation of a molecule, and changing the size of the simulation box |
| mc_run | Preps the system for a Monte Carlo run (sets up some environments, calls the routines to read in the MC parameters)...converted from qs_mc.F |
| mc_types | Holds all the structure types needed for Monte Carlo, except the mc_environment_type |
| md_conserved_quantities | Computes the conserved quantities for a given md ensemble and also kinetic energies, thermo/barostat stuff |
| md_ener_types | Split md_ener module from md_environment_type |
| md_energies | Prints all energy info per timestep to the screen or to user defined output files |
| md_environment_types | |
| md_run | Perform a molecular dynamics (MD) run using QUICKSTEP |
| md_util | Utilities for Molecular Dynamics |
| md_vel_utils | Collection of utilities for setting-up and handle velocities in MD runs |
| memory_utilities | Utility routines for the memory handling. Uses stop_memory to handle exceptions |
| message_passing | Interface to the message passing library MPI |
| metadynamics | Performs the metadynamics calculation |
| metadynamics_types | Defines types for metadynamics calculation |
| metadynamics_utils | Performs the metadynamics calculation |
| min_heap | |
| minimax | Routines to calculate the minimax coefficients in order to approximate 1/x as a sum over exponential functions 1/x ~ SUM_{i}^{K} w_i EXP(-a_i * x) for x belonging to [1:Rc] |
| mixed_energy_types | |
| mixed_environment | Initialize mixed environment |
| mixed_environment_types | |
| mixed_environment_utils | Util mixed_environment |
| mixed_main | Perform biased molecular dynamics (H= k H1 + (1-k) H2 [linear or general mixing) |
| mltfftsg_tools | |
| mm_collocate_potential | Calculate the MM potential by collocating the primitive Gaussian functions (pgf) |
| mm_mapping_library | Contains the mapping ATOM_KIND -> ELEMENT for the most common cases in CHARMM and AMBER This should avoid in most cases the need to provide the element column in the PDB if in the atom_name column of the PDB is provided instead the atom kind |
| mode_selective | Module performing a mdoe selective vibrational analysis |
| mol_force | |
| mol_kind_new_list_types | Represent a simple array based list of the given type |
| mol_new_list_types | Represent a simple array based list of the given type |
| molden_utils | Functions handling the MOLDEN format. Split from mode_selective |
| molecular_states | Routines for the calculation of molecular states |
| molecule_kind_types | Define the molecule kind structure types and the corresponding functionality |
| molecule_types_new | Define the data structure for the molecule information |
| molsym | Molecular symmetry routines |
| moments_utils | Calculates the moment integrals <a|r^m|b> |
| motion_utils | Output Utilities for MOTION_SECTION |
| mp2 | Rountines to calculate MP2 energy |
| mp2_direct_method | Rountines to calculate MP2 energy |
| mp2_gpw | Rountines to calculate MP2 energy using pw |
| mp2_laplace | Rountines to calculate MP2 energy with laplace approach |
| mp2_ri_gpw | Rountines to calculate RI-GPW-MP2 energy using pw |
| mp2_setup | Types needed for MP2 calculations |
| mp2_types | Types needed for MP2 calculations |
| mt_util | |
| mulliken | Compute mulliken charges we (currently) define them as c_i = 1/2 [ (PS)_{ii} + (SP)_{ii} ] |
| multipole_types | Multipole structure: for multipole (fixed and induced) in FF based MD |
| neb_io | I/O Module for Nudged Elastic Band Calculation |
| neb_md_utils | Module with utility to perform MD Nudged Elastic Band Calculation |
| neb_methods | Module performing a Nudged Elastic Band Calculation |
| neb_opt_utils | Module with utility to perform MD Nudged Elastic Band Calculation |
| neb_types | Typo for Nudged Elastic Band Calculation |
| neb_utils | Module with utility for Nudged Elastic Band Calculation |
| optbas_fenv_manipulation | |
| optbas_opt_utils | |
| optimize_basis | |
| optimize_basis_types | |
| optimize_basis_utils | |
| optimize_input | |
| orbital_pointers | Provides Cartesian and spherical orbital pointers and indices |
| orbital_symbols | Orbital_symbols |
| orbital_transformation_matrices | Calculation of the spherical harmonics and the corresponding orbital transformation matrices |
| pair_potential | |
| pair_potential_coulomb | |
| pair_potential_types | |
| pair_potential_util | |
| parallel_rng_types | Parallel (pseudo)random number generator (RNG) for multiple streams and substreams of random numbers |
| particle_list_types | Represent a simple array based list of the given type |
| particle_types | Define the data structure for the particle information |
| paw_proj_set_types | |
| periodic_table | Periodic Table related data definitions |
| physcon | Definition of physical constants: |
| pint_gle | Methods to apply GLE to PI runs |
| pint_io | I/O subroutines for pint_env |
| pint_methods | Methods to performs a path integral run |
| pint_normalmode | Data type and methods dealing with PI calcs in normal mode coords |
| pint_public | Public path integral routines that can be called from other modules |
| pint_staging | Data type and methods dealing with PI calcs in staging coordinates |
| pint_transformations | |
| pint_types | |
| pme | |
| pme_tools | Tools common both to PME and SPME |
| population_analyses | Provide various population analyses and print the requested output information |
| powell | |
| preconditioner | Computes preconditioners, and implements methods to apply them currently used in qs_ot |
| preconditioner_types | Types of preconditioners |
| ps_wavelet_base | Creates the wavelet kernel for the wavelet based poisson solver |
| ps_wavelet_fft3d | |
| ps_wavelet_kernel | Creates the wavelet kernel for the wavelet based poisson solver |
| ps_wavelet_scaling_function | Creates the wavelet kernel for the wavelet based poisson solver |
| ps_wavelet_types | Definition and initialisation of the ps_wavelet data type |
| ps_wavelet_util | Performs a wavelet based solution of the Poisson equation |
| pw_env_methods | Methods of pw_env that have dependence on qs_env |
| pw_env_types | Container for various plainwaves related things |
| pw_grid_info | This module returns additional info on PW grids |
| pw_grid_types | |
| pw_grids | This module defines the grid data type and some basic operations on it |
| pw_methods | |
| pw_methods_cuda | |
| pw_poisson_methods | |
| pw_poisson_types | Functions related to the poisson solver on regular grids |
| pw_pool_types | Manages a pool of grids (to be used for example as tmp objects), but can also be used to instantiate grids that are never given back |
| pw_spline_utils | Different utils that are useful to manipulate splines on the regular grid of a pw |
| pw_types | |
| qmmm_elpot | |
| qmmm_ff_fist | |
| qmmm_force_mixing | Routines used for force-mixing QM/MM calculations |
| qmmm_gaussian_data | GEEP coefficients for fixed radii. THIS IS THE GEEP LIB. They can be used together with the "omotetia" rule for erf function to obtain the expansion for whatever radius one desires Radius value are in Angstrom |
| qmmm_gaussian_init | Initialize the use of the gaussians to treat the QMMM coupling potential |
| qmmm_gaussian_input | Set the QMMM Gaussian Input Environment |
| qmmm_gaussian_types | Sets the typo for the gaussian treatment of the qm/mm interaction |
| qmmm_gpw_energy | A collection of methods to treat the QM/MM electrostatic coupling |
| qmmm_gpw_forces | Routines to compute energy and forces in a QM/MM calculation |
| qmmm_image_charge | Routines for image charge calculation within QM/MM |
| qmmm_init | Initialize a QM/MM calculation |
| qmmm_links_methods | A collection of methods to treat the QM/MM links |
| qmmm_main | Initialize a QM/MM calculation |
| qmmm_per_elpot | |
| qmmm_pw_grid | Sets variables for the qmmm pool of pw_types |
| qmmm_se_energy | Calculation of the QMMM Hamiltonian integral matrix <a| q_i|b> for semi-empirical methods |
| qmmm_se_forces | Calculation of the derivative of the QMMM Hamiltonian integral matrix <a| q_i|b> for semi-empirical methods |
| qmmm_topology_util | |
| qmmm_types | |
| qmmm_util | |
| qs_block_davidson_types | Module that contains the algorithms to perform an itrative diagonalization by the block-Davidson approach P. Blaha, et al J. Comp. Physics, 229, (2010), 453-460 diagonalization in augmented plane wave based methods in electronic structure calculations |
| qs_charges_types | Container for information about total charges on the grids |
| qs_collocate_density | Calculate the plane wave density by collocating the primitive Gaussian functions (pgf) |
| qs_conductivity | Should be able to compute the optical conductivity |
| qs_core_energies | Calculation of the energies concerning the core charge distribution |
| qs_core_hamiltonian | Calculation of the core Hamiltonian integral matrix <a|H|b> over Cartesian Gaussian-type functions |
| qs_density_mixing_types | Module that contains the definitions of the scf types |
| qs_dftb_coulomb | Calculation of Coulomb contributions in DFTB |
| qs_dftb_dispersion | Calculation of dispersion in DFTB |
| qs_dftb_matrices | Calculation of Overlap and Hamiltonian matrices in DFTB |
| qs_dftb_parameters | |
| qs_dftb_types | Definition of the DFTB parameter types |
| qs_dftb_utils | Working with the DFTB parameter types |
| qs_diis | Apply the direct inversion in the iterative subspace (DIIS) of Pulay in the framework of an SCF iteration for convergence acceleration |
| qs_diis_types | Buffer for the diis of the scf |
| qs_dispersion_nonloc | Calculation of non local dispersion functionals Some routines adapted from: Copyright (C) 2001-2009 Quantum ESPRESSO group Copyright (C) 2009 Brian Kolb, Timo Thonhauser - Wake Forest University This file is distributed under the terms of the GNU General Public License. See the file `License' in the root directory of the present distribution, or http://www.gnu.org/copyleft/gpl.txt |
| qs_dispersion_pairpot | Calculation of dispersion using pair potentials |
| qs_dispersion_types | Definition of disperson types for DFT calculations |
| qs_efield_berry | Calculates the energy contribution and the mo_derivative of a static periodic electric field |
| qs_elec_field | Distribution of the electric field gradient integral matrix |
| qs_electric_field_gradient | Calculates electric field gradients H.M. Petrili, P.E. Blochl, P. Blaha, K. Schwarz, PRB 57, 14690 (1998) |
| qs_energy | Perform a QUICKSTEP wavefunction optimization (single point) |
| qs_energy_types | |
| qs_environment | |
| qs_environment_methods | Qs_environement methods that use many other modules |
| qs_environment_types | |
| qs_epr_hyp | Calculates hyperfine values |
| qs_external_potential | Routines to handle an external electrostatic field The external field can be generic and is provided by user input |
| qs_fermi_contact | Distribution of the Fermi contact integral matrix |
| qs_force | Quickstep force driver routine |
| qs_force_types | |
| qs_gapw_densities | |
| qs_geminals | Rountines to calculate Geminal integrals |
| qs_grid_atom | |
| qs_gspace_mixing | |
| qs_harmonics_atom | |
| qs_initial_guess | Routines to somehow generate an intial guess |
| qs_integrate_potential | Build up the plane wave density by collocating the primitive Gaussian functions (pgf) |
| qs_integrate_potential_low | |
| qs_interactions | Calculate the interaction radii for the operator matrix calculation |
| qs_kinetic | Calculation of kinetic energy matrix, its derivatives and forces |
| qs_kpp1_env_methods | Module that builds the second order perturbation kernel kpp1 = delta_rho|_P delta_rho|_P E drho(P1) drho |
| qs_kpp1_env_types | Basis types for the calculation of the perturbation of density theory |
| qs_ks_apply_restraints | Set of routines to apply restraints to the KS hamiltonian |
| qs_ks_atom | Routines that build the Kohn-Sham matrix contributions coming from local atomic densities |
| qs_ks_methods | Routines that build the Kohn-Sham matrix (i.e calculate the coulomb and xc parts |
| qs_ks_qmmm_methods | |
| qs_ks_qmmm_types | |
| qs_ks_scp_methods | |
| qs_ks_scp_types | |
| qs_ks_types | |
| qs_linres_atom_current | Given the response wavefunctions obtained by the application of the (rxp), p, and ((dk-dl)xp) operators, here the current density vector (jx, jy, jz) is computed for the 3 directions of the magnetic field (Bx, By, Bz) |
| qs_linres_current | Given the response wavefunctions obtained by the application of the (rxp), p, and ((dk-dl)xp) operators, here the current density vector (jx, jy, jz) is computed for the 3 directions of the magnetic field (Bx, By, Bz) |
| qs_linres_current_utils | Chemical shift calculation by dfpt Initialization of the nmr_env, creation of the special neighbor lists Perturbation Hamiltonians by application of the p and rxp oprtators to psi0 Write output Deallocate everything |
| qs_linres_epr_nablavks | Calculates Nabla V_KS (local part if PSP) on the different grids |
| qs_linres_epr_ownutils | |
| qs_linres_epr_utils | G tensor calculation by dfpt Initialization of the epr_env, creation of the special neighbor lists Perturbation Hamiltonians by application of the p and rxp oprtators to psi0 Write output Deallocate everything |
| qs_linres_issc_utils | Chemical shift calculation by dfpt Initialization of the issc_env, creation of the special neighbor lists Perturbation Hamiltonians by application of the p and rxp oprtators to psi0 Write output Deallocate everything |
| qs_linres_methods | Localize wavefunctions linear response scf |
| qs_linres_module | Contains the setup for the calculation of properties by linear response by the application of second order density functional perturbation theory. The knowledge of the ground state energy, density and wavefunctions is assumed. Uses the self consistent approach. Properties that can be calculated : none |
| qs_linres_nmr_epr_common_utils | Given the response wavefunctions obtained by the application of the (rxp), p, and ((dk-dl)xp) operators, here the current density vector (jx, jy, jz) is computed for the 3 directions of the magnetic field (Bx, By, Bz) |
| qs_linres_nmr_shift | From the response current density calculates the shift tensor and the susceptibility |
| qs_linres_nmr_utils | Chemical shift calculation by dfpt Initialization of the nmr_env, creation of the special neighbor lists Perturbation Hamiltonians by application of the p and rxp oprtators to psi0 Write output Deallocate everything |
| qs_linres_op | Calculate the operators p rxp and D needed in the optimization of the different contribution of the firs order response orbitals in a epr calculation |
| qs_linres_types | Type definitiona for linear response calculations |
| qs_loc_methods | Driver for the localization that should be general for all the methods available and all the definition of the spread functional Write centers, spread and cubes only if required and for the selected states The localized functions are copied in the standard mos array for the next use |
| qs_loc_molecules | Set of routines handling the localization for molecular properties |
| qs_loc_types | New version of the module for the localization of the molecular orbitals This should be able to use different definition of the spread functional It should also calculate the integrals analytically so that it can be used irrespective of the pw_env and the collocation of wfn on the grids It should also work with a selected set of states, instead than all of them, in this case one should check that the selected states have the same occupation number The spread functional can be only estimated, or also optimized by minimization and in principle also maximization should be available. This operations can be required irrespective of the printing requirements It would be highly desirable to do all this along a MD run every N steps, and have a trajectory of the centeroids of the localized wfn In addition these functions can be used for properties calculations like NMR and XAS. Therefore it is necessary that the rotated wfn are then copied in the mos fm matrix to be available for next use |
| qs_loc_utils | Some utilities for the construction of the localization environment |
| qs_local_rho_types | |
| qs_localization_methods | Localization methods such as 2x2 Jacobi rotations Steepest Decents Conjugate Gradient |
| qs_main | Perform a LCGTO-SCF-DF calculation using the Gaussian plane wave (GPW) method |
| qs_matrix_pools | Wrapper for the pools of matrixes |
| qs_mo_methods | Collects routines that perform operations directly related to MOs |
| qs_mo_types | Definition and initialisation of the mo data type |
| qs_modify_pab_block | Set of procedures to modify the density matrix, in order to collocate on the real space grid specific functions of the primitives |
| qs_moments | Calculates the moment integrals <a|r^m|b> and <a|r x d/dr|b> |
| qs_neighbor_list_types | Define the neighbor list data types and the corresponding functionality |
| qs_neighbor_lists | Generate the atomic neighbor lists |
| qs_oce_methods | Routines for the construction of the coefficients for the expansion of the atomic densities rho1_hard and rho1_soft in terms of primitive spherical gaussians |
| qs_oce_types | |
| qs_operators_ao | |
| qs_ot | Orbital transformations |
| qs_ot_eigensolver | Eigen-space solver for the generalised symmetric eigenvalue problem for sparse matrices, needing only multiplications |
| qs_ot_minimizer | Orbital transformations |
| qs_ot_scf | Basic functionality for using ot in the scf routines |
| qs_ot_types | Orbital transformations |
| qs_outer_scf | Routines for performing an outer scf loop |
| qs_overlap | Calculation of overlap matrix, its derivatives and forces |
| qs_p_env_methods | Utility functions for the perturbation calculations |
| qs_p_env_types | Basis types for the calculation of the perturbation of density theory |
| qs_p_sparse_psi | Utilities to represent orbitals that are localized on few atoms |
| qs_pdos | Calculation and writing of projected density of states The DOS is computed per angular momentum and per kind |
| qs_period_efield_types | Type for berry phase efield matrices. At the moment only used for cosmat and sinmat |
| qs_resp | Resp fit for gas phase systems |
| qs_rho0_ggrid | |
| qs_rho0_methods | |
| qs_rho0_types | |
| qs_rho_atom_methods | |
| qs_rho_atom_types | |
| qs_rho_methods | Methods of the rho structure (defined in qs_rho_types) |
| qs_rho_types | Superstucture that hold various representations of the density and keeps track of which ones are valid |
| qs_scf | Routines for the Quickstep SCF run |
| qs_scf_block_davidson | Module that contains the algorithms to perform an itrative diagonalization by the block-Davidson approach P. Blaha, et al J. Comp. Physics, 229, (2010), 453-460 diagonalization in augmented plane wave based methods in electronic structure calculations |
| qs_scf_diagonalization | Different diagonalization schemes that can be used for the iterative solution of the eigenvalue problem |
| qs_scf_lanczos | Module that contains the algorithms to perform an itrative diagonalization by the block-Lanczos approach |
| qs_scf_methods | Groups fairly general SCF methods, so that modules other than qs_scf can use them too split off from qs_scf to reduce dependencies |
| qs_scf_post_dftb | Does all kind of post scf calculations for DFTB |
| qs_scf_post_gpw | Does all kind of post scf calculations for GPW/GAPW |
| qs_scf_post_se | Does all kind of post scf calculations for semi-empirical |
| qs_scf_types | Module that contains the definitions of the scf types |
| qs_spin_orbit | Distribution of the spin orbit integral matrix |
| qs_tddfpt_eigensolver | |
| qs_tddfpt_module | Performs density functional perturbation theory (tddfpt) calculations. Uses the self consistent approach. The tddfpt calculation uses the ground state of the unperturbed system as the initial state |
| qs_tddfpt_types | |
| qs_tddfpt_utils | |
| qs_util | All kind of helpfull little routines |
| qs_vxc | |
| qs_vxc_atom | Routines that build the integrals of the Vxc potential calculated for the atomic density in the basis set of spherical primitives |
| qs_wf_history_methods | Storage of past states of the qs_env. Methods to interpolate (or actually normally extrapolate) the new guess for density and wavefunctions |
| qs_wf_history_types | Interpolate the wavefunctions to speed up the convergence when doing MD |
| realspace_grid_cube | Generate Gaussian cube files |
| realspace_grid_types | |
| reference_manager | Uniform framework to add references to CP2K cite and output these |
| reftraj_types | Initialization of the reftraj structure used to analyse previously generated trajectories |
| reftraj_util | Initialize the analysis of trajectories to be done by activating the REFTRAJ ensemble |
| rel_control_types | Parameters that control a relativistic calculation |
| replica_methods | Methods to setup replicas of the same system differing only by atom positions and velocities (as used in path integral or nudged elastic band for example) |
| replica_types | Types used to handle many replica of the same system that differ only in atom positions, and velocity. This is useful for things like path integrals or nudged elastic band |
| restraint | Handles all possible kinds of restraints in CP2K |
| ri_environment_types | Types and subroutines for dealing with the ri_env ri : resolution of the identity |
| rmsd | Defines functions to perform rmsd in 3D |
| rpa_communication | Auxiliary rountines necessary to redistribute an fm_matrix from a given blacs_env to another |
| rpa_ri_gpw | Rountines to calculate RI-RPA energy |
| rt_make_propagators | Routines for calculating a complex matrix exponential |
| rt_matrix_exp | Routines for calculating a complex matrix exponential |
| rt_propagation | Routines for the real time propagation |
| rt_propagation_methods | Routines for propagating the orbitals |
| rt_propagation_output | Routine for the real time propagation output |
| rt_propagation_types | Types and set_get for real time propagation depending on runtype and diagonalization method different matrices are allocated exp_H_old, exp_H_new, mos_new, mos_old contain always real and imaginary parts of the matrices odd index = real part (alpha, beta spin) even index= imaginary part (alpha, beta spin) |
| rt_propagation_utils | Routines needed for EMD |
| rt_propagator_init | Routines for the prepares teh matrices for the propagators |
| rtp_admm_methods | Utilities for rtp in combination with admm methods adapted routines from admm_method (author Manuel Guidon) |
| s_square_methods | Methods related to S**2 (ie. spin) |
| sap_kind_types | General overlap type integrals containers |
| scf_control_types | Parameters that control an scf iteration |
| scp_coeff_types | Define the data structure for the auxilliary basis SCP coefficents |
| scp_delta_fock_matrix | Module that collects all Coulomb parts of the fock matrix construction |
| scp_density_methods | Calculate the SPC plane wave density by collocating the primitive Gaussian functions (pgf). Also computes the integral of the potential with a density in the primitive gaussian basis |
| scp_diis_utils | |
| scp_dispersion | Perform the calculation of the dispersion contributions for the SCP method |
| scp_energy | Scp_energy minim routine |
| scp_energy_types | |
| scp_environment | Initialize scp environment |
| scp_environment_methods | To complete the setup of the scp_env |
| scp_environment_types | |
| scp_fock_matrix_integrals | Provides the low level routines to build Coulomb Fock matrices for SCP |
| scp_force_types | |
| scp_hartree_1center | Perform the calculation of the hartree 1 center 3 electron self-interaction terms for the SCP method |
| scp_nddo_utils | Calculation of the SCP specific terms for semi-empirical methods |
| scp_restarts | Routine handling the collection of the restart information for the SCP |
| scp_rho_methods | Rho_methods |
| scp_rho_types | Rho_types |
| scp_rspw_methods | Set the SCP real-space plane-wave environment |
| scp_rspw_types | |
| scptb_core_interactions | SCPTB short range repulsive core interaction |
| scptb_core_matrix | Calculation of the Hamiltonian integral and Overlap matrices <a|b> and <a|T+V|b> for SCP-TB methods |
| scptb_ks_matrix | Calculation of Hamiltonian matrices in SCPTB |
| scptb_parameters | Default parameter sets for SCPTB method key, atomname key, atomic name z, zeff atomic number, core charge lmaxorb, lmaxscp max l basis, max l polarization norb number of orbitals (0,1,2,3) zeta exponents of orbitals (0,1,2,3) hcore two body terms occupation orbital occupation in free atom energy total energy of free atom crep core repulsion terms (1=a,2=c,3=d) pol polarization constants (1,2,3) ag Gaussian exponents |
| scptb_types | Definition of the SCPTB parameter types |
| scptb_utils | Routines for SCPTB |
| se_core_core | Split and build its own idependent core_core SE interaction module |
| se_core_matrix | Calculation of the Hamiltonian integral matrix <a|H|b> for semi-empirical methods |
| se_fock_matrix_control | Controls the construction of the fock matrix with GA or MPI |
| se_fock_matrix_coulomb_ga | Module that collects all Coulomb parts of the fock matrix construction |
| se_fock_matrix_coulomb_mpi | Module that collects all Coulomb parts of the fock matrix construction |
| se_fock_matrix_dbg | |
| se_fock_matrix_exchange | Construction of the Exchange part of the Fock Matrix |
| se_fock_matrix_ga | Calculation of the Fock matrix for SE methods |
| se_fock_matrix_integrals | Provides the low level routines to build both the exchange and the Coulomb Fock matrices.. This routines support d-orbitals and should be changed only if one knows exactly what he is doing. |
| se_fock_matrix_mpi | Calculation of the Fock matrix for SE methods |
| se_ga_tools | Module that collects GA functionality for semi-empirical |
| semi_empirical_expns3_methods | Methods for handling the 1/R^3 residual integral part |
| semi_empirical_expns3_types | Definition of the type to handle the 1/R^3 residual integral part |
| semi_empirical_int3_utils | Utilities for evaluating the residual part (1/r^3) of Integrals for semi-empiric methods |
| semi_empirical_int_ana | Analytical derivatives of Integrals for semi-empirical methods |
| semi_empirical_int_arrays | Arrays of parameters used in the semi-empirical calculations Everywhere in this module TCA stands for:
- TCA: W. Thiel and A. A. Voityuk - Teor. Chim. Acta (1992) 81:391-404
- TCA77: M.J.S. Dewar and W. Thiel - Teor. Chim. Acta (1977) 46:89-104
|
| semi_empirical_int_gks | Integral GKS scheme: The order of the integrals in makeCoul reflects the standard order by MOPAC |
| semi_empirical_int_num | Integrals for semi-empiric methods |
| semi_empirical_int_utils | Utilities for Integrals for semi-empiric methods |
| semi_empirical_integrals | Set of wrappers for semi-empirical analytical/numerical Integrals routines |
| semi_empirical_mpole_methods | Setup and Methods for semi-empirical multipole types |
| semi_empirical_mpole_types | Definition of the semi empirical multipole integral expansions types |
| semi_empirical_par_utils | Utilities to post-process semi-empirical parameters |
| semi_empirical_parameters | Default parameter sets for semi empirical models: sep%... ass, asp, app, a.u. parameters for the SCP-NDDO calculations ad, am, aq, a.u. parameters for the multipole approximation to dd, qq a.u. the two-centre, two-electron integrals. alp A**(-1) the exponents used to calculate the core-core repulsion terms. beta eV parameters for the two-centre, one-electron core resonance integrals. z the CORE charge on each element. eheat kcal/mol the experimental heat of formation for each element. eisol eV the calculated electronic energies for each element. fn1 A*eV AM1/PM3 specific parameters fn2 A**(-2) for the core-core repulsion fn3 A interaction. pre eV PDDG function d A PDDG function bfn1-3 special core-core interactions |
| semi_empirical_store_int_types | Type to store integrals for semi-empirical calculations |
| semi_empirical_types | Definition of the semi empirical parameter types |
| semi_empirical_utils | Working with the semi empirical parameter types |
| shell_opt | |
| shell_potential_types | |
| simpar_methods | Methods for storing MD parameters type |
| simpar_types | Type for storing MD parameters |
| soft_basis_set | |
| spherical_harmonics | Calculate spherical harmonics |
| splines_methods | Routines for handling splines |
| splines_types | Routines for handling splines_types |
| spme | Calculate the electrostatic energy by the Smooth Particle Ewald method |
| statistical_methods | Methods to perform on the fly statistical analysis of data -) Schiferl and Wallace, J. Chem. Phys. 83 (10) 1985 |
| stm_images | Calculation of STM image as post processing of an electronic structure calculation, |
| sto_ng | |
| string_table | Generates a unique id number for a string (str2id) that can be used two compare two strings. I.e. if (str1==str2) => str2id(str1)==str2id(str2) if (str1.NE.str2) => str2id(str1).NE.str2id(str2) and the other way around. Given an id, the string can be retrieved |
| string_utilities | Utilities for string manipulations |
| structure_factor_types | |
| structure_factors | |
| subcell_types | Subcell types and allocation routines |
| t_c_g0 | |
| t_sh_p_s_c | |
| tamc_run | Perform a temperature accelarated hybrid monte carlo (TAHMC) run using QUICKSTEP |
| taper_types | Definition of the semi empirical parameter types |
| task_list_methods | Generate the tasks lists used by collocate and integrate routines |
| task_list_types | Types for task lists |
| termination | Perform an abnormal program termination |
| thermal_region_types | Thermal regions type: to initialize and control the temperature of different regions |
| thermal_region_utils | Setup of regions with different temperature |
| thermostat_mapping | |
| thermostat_methods | Methods for Thermostats |
| thermostat_types | Thermostat structure: module containing thermostat available for MD |
| thermostat_utils | Utilities for thermostats |
| timings | Timing routines for accounting |
| timings_base_type | Types used by timings.F and timings_report.F The types in this module are used within dict or list, which are in turn used in timer_env_type from timings_type.F Due to the fortran restriction on cicular module-dependencies these "inner-types" had to go into a separate module |
| timings_report | Timing routines for accounting |
| timings_types | Types used by timings.F and timings_report.F Due to the fortran restriction on cicular module-dependencies the types, which are used through dict or list had to go into the separate module timings_base_type.F |
| topology | Control for reading in different topologies and coordinates |
| topology_amber | Handles all functions used to read and interpret AMBER coordinates and topology files |
| topology_cif | Handles CIF (Crystallographic Information File) files |
| topology_connectivity_util | Collection of subroutine needed for topology related things |
| topology_constraint_util | Collection of subroutine needed for topology related things |
| topology_coordinate_util | Collection of subroutine needed for topology related things |
| topology_cp2k | |
| topology_generate_util | Collection of subroutine needed for topology related things |
| topology_gromos | |
| topology_input | Reads the input sections "topology" |
| topology_multiple_unit_cell | Handles the multiple unit cell option regarding atomic coordinates |
| topology_pdb | Handles PDB files |
| topology_psf | Functionality to read in PSF topologies and convert it into local data structures |
| topology_types | |
| topology_util | Collection of subroutine needed for topology related things |
| topology_xtl | Handles XTL (Molecular Simulations, Inc (MSI)) files |
| topology_xyz | |
| tum_utils | |
| util | All kind of helpfull little routines |
| velocity_verlet_control | Provides an interface to the velocity-verlet based integrator routines for all ensembles |
| vibrational_analysis | Module performing a vibrational analysis |
| virial_methods | |
| virial_types | |
| wannier_states | Routines for the calculation of wannier states |
| wannier_states_types | Defines the type needed for computing wannier states expectations |
| whittaker | Calculates special integrals |
| wiener_process | Handling of the Wiener process currently employed in turn of the Langevin dynamics |
| xas_control | Defines control structures, which contain the parameters and the settings for the calculations |
| xas_env_types | Define create destroy get and put information in xas_env to calculate the x-ray absorption spectra |
| xas_methods | Driver for the xas calculation and xas_scf for the tp method |
| xas_restart | Initialize the XAS orbitals for specific core excitations Either the GS orbitals are used as initial guess, or the xas mos are read from a previous calculation. In the latter case, the core-hole potetial should be the same |
| xas_tp_scf | Xas_scf for the tp method It is repeaated for every atom that have to be excited |
| xc | Exchange and Correlation functional calculations |
| xc_adiabatic_methods | Contains some functions used in the context of adiabatic hybrid functionals |
| xc_adiabatic_utils | |
| xc_atom | |
| xc_b97 | Calculates the b97 correlation functional |
| xc_cs1 | Calculate the CS1 Functional (Handy s improved LYP functional) |
| xc_derivative_desc | Module with functions to handle derivative descriptors. derivative description are strings have the following form "(rho)(rho)(rhoa)" which means that it is a forth order derivative, twice with respect to rho, once with respect to rhoa and once with respect to drhoa. Possible derivatives are:
- rho: total density
- norm_drho: norm of the gradient of the total density
- rhoa, rhob: alpha and beta spin density (with LSD)
- norm_drhoa, norm_drhob: norm of the gradient of the alpha and beta spin density
- drhoa_drhob: scalar product between the gradient of rhoa and the grandient of rhob
- tau: the local kinetic part
- taua, taub: the kinetic part of the different spins
|
| xc_derivative_set_types | Represent a group ofunctional derivatives |
| xc_derivative_types | Provides types for the management of the xc-functionals and their derivatives |
| xc_derivatives | |
| xc_exchange_gga | Calculate several different exchange energy functionals with a GGA form |
| xc_f90_lib_m | |
| xc_f90_types_m | |
| xc_functionals_utilities | Utility routines for the functional calculations |
| xc_hcth | Calculate the Hamprecht, Cohen, Tozer, and Handy (HCTH) exchange functional |
| xc_ke_gga | Calculate the several different kinetic energy functionals with a GGA form |
| xc_libxc | Calculates a functional from libxc and its derivatives |
| xc_lyp | Calculates the lyp correlation functional |
| xc_lyp_adiabatic | Calculates the density_scaled Lyp functional when used in adiabatic hybrids. The energy is given as |
| xc_optx | Calculate optx |
| xc_pade | Calculate the LDA functional in the Pade approximation Literature: S. Goedecker, M. Teter and J. Hutter, Phys. Rev. B 54, 1703 (1996) |
| xc_pbe | Calculates the pbe correlation functional |
| xc_perdew86 | Calculate the Perdew Correlation from 1986 |
| xc_perdew_wang | Calculate the Perdew-Wang correlation potential and energy density and ist derivatives with respect to the spin-up and spin-down densities up to 3rd order |
| xc_perdew_zunger | Calculate the Perdew-Zunger correlation potential and energy density and ist derivatives with respect to the spin-up and spin-down densities up to 3rd order |
| xc_pot_saop | Calculate the saop potential |
| xc_rho_cflags_types | Structure |
| xc_rho_set_types | Structure |
| xc_tfw | Calculate the Thomas-Fermi kinetic energy functional plus the von Weizsaecker term |
| xc_thomas_fermi | Calculate the Thomas-Fermi kinetic energy functional |
| xc_tpss | Calculates the tpss functional |
| xc_vwn | Calculate the LDA functional according to Vosk, Wilk and Nusair Literature: S. H. Vosko, L. Wilk and M. Nusair, Can. J. Phys. 58, 1200 (1980) |
| xc_xalpha | Calculate the local exchange functional |
| xc_xbecke88 | Calculates the Becke 88 exchange functional |
| xc_xbecke88_long_range | Calculates the longrange part of Becke 88 exchange functional |
| xc_xbecke88_lr_adiabatic | Calculates the density_scaled BECKE88 long-range functional when used in adiabatic hybrids. The energy is given as |
| xc_xbecke_roussel | Calculates the exchange energy based on the Becke-Roussel exchange hole. Takes advantage of an analytical representation of the hole in order to avoid solving a non-linear equation by means of Newton- Raphson algorithm |
| xc_xbr_pbe_lda_hole_t_c_lr | This functional is a combination of three different exchange hole models. The ingredients are: |
| xc_xlda_hole_t_c_lr | Calculates the lda exchange hole in a truncated coulomb potential. Can be used as longrange correction for truncated hfx calculations |
| xc_xpbe_hole_t_c_lr | Calculates the exchange energy for the pbe hole model in a truncated coulomb potential, considering the long range part only. Can be used as longrange correction to a truncated Hartree Fock calculation |
| xc_xwpbe | Calculates short range exchange part for wPBE functional and averaged PBE exchange-hole functional (omega = 0.0 ) |
| xml_parser | |
| xray_diffraction | |
