ddx.h

Go to the documentation of this file.

#ifndef DDX_H
#define DDX_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
void ddx_get_banner(char* banner, int maxlen);
 
int ddx_supported_lebedev_grids(int maxlen, int* grids);
 
void ddx_scaled_ylm(const void* ddx, int lmax, const double* x, int sphere, double* ylm);
 
 
void* ddx_allocate_error();
 
int ddx_get_error_flag(const void* error);
 
void ddx_get_error_message(const void* error, char* message, int maxlen);
 
 
 
void* ddx_allocate_electrostatics(void* ddx, void* error);
 
void ddx_multipole_electrostatics(void* ddx, int nsph, int nmultipoles,
                                  const double* multipoles,
                                  void* electrostatics, void* error);
 
void ddx_deallocate_electrostatics(void* electrostatics, void* error);
 
 
 
void* ddx_allocate_model(int model, int enable_force, double solvent_epsilon,
                         double solvent_kappa, double eta, double shift, int lmax,
                         int n_lebedev, int incore, int maxiter, int jacobi_n_diis,
                         int enable_fmm, int fmm_multipole_lmax, int fmm_local_lmax,
                         int n_proc, int n_spheres, const double* sphere_centres,
                         const double* sphere_radii, int length_logfile,
                         const char* logfile, void* error);
 
void ddx_deallocate_model(void* ddx, void* error);
 
 
 
void ddx_get_logfile(const void* ddx, char* logfile, int maxlen);
 
// Generated block, see scripts/generate_cinterface_setup.py.
int ddx_get_enable_fmm(const void* ddx);
 
int ddx_get_enable_force(const void* ddx);
 
int ddx_get_jacobi_n_diis(const void* ddx);
 
int ddx_get_lmax(const void* ddx);
 
int ddx_get_incore(const void* ddx);
 
int ddx_get_maxiter(const void* ddx);
 
int ddx_get_model(const void* ddx);
 
int ddx_get_n_lebedev(const void* ddx);
 
int ddx_get_n_proc(const void* ddx);
 
int ddx_get_n_spheres(const void* ddx);
 
int ddx_get_fmm_local_lmax(const void* ddx);
 
int ddx_get_fmm_multipole_lmax(const void* ddx);
 
double ddx_get_solvent_epsilon(const void* ddx);
 
double ddx_get_eta(const void* ddx);
 
double ddx_get_solvent_kappa(const void* ddx);
 
double ddx_get_shift(const void* ddx);
 
void ddx_get_sphere_charges(const void* ddx, int nsph, double* c_charge);
 
void ddx_get_sphere_centres(const void* ddx, int nsph, double* c_csph);
 
void ddx_get_sphere_radii(const void* ddx, int nsph, double* c_rsph);
 
int ddx_get_n_basis(const void* ddx);
 
int ddx_get_n_cav(const void* ddx);
 
void ddx_get_cavity(const void* ddx, int ncav, double* c_ccav);
// end generated block
 
 
void* ddx_allocate_state(const void* ddx, void* error);
 
void ddx_deallocate_state(void* state, void* error);
 
void ddx_get_x(const void* state, int nbasis, int nsph, double* x);
 
int ddx_get_x_niter(const void* state);
 
void ddx_get_s(const void* state, int nbasis, int nsph, double* s);
 
int ddx_get_s_niter(const void* state);
 
void ddx_get_xi(const void* state, const void* ddx, int ncav, double* xi);
 
void ddx_get_zeta_dip(const void* state, const void* ddx, int ncav, double* zeta_dip);
 
 
double ddx_ddsolve(const void* ddx, void* state, const void* electrostatics,
                   int nbasis, int nsph, const double* psi, double tol,
                   double* forces, const int read_guess, void* error);
 
void ddx_setup(const void* ddx, void* state, const void* electrostatics,
               int nbasis, int nsph, const double* psi, void* error);
 
void ddx_fill_guess(const void* ddx, void* state, double tol, void* error);
 
