Prerequisites and dependencies¶

A number of prerequisites and dependencies are to be satisfied to successfully build the module. It will be here assumed that you want to perform a “full” build, i.e. you want to build the static libraries to be linked to your QM program, the unit test suite and an offline copy of this documentation.

Configuration¶

Configuration is managed through the front-end script setup residing in the repository main directory. Issuing:

./setup [options] [build path]

will create the build directory in build path and run CMake with the given options. By default, files are configured in the build directory. The -h or –help option will list the available options and their effect. Options can be forwarded directly to CMake by using the –cmake-options flag and listing the -D... options. Usually the following command is sufficient to get the configuration done for a debug build, including compilation of the unit test suite:

./setup --type=debug

The unit tests suite is always compiled in standalone mode, unless the -DENABLE_TESTS=OFF option is forwarded to CMake.

cd path/to/boost
./bootstrap.sh --prefix=/home/user-name/boost

./b2 install

./setup --boost-headers=/home/user-name/boost/include --boost-libs=/home/user-name/boost/lib

./setup -DBOOST_INCLUDEDIR=/home/user-name/boost/include -DBOOST_LIBRARYDIR=/home/user-name/boost/lib

Build and test¶

To compile and link, just go to the build directory and run:

make -j N

where N is the number of cores you want to use when building.

To run the whole test suite:

ctest -j N

You can also use CTest to run a specific test or a set of tests. For example:

ctest -R gepol

will run all the test containing the string “gepol” in their name.

If Doxygen was found, an offline copy of this documentation can be built by:

make doc

and visualized by opening the doc/html/index.html file in your browser.

Input style¶

The input for PCMSolver is parsed through the Getkw library written by Jonas Juselius and is organized in sections and keywords. Input reading is case-insensitive. An example input structure is shown below, there are also some working examples in the directory examples. A general input parameter has the following form (Keyword = [Data type]):

Units = [String]
CODATA = [Integer]
Cavity {
       Type = [String]
       NpzFile = [String]
       Area = [Double]
       Scaling = [Bool]
       RadiiSet = [String]
       MinRadius = [Double]
       Mode = [String]
       Atoms = [Array of Integers]
       Radii = [Array of Doubles]
       Spheres = [Array of Doubles]
}
Medium {
       Solvent = [String]
       SolverType = [String]
       MatrixSymm = [Bool]
       Correction = [Double]
       ProbeRadius = [Double]
       Green<GreenTag> {
             Type = [String]
             Der = [String]
             Eps = [Double]
             EpsDyn = [Double]
             Eps1 = [Double]
             EpsDyn1 = [Double]
             Eps2 = [Double]
             EpsDyn2 = [Double]
             Center = [Double]
             Width = [Double]
             InterfaceOrigin = [Array of Doubles]
             MaxL = [Integer]
       }
}

Array-valued keywords will expect the array to be given in comma-separated format and enclosed in square brackets. The purpose of tags is to distinguish between cases in which multiple instances of the same kind of object can be managed by the program. There exist only certain legal tagnames and these are determined in the C++ code. Be aware that the input parsing script does not check the correctness of tags.

Top section keywords¶

Units

Units of measure used in the input file. If Angstrom is given, all relevant input parameters are first converted in au and subsequently parsed.

• Type: string
• Valid values: AU | Angstrom
• Default: No Default

CODATA

Set of fundamental physical constants to be used in the module.

• Type: integer
• Valid values: 2010 | 2006 | 2002 | 1998
• Default: 2010

Cavity section keywords¶

Type

The type of the cavity. Completely specifies type of molecular surface and its discretization. Only one type is allowed. Restart cavity will read the file specified by NpzFile keyword and create a GePol cavity from that.

• Type: string
• Valid values: GePol | Restart
• Default: none

NpzFile

The name of the .npz file to be used for the GePol cavity restart.

• Type: string
• Default: empty string

Area

Average area (weight) of the surface partition for the GePol (TsLess) cavity.

• Type: double
• Valid values: \(d \geq 0.01\,\text{a.u.}^2\)
• Valid for: GePol cavity
• Default value: \(0.3\,\text{a.u.}^2\)

Scaling

If true, the radii for the spheres will be scaled by 1.2. For finer control on the scaling factor for each sphere, select explicit creation mode.

• Type: bool
• Valid for: all cavities except Restart
• Default value: True

RadiiSet

Select set of atomic radii to be used. Currently Bondi-Mantina [Bondi64][MantinaChamberlinValero+09] and UFF [RCC+92] sets available, see Available radii.

• Type: string
• Valid values: Bondi | UFF
• Valid for: all cavities except Restart
• Default value: Bondi

MinRadius

Minimal radius for additional spheres not centered on atoms. An arbitrarily big value is equivalent to switching off the use of added spheres, which is the default.

• Type: double
• Valid values: \(d \geq 0.4\,\text{a.u.}\)
• Valid for: GePol cavity
• Default value: \(100.0\,\text{a.u.}\)

Mode

How to create the list of spheres for the generation of the molecular surface:

• in Implicit mode, the atomic coordinates and charges will be obtained from the QM host program. Spheres will be centered on the atoms and the atomic radii, as specified in one the built-in sets, will be used. Scaling by 1.2 will be applied according to the keyword Scaling;
• in Atoms mode, the atomic coordinates and charges will be obtained from the QM host program. For the atoms specified by the array given in keyword Atoms, the built-in radii will be substituted by the radii provided in the keyword Radii. Scaling by 1.2 will be applied according to the keyword Scaling;
• in Explicit mode, both centers and radii of the spheres are to be specified in the keyword Spheres. The user has full control over the generation of the list of spheres. Scaling by 1.2 is not applied, regardless of the value of the Scaling keyword.

• Type: string
• Valid values: Implicit | Atoms | Explicit
• Valid for: all cavities except Restart
• Default value: Implicit

Atoms

Array of atoms whose radius has to be substituted by a custom value.

• Type: array of integers
• Valid for: all cavities except Restart

Radii

Array of radii replacing the built-in values for the selected atoms.

• Type: array of doubles
• Valid for: all cavities except Restart

Spheres

Array of coordinates and centers for construction of the list of spheres in explicit mode. Format is \([\ldots, x_i, y_i, z_i, R_i, \ldots]\)

• Type: array of doubles
• Valid for: all cavities except Restart

Medium section keywords¶

SolverType

Type of solver to be used. All solvers are based on the Integral Equation Formulation of the Polarizable Continuum Model [CancesMennucci98]

• IEFPCM. Collocation solver for a general dielectric medium
• CPCM. Collocation solver for a conductor-like approximation to the dielectric medium

• Type: string
• Valid values: IEFPCM | CPCM
• Default value: IEFPCM

Nonequilibrium

Initializes an additional solver using the dynamic permittivity. To be used in response calculations.

• Type: bool
• Valid for: all solvers
• Default value: False

Solvent

Specification of the dielectric medium outside the cavity. This keyword must always be given a value. If the solvent name given is different from Explicit any other settings in the Green’s function section will be overridden by the built-in values for the solvent specified. See Table Available solvents for details. Solvent = Explicit, triggers parsing of the Green’s function sections.

• Type: string

