This is an fully open source solvation model, based on the original conductor like screening model for realistic solvation (COSMO-RS) model by Klamt et al. in combination with the universal solvation model based on solute electron density (SMD) by Marenich, Cramer and Truhlar.
While there are also parameters in this repository, that are optimized for running this library with ORCA and TURBOMOLE, the published version of this model was built to be run with the semi-empirical GFN2-xTB method. However, the final goal of this project is to deliver a robust open-source solvation framework, which can be reparametrized for the method of choice.
The method is published in The Journal of Physical Chemistry.
CPCM-X is built to be used as a library in Fortran projects. To be able to use this project, as a library, a few steps have to be taken beforehand. In this section, you will find an example implementation of CPCM-X, based on our implementation into the xTB source code.
First, we created a new module and load the necessary components from the CPCM-X source code. We also setup a new type (Tcpcmx
) and extend the original calculation type provided by CPCM-X with a few additional procedures.
module xtb_solv_cpx
use cpx, only: calculation_type, parameter_type, atomicmass, density,&
&initialize_param,load_solvent,read_cosmo
use xtb_solv_cosmo, only: TCosmo
use iso_fortran_env, only: input_unit, output_unit
use mctc_env, only: error_type, fatal_error, wp
implicit none
type, extends(calculation_type) :: TCpcmx
contains
procedure :: setup => setup_cpcmx
procedure :: calc_solv => calculate_cpcmx
procedure :: print => print
end type Tcpcmx
contains
In the setup procedure, we setup the right parametrisation for our method (xTB
), and load the specified solvent from an internal database. If you would use this with an unknown or new method, you would need to load the solvent using the read_cosmo
routine (same as the solute). Next, the solute is loaded from the xtb.cosmo
file created by xTB.
subroutine setup_cpcmx(self, solvent)
implicit none
!> CPCM-X Calculation type
class(Tcpcmx), intent(inout) :: self
!> Solvent for internal parameter loading
character(len=*), intent(in) :: solvent
!> Error handling
type(error_type), allocatable :: error
!> Initialize the CPCM-X parametrisation from the internal xtb database.
call initialize_param('xtb',solvent,self,error)
!> Load a solvent from the internal xTB solvent database (you could also use read_cosmo for the solvent)
call load_solvent(solvent,self%solvent,error)
!> Load the solute from a .cosmo file
Call read_cosmo('xtb.cosmo',self%solute,'NONE',error)
!> Error handling
if (allocated(error)) Call raise('E',error%message)
end subroutine setup_cpcmx
Now, the interesting part begins: The calculation of the various parts of the solvation free energy. We setup the necessary prerequisites (like probe radius and temperature) and average the charges. Afterwards we determine the bonding situation (e.g. for the ring correction) and calculate the restoring free energy, the state correction and the CDS
part of the solvation free energy.
subroutine calculate_cpcmx(self,solvent,probe,T,max_cycle,conv_crit)
implicit none
!> CPCM-X calculation type
class(Tcpcmx), intent(inout) :: self
!> Name of the solvent for property loading
character(len=*), intent(in) :: solvent
!> Error handling
type(error_type), allocatable :: error
!> Probe Radius for SASA Term, Temperature and convergence criteria for COSMO-RS part
real(wp), intent(in) :: probe
real(wp), intent(in) :: T
integer, intent(in) :: max_cycle
real(wp), intent(in) :: conv_crit
!> Charge averaging
call self%average_charge(error)
!> Bonding determination
call self%init_bonding()
!> restoring free energy
call self%solv('crs',error,T,max_cycle,conv_crit)
!> Error handling
if (allocated(error)) Call raise('E',error%message)
!> State correction
call self%state_correction(density(solvent),atomicmass(self%solvent%element),T)
!> SMD-CDS part
call self%cds(probe,solvent)
end subroutine calculate_cpcmx
All necessary components of the solvation free energy, as well as the solvation free energy itself should then be saved in the calculation type. You should be able to print it, for example like this:
subroutine print(self)
implicit none
class(Tcpcmx), intent(in) :: self
real(wp), parameter :: autokcal=627.509_wp
write(output_unit,'(4x,a)') repeat('-',73)
write(output_unit,'(5x,a,t55,a,t66,a)') &
"Free Energy contributions:", "[Eh]", " [kcal/mol]"
write(output_unit,'(5x,a,t50,E13.5,t65,F10.5)') &
"Ideal State (dG_is):", self%dG_is, self%dG_is*autokcal, &
"Averaging correction (dG_av):", self%dG_cc, self%dG_cc*autokcal, &
"restoring free energy (dG_res):", self%dG_res, self%dG_res*autokcal, &
"SMD Contribution (dG_CDS):", self%dG_smd, self%dG_smd*autokcal, &
"Standard state correction (dG_corr):", self%dG_ss, self%dG_ss*autokcal, &
"Systematic empirical shift (dG_shift)", self%dG_shift, self%dG_shift*autokcal
write(output_unit,'(4x,a)') repeat('-',73)
write(output_unit,'(5x,a,t50,E13.5,t65,F10.5)') &
"solvation free energy: ", self%dG(), self%dG()*autokcal
write(output_unit,*) ""
end subroutine print
end module xtb_solv_cpx
You can also use a release binary, but for compatibility, it is recommended to build this project by yourself from source. To do that, you need to clone the repository to your local environment.
git clone https://github.com/grimme-lab/CPCM-X.git
cd CPCM-X
The recommended version for building this project is using Meson.
You can also use Meson to build your project. To be able to do that, you need version 0.60 or newer. To use the default backend, you also need ninja in version 1.7 or newer.
meson setup build --buildtype release
ninja -C build
You afterwards have to manually install the created binary in the path of your choice.
You can also use the Fortran Package Manager to build this project. Building should be as simple as using
fpm build
You can also include this project as dependency in your package manifest fpm.toml
as
[dependencies]
cpx.git = "https://github.com/grimme-lab/CPCM-X"
You can either use a commandline version of CPCM-X
or create a detailed input for your calculation.
To use the commandline version of CPCM-X
, you have to set up an CPXHOME
environment variable.
export CPXHOME=[path]
In the home directory, you need to place a configuration file, as well as the parameters and the COSMO
file database.
If you clone the repository, the commandline version should work out of the box, if you set the CPXHOME
Variable to the cloned repository.
Otherwise, you can create a new sample configuration file and set up the home directory for yourself.
cpx --newconfig
The commandline version needs a coord
file for your solute and a working version of xTB
or another supported QC package.
You can then start a calculation (starting from the coord file) for example by
cpx --solvent water
You can also set up an input file. CPCM-X
needs cosmo files for the solute and the solvent. You can create a sample input by
cpx --newinput
You then need to manually specify which parameters you want to use, as well as the respective cosmo files. You can start the calculation by
cpx cpx.input