void ddx_fill_guess_adjoint(const void* ddx, void* state, double tol, void* error);
 
void ddx_solve(const void* ddx, void* state, double tol, void* error);
 
void ddx_solve_adjoint(const void* ddx, void* state, double tol, void* error);
 
double ddx_energy(const void* ddx, void* state, void* error);
 
void ddx_solvation_force_terms(const void* ddx, void* state, void* electrostatics,
                               int nsph, double* forces, void* error);
 
double ddx_ddrun(const void* ddx, void* state, void* electrostatics, int nbasis,
                 int nsph, double* psi, const double tol, double* forces,
                 int read_guess, void* error);
 
 
 
void ddx_cosmo_setup(const void* ddx, void* state, int ncav, int nbasis, int nsph,
                     const double* psi, const double* phi_cav, void* error);
 
void ddx_cosmo_guess(const void* ddx, void* state, void* error);
 
void ddx_cosmo_guess_adjoint(const void* ddx, void* state, void* error);
 
void ddx_cosmo_solve(const void* ddx, void* state, double tol, void* error);
 
void ddx_cosmo_solve_adjoint(const void* ddx, void* state, double tol, void* error);
 
double ddx_cosmo_energy(const void* ddx, void* state, void* error);
 
void ddx_cosmo_solvation_force_terms(const void* ddx, void* state, int nsph,
                                     int ncav, const double* e_cav,
                                     double* forces, void* error);
 
void ddx_pcm_setup(const void* ddx, void* state, int ncav, int nbasis, int nsph,
                   const double* psi, const double* phi_cav, void* error);
 
void ddx_pcm_guess(const void* ddx, void* state, void* error);
 
void ddx_pcm_guess_adjoint(const void* ddx, void* state, void* error);
 
void ddx_pcm_solve(const void* ddx, void* state, double tol, void* error);
 
void ddx_pcm_solve_adjoint(const void* ddx, void* state, double tol, void* error);
 
double ddx_pcm_energy(const void* ddx, void* state, void* error);
 
void ddx_pcm_solvation_force_terms(const void* ddx, void* state, int nsph,
                                   int ncav, const double* e_cav,
                                   double* forces, void* error);
 
void ddx_lpb_setup(const void* ddx, void* state, int ncav, int nbasis, int nsph,
                   const double* psi, const double* phi_cav, const double* e_cav,
                   void* error);
 
void ddx_lpb_guess(const void* ddx, void* state, double tol, void* error);
 
void ddx_lpb_guess_adjoint(const void* ddx, void* state, double tol, void* error);
 
void ddx_lpb_solve(const void* ddx, void* state, double tol, void* error);
 
void ddx_lpb_solve_adjoint(const void* ddx, void* state, double tol, void* error);
 
double ddx_lpb_energy(const void* ddx, void* state, void* error);
 
void ddx_lpb_solvation_force_terms(const void* ddx, void* state, int nsph,
                                   int ncav, const double* g_cav,
                                   double* forces, const void* error);
 
 
 
void ddx_multipole_electrostatics_0(const void* ddx, int nsph, int ncav, int nmultipoles,
                                    const double* multipoles, double* phi_cav, void* error);
 
void ddx_multipole_electrostatics_1(const void* ddx, int nsph, int ncav, int nmultipoles,
                                    const double* multipoles, double* phi_cav,
                                    double* e_cav, void* error);
 
void ddx_multipole_electrostatics_2(const void* ddx, int nsph, int ncav, int nmultipoles,
                                    const double* multipoles, double* phi_cav,
                                    double* e_cav, double* g_cav, void* error);
 
void ddx_multipole_psi(const void* ddx, int nbasis, int nsph, int nmultipoles,
                       const double* multipoles, double* psi, void* error);
 
void ddx_multipole_force_terms(const void* ddx, void* state, int nsph,
                               int nmultipoles, const double* multipoles,
                               double* forces, void* error);
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* DDX_H */