• Valid values:

  • Water , H2O;
  • Methanol , CH3OH;
  • Ethanol , CH3CH2OH;
  • Chloroform , CHCL3;
  • Methylenechloride , CH2CL2;
  • 1,2-Dichloroethane , C2H4CL2;
  • Carbon Tetrachloride, CCL4;
  • Benzene , C6H6;
  • Toluene , C6H5CH3;
  • Chlorobenzene , C6H5CL;
  • Nitromethane , CH3NO2;
  • N-heptane , C7H16;
  • Cyclohexane , C6H12;
  • Aniline , C6H5NH2;
  • Acetone , C2H6CO;
  • Tetrahydrofurane , THF;
  • Dimethylsulfoxide , DMSO;
  • Acetonitrile , CH3CN;
  • Explicit.

MatrixSymm

If True, the PCM matrix obtained by the IEFPCM collocation solver is symmetrized \(\mathbf{K} := \frac{\mathbf{K} + \mathbf{K}^\dagger}{2}\)

• Type: bool
• Valid for: IEFPCM solver
• Default: True

Correction

Correction, \(k\) for the apparent surface charge scaling factor in the CPCM solver \(f(\varepsilon) = \frac{\varepsilon - 1}{\varepsilon + k}\)

• Type: double
• Valid values: \(k > 0.0\)
• Valid for: CPCM solver
• Default: 0.0

DiagonalIntegrator

Type of integrator for the diagonal of the boundary integral operators

• Type: string
• Valid values: COLLOCATION
• Valid for: IEFPCM, CPCM
• Default: COLLOCATION
• Notes: in future releases we will add PURISIMA and NUMERICAL as options

DiagonalScaling

Scaling factor for diagonal of collocation matrices

• Type: double
• Valid values: \(f > 0.0\)
• Valid for: IEFPCM, CPCM
• Default: 1.07
• Notes: values commonly used in the literature are 1.07 and 1.0694

ProbeRadius

Radius of the spherical probe approximating a solvent molecule. Used for generating the solvent-excluded surface (SES) or an approximation of it. Overridden by the built-in value for the chosen solvent.

• Type: double
• Valid values: \(d \in [0.1, 100.0]\,\text{a.u.}\)
• Valid for: all solvers
• Default: 1.0

Green section keywords¶

If Solvent = Explicit, two Green’s functions sections must be specified with tags inside and outside, i.e. Green<inside> and Green<outside>. The Green’s function inside will always be the vacuum, while the Green’s function outside might vary.

Type

Which Green’s function characterizes the medium.

• Type: string
• Valid values: Vacuum | UniformDielectric | SphericalDiffuse
• Default: Vacuum

Der

How to calculate the directional derivatives of the Green’s function:

• Numerical, perform numerical differentiation debug option;
• Derivative, use automatic differentiation to get the directional derivative;
• Gradient, use automatic differentiation to get the full gradient debug option;
• Hessian, use automatic differentiation to get the full hessian debug option;

• Type: string
• Valid values: Numerical | Derivative | Gradient | Hessian
• Default: Derivative

Note

The spherical diffuse Green’s function always uses numerical differentiation.

Eps

Static dielectric permittivity of the medium

• Type: double
• Valid values: \(\varepsilon \geq 1.0\)
• Default: 1.0

EpsDyn

Dynamic dielectric permittivity of the medium

• Type: double
• Valid values: \(\varepsilon \geq 1.0\)
• Default: 1.0

rofile

Functional form of the dielectric profile

• Type: string
• Valid values: Tanh | Erf
• Valid for: SphericalDiffuse
• Default: Tanh

Eps1

Static dielectric permittivity inside the interface

• Type: double
• Valid values: \(\varepsilon \geq 1.0\)
• Default: 1.0

EpsDyn1

Dynamic dielectric permittivity inside the interface

• Type: double
• Valid values: \(\varepsilon \geq 1.0\)
• Default: 1.0

Eps2

Static dielectric permittivity outside the interface

• Type: double
• Valid values: \(\varepsilon \geq 1.0\)
• Default: 1.0

EpsDyn2

Dynamic dielectric permittivity outside the interface

• Type: double
• Valid values: \(\varepsilon \geq 1.0\)
• Default: 1.0

Center

Center of the interface layer. This corresponds to the radius of the spherical droplet.

• Type: double
• Valid for: SphericalDiffuse
• Default: 100.0 a.u.

Width

Physical width of the interface layer. This value is divided by 6.0 internally.

• Type: double
• Valid for: SphericalDiffuse
• Default: 5.0 a.u.

Warning

Numerical instabilities may arise if a too small value is selected.

InterfaceOrigin

Center of the spherical droplet

• Type: array of doubles
• Valid for: SphericalDiffuse
• Default: \([0.0, 0.0, 0.0]\)

MaxL

Maximum value of the angular momentum in the expansion of the Green’s function for the spherical diffuse Green’s function

• Type: integer
• Valid for: SphericalDiffuse
• Default: 30

Molecule section keywords¶

It is possible to run the module standalone and use a classical charge distribution as specified in this section of the input. The run_pcm.x executable has to be compiled for a standalone run with:

python pcmsolver.py -x molecule.inp

where the molecule.inp input file looks like:

units = angstrom
codata = 2002
medium
{
	solvertype = cpcm
	correction = 0.5
    solvent = cyclohexane
}

cavity
{
	type = gepol
	area = 0.6
	radiiset = uff
	mode = implicit
}

molecule
{
    # x, y, z, q
    geometry = [0.000000000, 0.00000000,  0.08729478, 9.0,
                0.000000000, 0.00000000, -1.64558444, 1.0]
}

Geometry

Coordinates and charges of the molecular aggregate. Format is \([\ldots, x_i, y_i, z_i, Q_i, \ldots]\) Charges are always assumed to be in atomic units

• Type: array of doubles

Available radii¶

Available solvents¶

The macroscopic properties for the built-in list of solvents are:

• static permittivity, \(\varepsilon_s\)
• optical permittivity, \(\varepsilon_\infty\)
• probe radius, \(r_\mathrm{probe}\) in Angstrom.

The following table summarizes the built-in solvents and their properties. Solvents are ordered by decreasing static permittivity.

Name	Formula	\(\varepsilon_s\)	\(\varepsilon_\infty\)	\(r_\mathrm{probe}\)
Water	H2O	78.39	1.776	1.385
Dimethylsulfoxide	DMSO	46.7	2.179	2.455
Nitromethane	CH3NO2	38.20	1.904	2.155
Acetonitrile	CH3CN	36.64	1.806	2.155
Methanol	CH3OH	32.63	1.758	1.855
Ethanol	CH3CH2OH	24.55	1.847	2.180
Acetone	C2H6CO	20.7	1.841	2.38
1,2-Dichloroethane	C2H4Cl2	10.36	2.085	2.505
Methylenechloride	CH2Cl2	8.93	2.020	2.27
Tetrahydrofurane	THF	7.58	1.971	2.9
Aniline	C6H5NH2	6.89	2.506	2.80
Chlorobenzene	C6H5Cl	5.621	2.320	2.805
Chloroform	CHCl3	4.90	2.085	2.48
Toluene	C6H5CH3	2.379	2.232	2.82
Benzene	C6H6	2.247	2.244	2.630
Carbon tetrachloride	CCl4	2.228	2.129	2.685
Cyclohexane	C6H12	2.023	2.028	2.815
N-heptane	C7H16	1.92	1.918	3.125

For the impatients: tl;dr¶

In these examples, we want to show how every function in the API works. If your program is written in Fortran, head over to Interfacing with a Fortran host If your program is written in C/C++, head over to Interfacing with a C host

How PCMSolver handles potentials and charges: surface functions¶

Electrostatic potential vectors and the corresponding apparent surface charge vectors are handled internally as surface functions. The actual values are stored into Eigen vectors and saved into a map. The mapping is between the name of the surface function, given by the programmer writing the interface to the library, and the vector holding the values.

What you should care about: API functions¶

These are the contents of the pcmsolver.h file defining the public API of the PCMSolver library. The Fortran bindings for the API are in the pcmsolver.F90 file. The indexing of symmetry operations and their mapping to a bitstring is explained in the following Table. This is important when passing symmetry information to the pcmsolver_new() function.

Host input forwarding¶

struct PCMInput¶

Data structure for host-API input communication.

Forward-declare PCMInput input wrapping struct

Public Members

char cavity_type[8]¶

Type of cavity requested.

int patch_level¶

Wavelet cavity mesh patch level.

double coarsity¶

Wavelet cavity mesh coarsity.

double area¶

Average tesserae area.

char radii_set[8]¶

The built-in radii set to be used.

double min_distance¶

Minimal distance between sampling points.

int der_order¶

Derivative order for the switching function.

pcmsolver_bool_t scaling¶

Whether to scale or not the atomic radii.

char restart_name[20]¶

Name of the .npz file for GePol cavity restart.

double min_radius¶

Minimal radius for the added spheres.

char solver_type[7]¶

Type of solver requested.

double correction¶

Correction in the CPCM apparent surface charge scaling factor.

char solvent[16]¶

Name of the solvent.

double probe_radius¶

Radius of the spherical probe mimicking the solvent.

char equation_type[11]¶

Type of the integral equation to be used.

char inside_type[7]¶

Type of Green’s function requested inside the cavity.

double outside_epsilon¶

Value of the static permittivity outside the cavity.

char outside_type[22]¶

Type of Green’s function requested outside the cavity.

Internal details of the API¶

Including header files¶

Do not include header files unnecessarily. Even if PCMSolver is not a big project, unnecessary include directives and/or forward declarations introduce nasty interdependencies among different parts of the code. This reflects mainly in longer compilation times, but also in uglier looking code (see also the discussion in [Sut99]).

Follow these guidelines to decide whether to include or forward declare:

1. class A makes no reference to class B. Neither include nor forward declare B;
2. class A refers to class B as a friend. Neither include nor forward declare B;
3. class A contains a pointer/reference to a class B object. Forward declare B;
4. class A contains functions with a class B object (value/pointer/reference) as parameter/return value. Forward declare B;
5. class A is derived from class B. include B;
6. class A contains a class B object. include B.

#ifndef MYCLASS_HPP
#define MYCLASS_HPP

//==============================
// Forward declared dependencies
class Foo;
class Bar;

//==============================
// Included dependencies
#include <vector>
#include "Parent.hpp"

//==============================
// The actual class
class MyClass : public Parent // Parent object, so #include "Parent.h"
{
  public:
    std::vector<int> avector; // vector object, so #include <vector>
    Foo * foo;                // Foo pointer, so forward declare
    void Func(Bar & bar);     // Bar reference as parameter, so forward declare

    friend class MyFriend;    // friend declaration is not a dependency
                              //    don't do anything about MyFriend
};

#endif // MYCLASS_HPP

Proper overloading of operator<<¶

Suppose we have an inheritance hierarchy made of an abstract base class, Base, and two derived classes, Derived1 and Derived2. In the Base class header file we will define a pure virtual private function printObject and provide a public friend overload of operator<<:

#include <iosfwd>

class Base
{
  public:
    // All your other very fancy public members
    friend std::ostream & operator<<(std::ostream & os, Base & base)
    {
            return base.printObject(os);
    }
  protected:
    // All your other very fancy protected members
  private:
    // All your other very fancy private members
    virtual std::ostream & printObject(std::ostream & os) = 0;
}

The printObject method can also be made (impure) virtual, it really depends on your class hierarchy. Derived1 and Derived2 header files will provide a public friend overload of operator<< (friendliness isn’t inherited, transitive or reciprocal) and an override for the printObject method:

#include <iosfwd>

#include "Base.hpp"

class Derived1 : public Base
{
  public:
    // All your other very fancy public members
    friend std::ostream & operator<<(std::ostream & os, Derived1 & derived)
    {
      return derived.printObject(os);
    }
  protected:
    // All your other very fancy protected members
  private:
    // All your other very fancy private members
    virtual std::ostream & printObject(std::ostream & os);
}

class Derived2 : public Base
{
  public:
    // All your other very fancy public members
    friend std::ostream & operator<<(std::ostream & os, Derived2 & derived)
    {
      return derived.printObject(os);
    }
  protected:
    // All your other very fancy protected members
  private:
    // All your other very fancy private members
    virtual std::ostream & printObject(std::ostream & os);
}

Code formatting¶

We conform to the so-called Linux (aka kernel) formatting style for C/C++ code (see http://en.wikipedia.org/wiki/Indent_style#Kernel_style) with minimal modifications. If uncertain on your code formatting use the Artistic Style command-line utility to rectify it:

astyle --style=linux --max-code-length=85 --indent-namespaces --keep-one-line-blocks filename

How and what to document¶

Doxygen enables documenting the code in the source code files thus removing a “barrier” for developers. To avoid that the code degenerates into a Big Ball of Mud, it is mandatory to document directly within the source code classes and functions. To document general programming principles, design choices, maintenance etc. you can create a .rst file in the doc directory. Remember to refer the new file inside the index.rst file (it won’t be parsed otherwise). Sphing uses reStructuredText and Markdown. Support for Markdown is not as extensive as for reStructuredText, see these comments Follow the guidelines in [WAB+14] regarding what to document.

How does this work?¶

To have an offline version of the documentation just issue make doc in the build directory. The HTML will be stored in doc/html. Open the doc/html/index.html file with your browser to see and browse the documentation.

Adding new source subdirectories and/or files¶

Developers HAVE TO manually list the sources in a given subdirectory of the main source directory src/. In our previous infrastructure this was not necessary, but the developers needed to trigger CMake to regenerate the Makefiles manually.

python make_cmake_files.py --libname=cavity --lang=CXX

# List of headers
list(APPEND headers_list Cavity.hpp Element.hpp GePolCavity.hpp RegisterCavityToFactory.hpp RestartCavity.hpp)

# List of sources
list(APPEND sources_list Cavity.cpp Element.cpp GePolCavity.cpp RestartCavity.cpp)

add_library(cavity OBJECT ${sources_list} ${headers_list})
set_target_properties(cavity PROPERTIES POSITION_INDEPENDENT_CODE 1 )
set_property(GLOBAL APPEND PROPERTY PCMSolver_HEADER_DIRS ${CMAKE_CURRENT_LIST_DIR})
# Sets install directory for all the headers in the list
foreach(_header ${headers_list})
   install(FILES ${_header} DESTINATION include/cavity)
endforeach()

target_link_libraries(myexe -lsomesystemlib)

Bump version¶

Version numbering follows the guidelines of semantic versioning To update, change the relevant field in the README.md file.

Updating Eigen distribution¶

The C++ linear algebra library Eigen comes bundled with the module. To update the distributed version one has to:

1. download the desired version of the library to a scratch location. Eigen’s website is: http://eigen.tuxfamily.org/

2. unpack the downloaded archive;

3. go into the newly created directory and create a build directory;

4. go into the newly created build directory and type the following (remember to substitute @PROJECT_SOURCE_DIR@ with the actual path)

   cmake .. -DCMAKE_INSTALL_PREFIX=@PROJECT_SOURCE_DIR@/external/eigen3
   

Remember to commit and push your modifications.

Updating the copyright notice¶

You need to have access to the pcmsolvermeta repository to update the copyright notice. The copyright notice text is in the file copyright_notice.txt in the tools directory. The script update_copyright.py will extract the text from the file, create the appropriate header and perform the update on the files in the subdirectory where it is invoked.

Release process¶

We have two repositories one public for the release, hosted on GitHub and one private for the development, hosted on GitLab. At release time the master branch on the private repository is synced to that of the public repository.

You need to compile the to-be-released code and run the unit test suite. If compilation works and all unit tests are passing then the code is ready to be released:

git push Origin release

Notice that Origin has been spelled with a capital O the reason being that the release branch gets pushed both to the private and the public repositories (trick explanation) In brief, you need to have a .git/config file that resembles the following:

[remote "origin"]
    url = git@gitlab.com:PCMSolver/pcmsolver.git
    fetch = +refs/heads/*:refs/remotes/origin/*
[remote "GitHub"]
    url = git@github.com:PCMSolver/pcmsolver.git
    fetch = +refs/heads/*:refs/remotes/GitHub/*
[remote "Origin"]
    url = git@gitlab.com:PCMSolver/pcmsolver.git
    url = git@github.com:PCMSolver/pcmsolver.git

Cavity¶

class Cavity¶

Abstract Base Class for cavities.

This class represents a cavity made of spheres, its surface being discretized in terms of finite elements.

Author

Krzysztof Mozgawa

Date

2011

Subclassed by GePolCavity, RestartCavity

Public Functions

Cavity()¶

Default constructor.

Cavity(const Sphere &sph)¶

Constructor from a single sphere.

Only used when we have to deal with a single sphere, i.e. in the unit tests

Parameters

• sph -

  the sphere

Cavity(const std::vector<Sphere> &sph)¶

Constructor from list of spheres.

Only used when we have to deal with a single sphere, i.e. in the unit tests

Parameters

• sph -

  the list of spheres

Cavity(const Molecule &molec)¶

Constructor from Molecule.

Parameters

• molec -

  the molecular aggregate

virtual void saveCavity(const std::string &fname = "cavity.npz")¶

Save cavity specification to file.

The cavity specification contains: 0. the number of finite elements, nElements;

1. the weight of the finite elements, elementArea;
2. the radius of the finite elements, elementRadius;
3. the centers of the finite elements, elementCenter;
4. the normal vectors relative to the centers, elementNormal. Each of these objects is saved in a separate .npy binary file and compressed into one .npz file. Notice that this is just the minimal set of data needed to restart an energy calculation.

virtual void loadCavity(const std::string &fname = "cavity.npz")¶

Load cavity specification from file.

Protected Attributes

std::vector<Sphere> spheres_¶

List of spheres.

Molecule molecule_¶

The molecule to be wrapped by the cavity.

PCMSolverIndex nElements_¶

Number of finite elements generated.

PCMSolverIndex nIrrElements_¶

Number of irreducible finite elements.

bool built¶

Whether the cavity has been built.

Eigen::Matrix3Xd elementCenter_¶

Coordinates of elements centers.

Eigen::Matrix3Xd elementNormal_¶

Outward-pointing normal vectors to the elements centers.

Eigen::VectorXd elementArea_¶

Elements areas.

int nSpheres_¶

Number of spheres.

Eigen::Matrix3Xd elementSphereCenter_¶

Centers of the sphere the elements belong to.

Eigen::VectorXd elementRadius_¶

Radii of the sphere the elements belong to.

Eigen::Matrix3Xd sphereCenter_¶

Spheres centers.

Eigen::VectorXd sphereRadius_¶

Spheres radii.

std::vector<Element> elements_¶

List of finite elements.

Symmetry pointGroup_¶

Molecular point group.

Private Functions

virtual void makeCavity() = 0¶

Creates the cavity and discretizes its surface.

Has to be implemented by classes lower down in the inheritance hierarchy

GePolCavity¶

class GePolCavity¶

A class for GePol cavity.

This class is an interface to the Fortran code PEDRA for the generation of cavities according to the GePol algorithm.

Author

Krzysztof Mozgawa, Roberto Di Remigio

Date

2011, 2016

Inherits from Cavity

Private Functions

virtual void makeCavity()¶

Creates the cavity and discretizes its surface.

Has to be implemented by classes lower down in the inheritance hierarchy

void build(const std::string &suffix, int maxts, int maxsp, int maxvert)¶

Driver for PEDRA Fortran module.

Parameters

• suffix -

  for the cavity.off and PEDRA.OUT files, the PID will also be added

• maxts -

  maximum number of tesserae

• maxsp -

  maximum number of spheres (original + added)

• maxvert -

  maximum number of vertices

void writeOFF(const std::string &suffix)¶

Writes the cavity.off file for visualizing the cavity.

Parameters

• suffix -

  for the cavity.off The full name of the visualization file will be cavity.off_suffix_PID

RestartCavity¶

class RestartCavity¶

A class for Restart cavity.

Author

Roberto Di Remigio

Date

2014

Inherits from Cavity

Public Functions

virtual void makeCavity()¶

Creates the cavity and discretizes its surface.

Has to be implemented by classes lower down in the inheritance hierarchy

IGreensFunction¶

class IGreensFunction¶

Interface for Green’s function classes.

The Non-Virtual Interface (NVI) idiom is used. Notice also that some of the return types are in some cases “auto”, meaning that we will let the compiler deduce them.

Author

Luca Frediani and Roberto Di Remigio

Date

2012-2015

Subclassed by GreensFunction< DerivativeTraits, IntegratorPolicy, ProfilePolicy, Derived >, GreensFunction< DerivativeTraits, IntegratorPolicy, Anisotropic, AnisotropicLiquid< DerivativeTraits, IntegratorPolicy > >, GreensFunction< DerivativeTraits, IntegratorPolicy, Sharp, SphericalSharp< DerivativeTraits, IntegratorPolicy > >, GreensFunction< DerivativeTraits, IntegratorPolicy, Uniform, UniformDielectric< DerivativeTraits, IntegratorPolicy > >, GreensFunction< DerivativeTraits, IntegratorPolicy, Uniform, Vacuum< DerivativeTraits, IntegratorPolicy > >, GreensFunction< DerivativeTraits, IntegratorPolicy, Yukawa, IonicLiquid< DerivativeTraits, IntegratorPolicy > >, GreensFunction< Numerical, IntegratorPolicy, ProfilePolicy, Derived >, GreensFunction< Numerical, IntegratorPolicy, ProfilePolicy, SphericalDiffuse< IntegratorPolicy, ProfilePolicy > >

Public Functions

double kernelS(const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the kernel of the \(\mathcal{S}\) integral operator, i.e. the value of the Greens’s function for the pair of points p1, p2: \( G(\mathbf{p}_1, \mathbf{p}_2)\)

Parameters

• p1 -

  first point

• p2 -

  second point

double kernelD(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the kernel of the \(\mathcal{D}\) integral operator for the pair of points p1, p2: \( [\boldsymbol{\varepsilon}\nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)]\cdot \mathbf{n}_{\mathbf{p}_2}\) To obtain the kernel of the \(\mathcal{D}^\dagger\) operator call this methods with \(\mathbf{p}_1\) and \(\mathbf{p}_2\) exchanged and with \(\mathbf{n}_{\mathbf{p}_2} = \mathbf{n}_{\mathbf{p}_1}\)

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

virtual bool uniform() const = 0¶

Whether the Green’s function describes a uniform environment

virtual Permittivity permittivity() const = 0¶

Returns a dielectric permittivity profile

virtual Eigen::MatrixXd singleLayer(const std::vector<Element> &e) const = 0¶

Calculates the matrix representation of the S operator

Parameters

• e -

  list of finite elements

virtual Eigen::MatrixXd doubleLayer(const std::vector<Element> &e) const = 0¶

Calculates the matrix representation of the D operator

Parameters

• e -

  list of finite elements

Protected Functions

virtual double kernelS_impl(const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const = 0¶

Returns value of the kernel of the \(\mathcal{S}\) integral operator, i.e. the value of the Greens’s function for the pair of points p1, p2: \( G(\mathbf{p}_1, \mathbf{p}_2)\)

Parameters

• p1 -

  first point

• p2 -

  second point

virtual double kernelD_impl(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const = 0¶

Returns value of the kernel of the \(\mathcal{D}\) integral operator for the pair of points p1, p2: \( [\boldsymbol{\varepsilon}\nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)]\cdot \mathbf{n}_{\mathbf{p}_2}\) To obtain the kernel of the \(\mathcal{D}^\dagger\) operator call this methods with \(\mathbf{p}_1\) and \(\mathbf{p}_2\) exchanged and with \(\mathbf{n}_{\mathbf{p}_2} = \mathbf{n}_{\mathbf{p}_1}\)

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

GreensFunction¶

template <typename DerivativeTraits, typename IntegratorPolicy, typename ProfilePolicy, typename Derived>

class GreensFunction¶

Templated interface for Green’s functions.

Author

Luca Frediani and Roberto Di Remigio

Date

2012-2014

Template Parameters

• DerivativeTraits -

  evaluation strategy for the function and its derivatives

• IntegratorPolicy -

  policy for the calculation of the matrix represenation of S and D

• ProfilePolicy -

  dielectric profile type

Inherits from IGreensFunction

Public Functions

virtual double derivativeSource(const Eigen::Vector3d &normal_p1, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the directional derivative of the Greens’s function for the pair of points p1, p2: \( \nabla_{\mathbf{p_1}}G(\mathbf{p}_1, \mathbf{p}_2)\cdot \mathbf{n}_{\mathbf{p}_1}\) Notice that this method returns the directional derivative with respect to the source point.

Parameters

• normal_p1 -

  the normal vector to p1

• p1 -

  first point

• p2 -

  second point

virtual double derivativeProbe(const Eigen::Vector3d &normal_p2, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the directional derivative of the Greens’s function for the pair of points p1, p2: \( \nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)\cdot \mathbf{n}_{\mathbf{p}_2}\) Notice that this method returns the directional derivative with respect to the probe point.

Parameters

• normal_p2 -

  the normal vector to p2

• p1 -

  first point

• p2 -

  second point

Eigen::Vector3d gradientSource(const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns full gradient of Greens’s function for the pair of points p1, p2: \( \nabla_{\mathbf{p_1}}G(\mathbf{p}_1, \mathbf{p}_2)\) Notice that this method returns the gradient with respect to the source point.

Parameters

• p1 -

  first point

• p2 -

  second point

Eigen::Vector3d gradientProbe(const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns full gradient of Greens’s function for the pair of points p1, p2: \( \nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)\) Notice that this method returns the gradient with respect to the probe point.

Parameters

• p1 -

  first point

• p2 -

  second point

virtual bool uniform() const¶

Whether the Green’s function describes a uniform environment

virtual Permittivity permittivity() const¶

Returns a dielectric permittivity profile

Protected Functions

virtual DerivativeTraits operator()(DerivativeTraits *source, DerivativeTraits *probe) const = 0¶

Evaluates the Green’s function given a pair of points

Parameters

• source -

  the source point

• probe -

  the probe point

virtual double kernelS_impl(const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the kernel of the \(\mathcal{S}\) integral operator, i.e. the value of the Greens’s function for the pair of points p1, p2: \( G(\mathbf{p}_1, \mathbf{p}_2)\)

Note

Relies on the implementation of operator() in the subclasses and that is all subclasses need to implement. Thus this method is marked __final.

Parameters

• p1 -

  first point

• p2 -

  second point

Vacuum¶

template <typename DerivativeTraits = AD_directional, typename IntegratorPolicy = CollocationIntegrator>

class Vacuum¶

Green’s function for vacuum.

Author

Luca Frediani and Roberto Di Remigio

Date

2012-2014

Template Parameters

• DerivativeTraits -

  evaluation strategy for the function and its derivatives

• IntegratorPolicy -

  policy for the calculation of the matrix represenation of S and D

Inherits from GreensFunction< DerivativeTraits, IntegratorPolicy, Uniform, Vacuum< DerivativeTraits, IntegratorPolicy > >

Public Functions

virtual Eigen::MatrixXd singleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the S operator

Parameters

• e -

  list of finite elements

virtual Eigen::MatrixXd doubleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the D operator

Parameters

• e -

  list of finite elements

Private Functions

virtual DerivativeTraits operator()(DerivativeTraits *sp, DerivativeTraits *pp) const¶

Evaluates the Green’s function given a pair of points

Parameters

• sp -

  the source point

• pp -

  the probe point

virtual double kernelD_impl(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the kernel of the \(\mathcal{D}\) integral operator for the pair of points p1, p2: \( [\boldsymbol{\varepsilon}\nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)]\cdot \mathbf{n}_{\mathbf{p}_2}\) To obtain the kernel of the \(\mathcal{D}^\dagger\) operator call this methods with \(\mathbf{p}_1\) and \(\mathbf{p}_2\) exchanged and with \(\mathbf{n}_{\mathbf{p}_2} = \mathbf{n}_{\mathbf{p}_1}\)

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

UniformDielectric¶

template <typename DerivativeTraits = AD_directional, typename IntegratorPolicy = CollocationIntegrator>

class UniformDielectric¶

Green’s function for uniform dielectric.

Author

Luca Frediani and Roberto Di Remigio

Date

2012-2015

Template Parameters

• DerivativeTraits -

  evaluation strategy for the function and its derivatives

• IntegratorPolicy -

  policy for the calculation of the matrix represenation of S and D

Inherits from GreensFunction< DerivativeTraits, IntegratorPolicy, Uniform, UniformDielectric< DerivativeTraits, IntegratorPolicy > >

Public Functions

virtual Eigen::MatrixXd singleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the S operator

Parameters

• e -

  list of finite elements

virtual Eigen::MatrixXd doubleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the D operator

Parameters

• e -

  list of finite elements

Private Functions

virtual DerivativeTraits operator()(DerivativeTraits *sp, DerivativeTraits *pp) const¶

Evaluates the Green’s function given a pair of points

Parameters

• sp -

  the source point

• pp -

  the probe point

virtual double kernelD_impl(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the kernel of the \(\mathcal{D}\) integral operator for the pair of points p1, p2: \( [\boldsymbol{\varepsilon}\nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)]\cdot \mathbf{n}_{\mathbf{p}_2}\) To obtain the kernel of the \(\mathcal{D}^\dagger\) operator call this methods with \(\mathbf{p}_1\) and \(\mathbf{p}_2\) exchanged and with \(\mathbf{n}_{\mathbf{p}_2} = \mathbf{n}_{\mathbf{p}_1}\)

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

IonicLiquid¶

template <typename DerivativeTraits = AD_directional, typename IntegratorPolicy = CollocationIntegrator>

class IonicLiquid¶

Green’s functions for ionic liquid, described by the linearized Poisson-Boltzmann equation.

Author

Luca Frediani, Roberto Di Remigio

Date

2013-2015

Template Parameters

• DerivativeTraits -

  evaluation strategy for the function and its derivatives

• IntegratorPolicy -

  policy for the calculation of the matrix represenation of S and D

Inherits from GreensFunction< DerivativeTraits, IntegratorPolicy, Yukawa, IonicLiquid< DerivativeTraits, IntegratorPolicy > >

Public Functions

virtual Eigen::MatrixXd singleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the S operator

Parameters

• e -

  list of finite elements

virtual Eigen::MatrixXd doubleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the D operator

Parameters

• e -

  list of finite elements

Private Functions

virtual DerivativeTraits operator()(DerivativeTraits *sp, DerivativeTraits *pp) const¶

Evaluates the Green’s function given a pair of points

Parameters

• sp -

  the source point

• pp -

  the probe point

virtual double kernelD_impl(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the directional derivative of the Greens’s function for the pair of points p1, p2: \( \nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)\cdot \mathbf{n}_{\mathbf{p}_2}\) Notice that this method returns the directional derivative with respect to the probe point, thus assuming that the direction is relative to that point.

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

AnisotropicLiquid¶

template <typename DerivativeTraits = AD_directional, typename IntegratorPolicy = CollocationIntegrator>

class AnisotropicLiquid¶

Green’s functions for anisotropic liquid, described by a tensorial permittivity.

Author

Roberto Di Remigio

Date

2015

Template Parameters

• DerivativeTraits -

  evaluation strategy for the function and its derivatives

• IntegratorPolicy -

  policy for the calculation of the matrix represenation of S and D

Inherits from GreensFunction< DerivativeTraits, IntegratorPolicy, Anisotropic, AnisotropicLiquid< DerivativeTraits, IntegratorPolicy > >

Public Functions

AnisotropicLiquid(const Eigen::Vector3d &eigen_eps, const Eigen::Vector3d &euler_ang)¶

Parameters

• eigen_eps -

  eigenvalues of the permittivity tensors

• euler_ang -

  Euler angles in degrees

AnisotropicLiquid(const Eigen::Vector3d &eigen_eps, const Eigen::Vector3d &euler_ang, double f)¶

Parameters

• eigen_eps -

  eigenvalues of the permittivity tensors

• euler_ang -

  Euler angles in degrees

virtual Eigen::MatrixXd singleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the S operator

Parameters

• e -

  list of finite elements

virtual Eigen::MatrixXd doubleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the D operator

Parameters

• e -

  list of finite elements

Private Functions

virtual DerivativeTraits operator()(DerivativeTraits *source, DerivativeTraits *probe) const¶

Evaluates the Green’s function given a pair of points

Parameters

• source -

  the source point

• probe -

  the probe point

virtual double kernelD_impl(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the kernel for the calculation of the \(\mathcal{D}\) integral operator for the pair of points p1, p2: \( [\boldsymbol{\varepsilon}\nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)]\cdot \mathbf{n}_{\mathbf{p}_2}\) To obtain the kernel of the \(\mathcal{D}^\dagger\) operator call this methods with \(\mathbf{p}_1\) and \(\mathbf{p}_2\) exchanged and with \(\mathbf{n}_{\mathbf{p}_2} = \mathbf{n}_{\mathbf{p}_1}\)

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

SphericalDiffuse¶

template <typename IntegratorPolicy = CollocationIntegrator, typename ProfilePolicy = OneLayerTanh>

class SphericalDiffuse¶

Green’s function for a diffuse interface with spherical symmetry.

This class is general, in the sense that no specific dielectric profile has been set in its definition. In principle any profile that can be described by:

1. a left-side dielectric constant;
2. a right-side dielectric constant;
3. an interface layer width;
4. an interface layer center can be used to define a new diffuse interface with spherical symmetry. The origin of the dielectric sphere can be changed by means of the constructor. The solution of the differential equation defining the Green’s function is always performed assuming that the dielectric sphere is centered in the origin of the coordinate system. Whenever the public methods are invoked to “sample” the Green’s function at a pair of points, a translation of the sampling points is performed first.

Author

Hui Cao, Ville Weijo, Luca Frediani and Roberto Di Remigio

Date

2010-2015

Template Parameters

• IntegratorPolicy -

  policy for the calculation of the matrix represenation of S and D

• ProfilePolicy -

  functional form of the diffuse layer

Inherits from GreensFunction< Numerical, IntegratorPolicy, ProfilePolicy, SphericalDiffuse< IntegratorPolicy, ProfilePolicy > >

Unnamed Group

int maxLGreen_¶

Parameters and functions for the calculation of the Green’s function, including Coulomb singularity

Maximum angular momentum in the __final summation over Legendre polynomials to obtain G

std::vector<RadialFunction<interfaces::StateType, interfaces::LnTransformedRadial, Zeta>> zeta_¶

First independent radial solution, used to build Green’s function.

Note

The vector has dimension maxLGreen_ and has r^l behavior

std::vector<RadialFunction<interfaces::StateType, interfaces::LnTransformedRadial, Omega>> omega_¶

Second independent radial solution, used to build Green’s function.

Note

The vector has dimension maxLGreen_ and has r^(-l-1) behavior

double imagePotentialComponent_impl(int L, const Eigen::Vector3d &sp, const Eigen::Vector3d &pp, double Cr12) const¶

Returns L-th component of the radial part of the Green’s function.

Note

This function shifts the given source and probe points by the location of the dielectric sphere.

Parameters

• L -

  angular momentum

• sp -

  source point

• pp -

  probe point

• Cr12 -

  Coulomb singularity separation coefficient

Unnamed Group

int maxLC_¶

Parameters and functions for the calculation of the Coulomb singularity separation coefficient

Maximum angular momentum to obtain C(r, r’), needed to separate the Coulomb singularity

RadialFunction<interfaces::StateType, interfaces::LnTransformedRadial, Zeta> zetaC_¶

First independent radial solution, used to build coefficient.

Note

This is needed to separate the Coulomb singularity and has r^l behavior

RadialFunction<interfaces::StateType, interfaces::LnTransformedRadial, Omega> omegaC_¶

Second independent radial solution, used to build coefficient.

Note

This is needed to separate the Coulomb singularity and has r^(-l-1) behavior

double coefficient_impl(const Eigen::Vector3d &sp, const Eigen::Vector3d &pp) const¶

Returns coefficient for the separation of the Coulomb singularity.

Note

This function shifts the given source and probe points by the location of the dielectric sphere.

Parameters

• sp -

  first point

• pp -

  second point

Public Functions

SphericalDiffuse(double e1, double e2, double w, double c, const Eigen::Vector3d &o, int l)¶

Constructor for a one-layer interface

Parameters

• e1 -

  left-side dielectric constant

• e2 -

  right-side dielectric constant

• w -

  width of the interface layer

• c -

  center of the diffuse layer

• o -

  center of the sphere

SphericalDiffuse(double e1, double e2, double w, double c, const Eigen::Vector3d &o, int l, double f)¶

Constructor for a one-layer interface

Parameters

• e1 -

  left-side dielectric constant

• e2 -

  right-side dielectric constant

• w -

  width of the interface layer

• c -

  center of the diffuse layer

• o -

  center of the sphere

virtual Eigen::MatrixXd singleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the S operator

Parameters

• e -

  list of finite elements

virtual Eigen::MatrixXd doubleLayer(const std::vector<Element> &e) const¶

Calculates the matrix representation of the D operator

Parameters

• e -

  list of finite elements

double coefficientCoulomb(const Eigen::Vector3d &source, const Eigen::Vector3d &probe) const¶

Returns Coulomb singularity separation coefficient.

Parameters

• source -

  location of the source charge

• probe -

  location of the probe charge

double Coulomb(const Eigen::Vector3d &source, const Eigen::Vector3d &probe) const¶

Returns singular part of the Green’s function.

Parameters

• source -

  location of the source charge

• probe -

  location of the probe charge

double imagePotential(const Eigen::Vector3d &source, const Eigen::Vector3d &probe) const¶

Returns non-singular part of the Green’s function (image potential)

Parameters

• source -

  location of the source charge

• probe -

  location of the probe charge

double coefficientCoulombDerivative(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the directional derivative of the Coulomb singularity separation coefficient for the pair of points p1, p2: \( \nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)\cdot \mathbf{n}_{\mathbf{p}_2}\) Notice that this method returns the directional derivative with respect to the probe point, thus assuming that the direction is relative to that point.

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

double CoulombDerivative(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the directional derivative of the singular part of the Greens’s function for the pair of points p1, p2: \( \nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)\cdot \mathbf{n}_{\mathbf{p}_2}\) Notice that this method returns the directional derivative with respect to the probe point, thus assuming that the direction is relative to that point.

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

double imagePotentialDerivative(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the directional derivative of the non-singular part (image potential) of the Greens’s function for the pair of points p1, p2: \( \nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)\cdot \mathbf{n}_{\mathbf{p}_2}\) Notice that this method returns the directional derivative with respect to the probe point, thus assuming that the direction is relative to that point.

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

pcm::tuple<double, double> epsilon(const Eigen::Vector3d &point) const¶

Handle to the dielectric profile evaluation

Private Functions

virtual Numerical operator()(Numerical *sp, Numerical *pp) const¶

Evaluates the Green’s function given a pair of points

Note

This takes care of the origin shift

Parameters

• sp -

  the source point

• pp -

  the probe point

virtual double kernelD_impl(const Eigen::Vector3d &direction, const Eigen::Vector3d &p1, const Eigen::Vector3d &p2) const¶

Returns value of the kernel of the \(\mathcal{D}\) integral operator for the pair of points p1, p2: \( [\boldsymbol{\varepsilon}\nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)]\cdot \mathbf{n}_{\mathbf{p}_2}\) To obtain the kernel of the \(\mathcal{D}^\dagger\) operator call this methods with \(\mathbf{p}_1\) and \(\mathbf{p}_2\) exchanged and with \(\mathbf{n}_{\mathbf{p}_2} = \mathbf{n}_{\mathbf{p}_1}\)

Parameters

• direction -

  the direction

• p1 -

  first point

• p2 -

  second point

void initProfilePolicy(double e1, double e2, double w, double c)¶

Initializes a one-layer profile

Parameters

• e1 -

  left-side dielectric constant

• e2 -

  right-side dielectric constant

• w -

  width of the interface layer

• c -

  center of the diffuse layer

void initSphericalDiffuse()¶

This calculates all the components needed to evaluate the Green’s function

Private Members

Eigen::Vector3d origin_¶

Center of the dielectric sphere

PCMSolver¶

class PCMSolver¶

Abstract Base Class for solvers inheritance hierarchy.

We use the Non-Virtual Interface idiom.

Author

Luca Frediani, Roberto Di Remigio

Date

2011, 2015

Subclassed by CPCMSolver, IEFSolver

Public Functions

void buildSystemMatrix(const Cavity &cavity, const IGreensFunction &gf_i, const IGreensFunction &gf_o)¶

Calculation of the PCM matrix.

Parameters

• cavity -

  the cavity to be used

• gf_i -

  Green’s function inside the cavity

• gf_o -

  Green’s function outside the cavity

Eigen::VectorXd computeCharge(const Eigen::VectorXd &potential, int irrep = 0) const¶

Returns the ASC given the MEP and the desired irreducible representation.

Parameters

• potential -

  the vector containing the MEP at cavity points

• irrep -

  the irreducible representation of the MEP and ASC

Protected Functions

virtual void buildSystemMatrix_impl(const Cavity &cavity, const IGreensFunction &gf_i, const IGreensFunction &gf_o) = 0¶

Calculation of the PCM matrix.

Parameters

• cavity -

  the cavity to be used

• gf_i -

  Green’s function inside the cavity

• gf_o -

  Green’s function outside the cavity

virtual Eigen::VectorXd computeCharge_impl(const Eigen::VectorXd &potential, int irrep = 0) const = 0¶

Returns the ASC given the MEP and the desired irreducible representation.

Parameters

• potential -

  the vector containing the MEP at cavity points

• irrep -

  the irreducible representation of the MEP and ASC

Protected Attributes

bool built_¶

Whether the system matrix has been built

bool isotropic_¶

Whether the solver is isotropic

IEFSolver¶

class IEFSolver¶

IEFPCM, collocation-based solver.

Author

Luca Frediani, Roberto Di Remigio

Date

2011, 2015, 2016

Note

We store the non-Hermitian, symmetry-blocked T(epsilon) and Rinfinity matrices. The ASC is obtained by multiplying the MEP by Rinfinity and then using a partially pivoted LU decomposition of T(epsilon) on the resulting vector. In case the polarization weights are requested, we use the approach suggested in [2]. First, the adjoint problem is solved:

\[ \mathbf{T}_\varepsilon^\dagger \tilde{v} = v \]

Also in this case a partially pivoted LU decomposition is used. The “transposed” ASC is obtained by the matrix-vector multiplication:

\[ q^* = \mathbf{R}_\infty^\dagger \tilde{v} \]

Eventually, the two sets of charges are summed and divided by 2 This avoids computing and storing the inverse explicitly, at the expense of storing both T(epsilon) and Rinfinity.

Inherits from PCMSolver

Public Functions

IEFSolver(bool symm)¶

Construct solver.

Parameters

• symm -

  whether the system matrix has to be symmetrized

void buildAnisotropicMatrix(const Cavity &cavity, const IGreensFunction &gf_i, const IGreensFunction &gf_o)¶

Builds PCM matrix for an anisotropic environment.

Parameters

• cavity -

  the cavity to be used.

• gf_i -

  Green’s function inside the cavity

• gf_o -

  Green’s function outside the cavity

void buildIsotropicMatrix(const Cavity &cavity, const IGreensFunction &gf_i, const IGreensFunction &gf_o)¶

Builds PCM matrix for an isotropic environment.

Parameters

• cavity -

  the cavity to be used.

• gf_i -

  Green’s function inside the cavity

• gf_o -

  Green’s function outside the cavity

Private Functions

virtual void buildSystemMatrix_impl(const Cavity &cavity, const IGreensFunction &gf_i, const IGreensFunction &gf_o)¶

Calculation of the PCM matrix.

Parameters

• cavity -

  the cavity to be used

• gf_i -

  Green’s function inside the cavity

• gf_o -

  Green’s function outside the cavity

virtual Eigen::VectorXd computeCharge_impl(const Eigen::VectorXd &potential, int irrep = 0) const¶

Returns the ASC given the MEP and the desired irreducible representation.

Parameters

• potential -

  the vector containing the MEP at cavity points

• irrep -

  the irreducible representation of the MEP and ASC

Private Members

bool hermitivitize_¶

Whether the system matrix has to be symmetrized

Eigen::MatrixXd Tepsilon_¶

T(epsilon) matrix, not symmetry blocked

std::vector<Eigen::MatrixXd> blockTepsilon_¶

T(epsilon) matrix, symmetry blocked form

Eigen::MatrixXd Rinfinity_¶

R_infinity matrix, not symmetry blocked

std::vector<Eigen::MatrixXd> blockRinfinity_¶

R_infinity matrix, symmetry blocked form

CPCMSolver¶

class CPCMSolver¶

Solver for conductor-like approximation: C-PCM (COSMO)

Author

Roberto Di Remigio

Date

2013, 2016

Note

We store the scaled, Hermitian, symmetrized S matrix and use a robust Cholesky decomposition to solve for the ASC. This avoids computing and storing the inverse explicitly. The S matrix is already scaled by the dielectric factor entering the definition of the conductor model!

Inherits from PCMSolver

Public Functions

CPCMSolver(bool symm, double corr)¶

Construct solver.

Parameters

• symm -

  whether the system matrix has to be symmetrized

• corr -

  factor to correct the conductor results

Private Functions

virtual void buildSystemMatrix_impl(const Cavity &cavity, const IGreensFunction &gf_i, const IGreensFunction &gf_o)¶

Calculation of the PCM matrix.

Parameters

• cavity -

  the cavity to be used

• gf_i -

  Green’s function inside the cavity

• gf_o -

  Green’s function outside the cavity

virtual Eigen::VectorXd computeCharge_impl(const Eigen::VectorXd &potential, int irrep = 0) const¶

Returns the ASC given the MEP and the desired irreducible representation.

Parameters

• potential -

  the vector containing the MEP at cavity points

• irrep -

  the irreducible representation of the MEP and ASC

Private Members

bool hermitivitize_¶

Whether the system matrix has to be symmetrized

double correction_¶

Correction for the conductor results

Eigen::MatrixXd S_¶

S matrix, not symmetry blocked

std::vector<Eigen::MatrixXd> blockS_¶

S matrix, symmetry blocked form

Input¶

class Input¶

A wrapper class for the Getkw Library C++ bindings.

An Input object is to be used as the unique point of access to user-provided input: input > parsed input (Python script) > Input object (contains all the input data) Definition of input parameters is to be done in the Python script and in this class. They must be specified as private data members with public accessor methods (get-ters). Most of the data members are anyway accessed through the input wrapping struct-s In general, no mutator methods (set-ters) should be needed, exceptions to this rule should be carefully considered.

Author

Roberto Di Remigio

Date

2013

Public Functions

Input()¶

Default constructor.

Input(const std::string &filename)¶

Constructor from human-readable input file name.

Input(const PCMInput &host_input)¶

Constructor from host input structs.

std::string units() const¶

Accessor methods.

Top-level section input

std::string cavityType() const¶

Cavity section input.

void molecule(const Molecule &m)¶

This method sets the molecule and the list of spheres.

Solvent solvent() const¶

Medium section input.

std::string greenInsideType() const¶

Green’s function section input.

std::string providedBy() const¶

Keeps track of who did the parsing: the API or the host program.

cavityData cavityParams()¶

Get-ters for input wrapping structs.

Private Functions

void reader(const PCMInput &host_input)¶

Read host data structures (host-side syntactic input parsing) into Input object. It provides access to a limited number of options only, basically the ones that can be filled into the cavityInput, solverInput and greenInput data structures. Lengths and areas are expected to be in Angstrom/Angstrom^2 and will hence be converted to au/au^2.

Note

Specification of the solvent by name overrides any input given through the greenInput data structure!

Warning

The cavity can only be built in the “Implicit” mode, i.e. by grabbing the coordinates for the sphere centers from the host program. Atomic coordinates are expected to be in au! The “Atoms” and “Explicit” methods are only available using the explicit parsing by our Python script of a separate input file.

void semanticCheck() const¶

Perform semantic input parsing aka sanity check

Private Members

std::string units_¶

Units of measure.

int CODATAyear_¶

Year of the CODATA set to be used.

std::string type_¶

The type of cavity.

std::string cavFilename_¶

Filename for the .npz cavity restart file.

std::string dyadicFilename_¶

Filename for the wavelet cavity dyadic file.

int patchLevel_¶

Wavelet cavity patch level.

double coarsity_¶

Wavelet cavity coarsity.

double area_¶

GePol and TsLess cavities average element area.

double minDistance_¶

TsLess cavity minimal distance between sampling points.

int derOrder_¶

TsLess cavity maximum derivative order of switch function.

bool scaling_¶

Whether the radii should be scaled by 1.2.

std::string radiiSet_¶

The set of radii to be used.

double minimalRadius_¶

Minimal radius of an added sphere.

std::string mode_¶

How the API should get the coordinates of the sphere centers.

std::vector<int> atoms_¶

List of selected atoms with custom radii.

std::vector<double> radii_¶

List of radii attached to the selected atoms.

std::vector<Sphere> spheres_¶

List of spheres for fully custom cavity generation.

Molecule molecule_¶

Molecule or atomic aggregate.

Solvent solvent_¶

The solvent for a vacuum/uniform dielectric run.

bool hasSolvent_¶

Whether the medium was initialized from a solvent object.

std::string solverType_¶

The solver type.

int equationType_¶

The integral equation type (wavelet solvers)

double correction_¶

Correction factor (C-PCM)

bool hermitivitize_¶

Whether the PCM matrix should be hermitivitized (collocation solvers)

bool isDynamic_¶

Whether the dynamic PCM matrix should be used.

double probeRadius_¶

Solvent probe radius.

int integratorType_¶

Type of integrator for the diagonal of the boundary integral operators.

double integratorScaling_¶

Scaling factor for the diagonal of the approximate collocation boundary integral operators.

std::string greenInsideType_¶

The Green’s function type inside the cavity.

std::string greenOutsideType_¶

The Green’s function type outside the cavity.

int derivativeInsideType_¶

How to calculate Green’s function derivatives inside the cavity.

int derivativeOutsideType_¶

How to calculate Green’s function derivatives outside the cavity.

double epsilonInside_¶

Permittivity inside the cavity.

double epsilonStaticOutside_¶

Static permittivity outside the cavity.

double epsilonDynamicOutside_¶

Dynamic permittivity outside the cavity.

double epsilonReal_¶

Real part of the metal NP permittivity.

double epsilonImaginary_¶

Imaginary part of the metal NP permittivity.

std::vector<double> spherePosition_¶

Center of the spherical metal NP.

double sphereRadius_¶

Radius of the spherical metal NP.

double epsilonStatic1_¶

Diffuse interface: static permittivity inside the interface.

double epsilonDynamic1_¶

Diffuse interface: dynamic permittivity inside the interface.

double epsilonStatic2_¶

Diffuse interface: static permittivity outside the interface.

double epsilonDynamic2_¶

Diffuse interface: dynamic permittivity outside the interface.

double center_¶

Center of the diffuse interface.

double width_¶

Width of the diffuse interface.

int profileType_¶

Profile chosen for the diffuse interface.

int maxL_¶

Maximum angular momentum.

std::vector<double> origin_¶

Center of the dielectric sphere.

std::vector<double> geometry_¶

Molecular geometry.

std::string providedBy_¶

Who performed the syntactic input parsing.

cavityData cavData_¶

Input wrapping struct for the cavity.

greenData insideGreenData_¶

Input wrapping struct for the Green’s function inside.

greenData outsideStaticGreenData_¶

Input wrapping struct for the Green’s function outside (static permittivity)

greenData outsideDynamicGreenData_¶

Input wrapping struct for the Green’s function outside (dynamic permittivity)

solverData solverData_¶

Input wrapping struct for the solver.

Friends

std::ostream &operator<<(std::ostream &os, const Input &input)¶

Operators operator<<